Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 35.8s

Alternatives: 25

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, 1.0× speedup

Math

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

FPCore

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

Python

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

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp(((Vef + (Ev + (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[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\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}}} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

4. Final simplification 100.0%

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

Alternative 2: 76.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_2 := t_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_3 := t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;mu \leq -3.5 \cdot 10^{+199}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -8 \cdot 10^{+86}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -2.65 \cdot 10^{-8}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 1.5 \cdot 10^{-169}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;mu \leq 2.65 \cdot 10^{-61}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{+172}:\\ \;\;\;\;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 (+ Ev (- EAccept mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
        (t_2 (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT))))))
        (t_3 (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
   (if (<= mu -3.5e+199)
     t_2
     (if (<= mu -8e+86)
       t_1
       (if (<= mu -2.65e-8)
         t_2
         (if (<= mu 1.5e-169)
           t_3
           (if (<= mu 2.65e-61) t_1 (if (<= mu 1.6e+172) 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 + (Ev + (EAccept - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	double t_3 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	double tmp;
	if (mu <= -3.5e+199) {
		tmp = t_2;
	} else if (mu <= -8e+86) {
		tmp = t_1;
	} else if (mu <= -2.65e-8) {
		tmp = t_2;
	} else if (mu <= 1.5e-169) {
		tmp = t_3;
	} else if (mu <= 2.65e-61) {
		tmp = t_1;
	} else if (mu <= 1.6e+172) {
		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 + (ev + (eaccept - mu))) / kbt)))
    t_1 = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    t_2 = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    t_3 = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
    if (mu <= (-3.5d+199)) then
        tmp = t_2
    else if (mu <= (-8d+86)) then
        tmp = t_1
    else if (mu <= (-2.65d-8)) then
        tmp = t_2
    else if (mu <= 1.5d-169) then
        tmp = t_3
    else if (mu <= 2.65d-61) then
        tmp = t_1
    else if (mu <= 1.6d+172) 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 + (Ev + (EAccept - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double t_3 = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	double tmp;
	if (mu <= -3.5e+199) {
		tmp = t_2;
	} else if (mu <= -8e+86) {
		tmp = t_1;
	} else if (mu <= -2.65e-8) {
		tmp = t_2;
	} else if (mu <= 1.5e-169) {
		tmp = t_3;
	} else if (mu <= 2.65e-61) {
		tmp = t_1;
	} else if (mu <= 1.6e+172) {
		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 + (Ev + (EAccept - mu))) / KbT)))
	t_1 = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	t_2 = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	t_3 = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	tmp = 0
	if mu <= -3.5e+199:
		tmp = t_2
	elif mu <= -8e+86:
		tmp = t_1
	elif mu <= -2.65e-8:
		tmp = t_2
	elif mu <= 1.5e-169:
		tmp = t_3
	elif mu <= 2.65e-61:
		tmp = t_1
	elif mu <= 1.6e+172:
		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(Ev + Float64(EAccept - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	t_2 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	t_3 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	tmp = 0.0
	if (mu <= -3.5e+199)
		tmp = t_2;
	elseif (mu <= -8e+86)
		tmp = t_1;
	elseif (mu <= -2.65e-8)
		tmp = t_2;
	elseif (mu <= 1.5e-169)
		tmp = t_3;
	elseif (mu <= 2.65e-61)
		tmp = t_1;
	elseif (mu <= 1.6e+172)
		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 + (Ev + (EAccept - mu))) / KbT)));
	t_1 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	t_2 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	t_3 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	tmp = 0.0;
	if (mu <= -3.5e+199)
		tmp = t_2;
	elseif (mu <= -8e+86)
		tmp = t_1;
	elseif (mu <= -2.65e-8)
		tmp = t_2;
	elseif (mu <= 1.5e-169)
		tmp = t_3;
	elseif (mu <= 2.65e-61)
		tmp = t_1;
	elseif (mu <= 1.6e+172)
		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[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -3.5e+199], t$95$2, If[LessEqual[mu, -8e+86], t$95$1, If[LessEqual[mu, -2.65e-8], t$95$2, If[LessEqual[mu, 1.5e-169], t$95$3, If[LessEqual[mu, 2.65e-61], t$95$1, If[LessEqual[mu, 1.6e+172], t$95$3, t$95$2]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -3.49999999999999981e199 or -8.0000000000000001e86 < mu < -2.6499999999999999e-8 or 1.59999999999999993e172 < mu

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 87.6%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{mu}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if -3.49999999999999981e199 < mu < -8.0000000000000001e86 or 1.5e-169 < mu < 2.65e-61

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 79.2%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{EDonor}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if -2.6499999999999999e-8 < mu < 1.5e-169 or 2.65e-61 < mu < 1.59999999999999993e172

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 82.1%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 83.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -3.5 \cdot 10^{+199}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -8 \cdot 10^{+86}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq -2.65 \cdot 10^{-8}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.5 \cdot 10^{-169}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.65 \cdot 10^{-61}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{+172}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]

Alternative 3: 74.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;Vef \leq -1 \cdot 10^{+130}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;Vef \leq 1.75 \cdot 10^{-202}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq 7.6 \cdot 10^{-144}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq 7.8 \cdot 10^{+71}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NaChar (+ 1.0 (exp (/ (+ Vef Ev) KbT))))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= Vef -1e+130)
     t_0
     (if (<= Vef 1.75e-202)
       t_1
       (if (<= Vef 7.6e-144)
         (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
         (if (<= Vef 7.8e+71) t_1 t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp(((Vef + Ev) / KbT))));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (Vef <= -1e+130) {
		tmp = t_0;
	} else if (Vef <= 1.75e-202) {
		tmp = t_1;
	} else if (Vef <= 7.6e-144) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	} else if (Vef <= 7.8e+71) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp(((vef + ev) / kbt))))
    t_1 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    if (vef <= (-1d+130)) then
        tmp = t_0
    else if (vef <= 1.75d-202) then
        tmp = t_1
    else if (vef <= 7.6d-144) then
        tmp = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    else if (vef <= 7.8d+71) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + Ev) / KbT))));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (Vef <= -1e+130) {
		tmp = t_0;
	} else if (Vef <= 1.75e-202) {
		tmp = t_1;
	} else if (Vef <= 7.6e-144) {
		tmp = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	} else if (Vef <= 7.8e+71) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp(((Vef + Ev) / KbT))))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if Vef <= -1e+130:
		tmp = t_0
	elif Vef <= 1.75e-202:
		tmp = t_1
	elif Vef <= 7.6e-144:
		tmp = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)))
	elif Vef <= 7.8e+71:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Ev) / KbT)))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (Vef <= -1e+130)
		tmp = t_0;
	elseif (Vef <= 1.75e-202)
		tmp = t_1;
	elseif (Vef <= 7.6e-144)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))));
	elseif (Vef <= 7.8e+71)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp(((Vef + Ev) / KbT))));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (Vef <= -1e+130)
		tmp = t_0;
	elseif (Vef <= 1.75e-202)
		tmp = t_1;
	elseif (Vef <= 7.6e-144)
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	elseif (Vef <= 7.8e+71)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + Ev), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -1e+130], t$95$0, If[LessEqual[Vef, 1.75e-202], t$95$1, If[LessEqual[Vef, 7.6e-144], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 7.8e+71], t$95$1, t$95$0]]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -1.0000000000000001e130 or 7.8000000000000002e71 < Vef

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 87.6%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in Ev around inf 82.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \color{blue}{Ev}}{KbT}}} \]

   if -1.0000000000000001e130 < Vef < 1.75e-202 or 7.59999999999999985e-144 < Vef < 7.8000000000000002e71

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 74.9%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{EDonor}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if 1.75e-202 < Vef < 7.59999999999999985e-144

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 65.4%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 50.2%

      \[\leadsto \color{blue}{\frac{KbT \cdot NdChar}{EDonor}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-/l* 43.8%

         \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Simplified 43.8%

      \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   8. Taylor expanded in KbT around 0 93.1%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 78.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -1 \cdot 10^{+130}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.75 \cdot 10^{-202}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 7.6 \cdot 10^{-144}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq 7.8 \cdot 10^{+71}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \end{array} \]

Alternative 4: 61.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{if}\;Ec \leq -1.05 \cdot 10^{+180}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;Ec \leq -1.9 \cdot 10^{-35}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{elif}\;Ec \leq 7.5 \cdot 10^{-237}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \mathbf{elif}\;Ec \leq 4.8 \cdot 10^{+135} \lor \neg \left(Ec \leq 5.8 \cdot 10^{+226}\right) \land Ec \leq 1.25 \cdot 10^{+259}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{-\frac{Ec}{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 (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))))
   (if (<= Ec -1.05e+180)
     t_0
     (if (<= Ec -1.9e-35)
       (+
        NdChar
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
       (if (<= Ec 7.5e-237)
         (+
          (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NaChar (+ 1.0 (exp (/ (+ Vef Ev) KbT)))))
         (if (or (<= Ec 4.8e+135)
                 (and (not (<= Ec 5.8e+226)) (<= Ec 1.25e+259)))
           t_0
           (+
            (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
            (/ NdChar (+ 1.0 (exp (- (/ Ec KbT))))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double tmp;
	if (Ec <= -1.05e+180) {
		tmp = t_0;
	} else if (Ec <= -1.9e-35) {
		tmp = NdChar + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	} else if (Ec <= 7.5e-237) {
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp(((Vef + Ev) / KbT))));
	} else if ((Ec <= 4.8e+135) || (!(Ec <= 5.8e+226) && (Ec <= 1.25e+259))) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(-(Ec / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    if (ec <= (-1.05d+180)) then
        tmp = t_0
    else if (ec <= (-1.9d-35)) then
        tmp = ndchar + (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt))))
    else if (ec <= 7.5d-237) then
        tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp(((vef + ev) / kbt))))
    else if ((ec <= 4.8d+135) .or. (.not. (ec <= 5.8d+226)) .and. (ec <= 1.25d+259)) then
        tmp = t_0
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp(-(ec / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double tmp;
	if (Ec <= -1.05e+180) {
		tmp = t_0;
	} else if (Ec <= -1.9e-35) {
		tmp = NdChar + (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	} else if (Ec <= 7.5e-237) {
		tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + Ev) / KbT))));
	} else if ((Ec <= 4.8e+135) || (!(Ec <= 5.8e+226) && (Ec <= 1.25e+259))) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp(-(Ec / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)))
	tmp = 0
	if Ec <= -1.05e+180:
		tmp = t_0
	elif Ec <= -1.9e-35:
		tmp = NdChar + (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))))
	elif Ec <= 7.5e-237:
		tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp(((Vef + Ev) / KbT))))
	elif (Ec <= 4.8e+135) or (not (Ec <= 5.8e+226) and (Ec <= 1.25e+259)):
		tmp = t_0
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp(-(Ec / 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(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))))
	tmp = 0.0
	if (Ec <= -1.05e+180)
		tmp = t_0;
	elseif (Ec <= -1.9e-35)
		tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))));
	elseif (Ec <= 7.5e-237)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Ev) / KbT)))));
	elseif ((Ec <= 4.8e+135) || (!(Ec <= 5.8e+226) && (Ec <= 1.25e+259)))
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(-Float64(Ec / 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((((EAccept + (Vef + Ev)) - mu) / KbT)));
	tmp = 0.0;
	if (Ec <= -1.05e+180)
		tmp = t_0;
	elseif (Ec <= -1.9e-35)
		tmp = NdChar + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	elseif (Ec <= 7.5e-237)
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp(((Vef + Ev) / KbT))));
	elseif ((Ec <= 4.8e+135) || (~((Ec <= 5.8e+226)) && (Ec <= 1.25e+259)))
		tmp = t_0;
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(-(Ec / 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[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ec, -1.05e+180], t$95$0, If[LessEqual[Ec, -1.9e-35], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, 7.5e-237], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + Ev), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[Ec, 4.8e+135], And[N[Not[LessEqual[Ec, 5.8e+226]], $MachinePrecision], LessEqual[Ec, 1.25e+259]]], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[(-N[(Ec / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if Ec < -1.05e180 or 7.50000000000000034e-237 < Ec < 4.79999999999999995e135 or 5.79999999999999949e226 < Ec < 1.25000000000000008e259

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 55.5%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 34.2%

      \[\leadsto \color{blue}{\frac{KbT \cdot NdChar}{EDonor}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-/l* 32.3%

         \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Simplified 32.3%

      \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   8. Taylor expanded in KbT around 0 75.5%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   if -1.05e180 < Ec < -1.9000000000000001e-35

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 46.4%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 48.6%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 76.1%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if -1.9000000000000001e-35 < Ec < 7.50000000000000034e-237

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 84.8%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in Ev around inf 75.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \color{blue}{Ev}}{KbT}}} \]

   if 4.79999999999999995e135 < Ec < 5.79999999999999949e226 or 1.25000000000000008e259 < Ec

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 81.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in Ec around inf 73.1%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{-1 \cdot \frac{Ec}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} \]
   6. Step-by-step derivation

      1. mul-1-neg 73.1%

         \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{-\frac{Ec}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} \]

   7. Simplified 73.1%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{-\frac{Ec}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} \]
3. Recombined 4 regimes into one program.

4. Final simplification 75.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ec \leq -1.05 \cdot 10^{+180}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;Ec \leq -1.9 \cdot 10^{-35}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{elif}\;Ec \leq 7.5 \cdot 10^{-237}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \mathbf{elif}\;Ec \leq 4.8 \cdot 10^{+135} \lor \neg \left(Ec \leq 5.8 \cdot 10^{+226}\right) \land Ec \leq 1.25 \cdot 10^{+259}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{-\frac{Ec}{KbT}}}\\ \end{array} \]

Alternative 5: 75.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -9.5 \cdot 10^{+26}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq 3.4 \cdot 10^{-195}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 8.4 \cdot 10^{-67}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{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 (+ Ev (- EAccept mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
   (if (<= Vef -9.5e+26)
     t_1
     (if (<= Vef 3.4e-195)
       (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
       (if (<= Vef 8.4e-67)
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) 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 + (Ev + (EAccept - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	double tmp;
	if (Vef <= -9.5e+26) {
		tmp = t_1;
	} else if (Vef <= 3.4e-195) {
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (Vef <= 8.4e-67) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / 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 + (ev + (eaccept - mu))) / kbt)))
    t_1 = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
    if (vef <= (-9.5d+26)) then
        tmp = t_1
    else if (vef <= 3.4d-195) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (vef <= 8.4d-67) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / 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 + (Ev + (EAccept - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	double tmp;
	if (Vef <= -9.5e+26) {
		tmp = t_1;
	} else if (Vef <= 3.4e-195) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (Vef <= 8.4e-67) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / 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 + (Ev + (EAccept - mu))) / KbT)))
	t_1 = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	tmp = 0
	if Vef <= -9.5e+26:
		tmp = t_1
	elif Vef <= 3.4e-195:
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif Vef <= 8.4e-67:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / 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(Ev + Float64(EAccept - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	tmp = 0.0
	if (Vef <= -9.5e+26)
		tmp = t_1;
	elseif (Vef <= 3.4e-195)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (Vef <= 8.4e-67)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / 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 + (Ev + (EAccept - mu))) / KbT)));
	t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	tmp = 0.0;
	if (Vef <= -9.5e+26)
		tmp = t_1;
	elseif (Vef <= 3.4e-195)
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (Vef <= 8.4e-67)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / 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[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -9.5e+26], t$95$1, If[LessEqual[Vef, 3.4e-195], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 8.4e-67], 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], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -9.50000000000000054e26 or 8.4000000000000006e-67 < Vef

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 85.6%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if -9.50000000000000054e26 < Vef < 3.40000000000000001e-195

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 74.6%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{EDonor}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if 3.40000000000000001e-195 < Vef < 8.4000000000000006e-67

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 86.5%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{mu}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in mu around inf 80.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{-1 \cdot \frac{mu}{KbT}}}} \]
   6. Step-by-step derivation

      1. associate-*r/ 52.2%

         \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{-1 \cdot mu}{KbT}}}} \]

      2. mul-1-neg 52.2%

         \[\leadsto NdChar + \frac{NaChar}{1 + e^{\frac{\color{blue}{-mu}}{KbT}}} \]

   7. Simplified 80.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{-mu}{KbT}}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 80.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -9.5 \cdot 10^{+26}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq 3.4 \cdot 10^{-195}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 8.4 \cdot 10^{-67}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]

Alternative 6: 73.6% accurate, 1.0× speedup

Math

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.55000000000000004e-33

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 82.5%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if -2.55000000000000004e-33 < NaChar < 3.8000000000000001e197

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 81.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   if 3.8000000000000001e197 < NaChar

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 82.0%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{EDonor}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 81.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.55 \cdot 10^{-33}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 3.8 \cdot 10^{+197}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \]

Alternative 7: 72.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -1.1499999999999999e84

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Ev around inf 91.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]

   if -1.1499999999999999e84 < Ev < -1.5e-158

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 78.4%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if -1.5e-158 < Ev

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 73.5%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 77.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -1.15 \cdot 10^{+84}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -1.5 \cdot 10^{-158}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 8: 66.9% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ t_1 := NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;NaChar \leq -2.1 \cdot 10^{+182}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq -2.95 \cdot 10^{+113}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -2.85 \cdot 10^{-143}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq 1.06 \cdot 10^{-137}:\\ \;\;\;\;t_2 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 3 \cdot 10^{-106}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq 6.5 \cdot 10^{-7}:\\ \;\;\;\;t_2 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 1.9 \cdot 10^{+81}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))
        (t_1
         (+
          NdChar
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))))
   (if (<= NaChar -2.1e+182)
     t_0
     (if (<= NaChar -2.95e+113)
       t_1
       (if (<= NaChar -2.85e-143)
         t_0
         (if (<= NaChar 1.06e-137)
           (+ t_2 (/ NaChar (+ (/ Ev KbT) 2.0)))
           (if (<= NaChar 3e-106)
             t_0
             (if (<= NaChar 6.5e-7)
               (+ t_2 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
               (if (<= NaChar 1.9e+81) t_0 t_1)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = NdChar + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	double t_2 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (NaChar <= -2.1e+182) {
		tmp = t_0;
	} else if (NaChar <= -2.95e+113) {
		tmp = t_1;
	} else if (NaChar <= -2.85e-143) {
		tmp = t_0;
	} else if (NaChar <= 1.06e-137) {
		tmp = t_2 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (NaChar <= 3e-106) {
		tmp = t_0;
	} else if (NaChar <= 6.5e-7) {
		tmp = t_2 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else if (NaChar <= 1.9e+81) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    t_1 = ndchar + (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt))))
    t_2 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    if (nachar <= (-2.1d+182)) then
        tmp = t_0
    else if (nachar <= (-2.95d+113)) then
        tmp = t_1
    else if (nachar <= (-2.85d-143)) then
        tmp = t_0
    else if (nachar <= 1.06d-137) then
        tmp = t_2 + (nachar / ((ev / kbt) + 2.0d0))
    else if (nachar <= 3d-106) then
        tmp = t_0
    else if (nachar <= 6.5d-7) then
        tmp = t_2 + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
    else if (nachar <= 1.9d+81) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = NdChar + (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	double t_2 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (NaChar <= -2.1e+182) {
		tmp = t_0;
	} else if (NaChar <= -2.95e+113) {
		tmp = t_1;
	} else if (NaChar <= -2.85e-143) {
		tmp = t_0;
	} else if (NaChar <= 1.06e-137) {
		tmp = t_2 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (NaChar <= 3e-106) {
		tmp = t_0;
	} else if (NaChar <= 6.5e-7) {
		tmp = t_2 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else if (NaChar <= 1.9e+81) {
		tmp = t_0;
	} 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((((EAccept + (Vef + Ev)) - mu) / KbT)))
	t_1 = NdChar + (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))))
	t_2 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	tmp = 0
	if NaChar <= -2.1e+182:
		tmp = t_0
	elif NaChar <= -2.95e+113:
		tmp = t_1
	elif NaChar <= -2.85e-143:
		tmp = t_0
	elif NaChar <= 1.06e-137:
		tmp = t_2 + (NaChar / ((Ev / KbT) + 2.0))
	elif NaChar <= 3e-106:
		tmp = t_0
	elif NaChar <= 6.5e-7:
		tmp = t_2 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))))
	elif NaChar <= 1.9e+81:
		tmp = t_0
	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(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))))
	t_1 = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (NaChar <= -2.1e+182)
		tmp = t_0;
	elseif (NaChar <= -2.95e+113)
		tmp = t_1;
	elseif (NaChar <= -2.85e-143)
		tmp = t_0;
	elseif (NaChar <= 1.06e-137)
		tmp = Float64(t_2 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	elseif (NaChar <= 3e-106)
		tmp = t_0;
	elseif (NaChar <= 6.5e-7)
		tmp = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))));
	elseif (NaChar <= 1.9e+81)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	t_1 = NdChar + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	t_2 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (NaChar <= -2.1e+182)
		tmp = t_0;
	elseif (NaChar <= -2.95e+113)
		tmp = t_1;
	elseif (NaChar <= -2.85e-143)
		tmp = t_0;
	elseif (NaChar <= 1.06e-137)
		tmp = t_2 + (NaChar / ((Ev / KbT) + 2.0));
	elseif (NaChar <= 3e-106)
		tmp = t_0;
	elseif (NaChar <= 6.5e-7)
		tmp = t_2 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	elseif (NaChar <= 1.9e+81)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -2.1e+182], t$95$0, If[LessEqual[NaChar, -2.95e+113], t$95$1, If[LessEqual[NaChar, -2.85e-143], t$95$0, If[LessEqual[NaChar, 1.06e-137], N[(t$95$2 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 3e-106], t$95$0, If[LessEqual[NaChar, 6.5e-7], N[(t$95$2 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.9e+81], t$95$0, t$95$1]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -2.0999999999999999e182 or -2.95000000000000011e113 < NaChar < -2.85e-143 or 1.06000000000000005e-137 < NaChar < 3.00000000000000019e-106 or 6.50000000000000024e-7 < NaChar < 1.9e81

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 56.4%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 35.4%

      \[\leadsto \color{blue}{\frac{KbT \cdot NdChar}{EDonor}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-/l* 32.4%

         \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Simplified 32.4%

      \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   8. Taylor expanded in KbT around 0 77.9%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   if -2.0999999999999999e182 < NaChar < -2.95000000000000011e113 or 1.9e81 < NaChar

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 61.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 60.7%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 80.3%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if -2.85e-143 < NaChar < 1.06000000000000005e-137

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Ev around inf 78.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]

   5. Taylor expanded in Ev around 0 69.5%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{2 + \frac{Ev}{KbT}}} \]

   if 3.00000000000000019e-106 < NaChar < 6.50000000000000024e-7

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 72.9%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 67.4%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]
3. Recombined 4 regimes into one program.

4. Final simplification 75.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.1 \cdot 10^{+182}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -2.95 \cdot 10^{+113}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -2.85 \cdot 10^{-143}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 1.06 \cdot 10^{-137}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 3 \cdot 10^{-106}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 6.5 \cdot 10^{-7}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 1.9 \cdot 10^{+81}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \end{array} \]

Alternative 9: 67.0% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ t_1 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ t_2 := NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{if}\;NaChar \leq -4.2 \cdot 10^{+182}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -2.75 \cdot 10^{+113}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NaChar \leq -1.1 \cdot 10^{-140}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq 5.8 \cdot 10^{-132}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq 1.3 \cdot 10^{-104}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq 8.5 \cdot 10^{-7}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq 6.5 \cdot 10^{+76}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
          (/ NaChar (+ (/ Ev KbT) 2.0))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))
        (t_2
         (+
          NdChar
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))))
   (if (<= NaChar -4.2e+182)
     t_1
     (if (<= NaChar -2.75e+113)
       t_2
       (if (<= NaChar -1.1e-140)
         t_1
         (if (<= NaChar 5.8e-132)
           t_0
           (if (<= NaChar 1.3e-104)
             t_1
             (if (<= NaChar 8.5e-7)
               t_0
               (if (<= NaChar 6.5e+76) t_1 t_2)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
	double t_1 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_2 = NdChar + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	double tmp;
	if (NaChar <= -4.2e+182) {
		tmp = t_1;
	} else if (NaChar <= -2.75e+113) {
		tmp = t_2;
	} else if (NaChar <= -1.1e-140) {
		tmp = t_1;
	} else if (NaChar <= 5.8e-132) {
		tmp = t_0;
	} else if (NaChar <= 1.3e-104) {
		tmp = t_1;
	} else if (NaChar <= 8.5e-7) {
		tmp = t_0;
	} else if (NaChar <= 6.5e+76) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / ((ev / kbt) + 2.0d0))
    t_1 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    t_2 = ndchar + (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt))))
    if (nachar <= (-4.2d+182)) then
        tmp = t_1
    else if (nachar <= (-2.75d+113)) then
        tmp = t_2
    else if (nachar <= (-1.1d-140)) then
        tmp = t_1
    else if (nachar <= 5.8d-132) then
        tmp = t_0
    else if (nachar <= 1.3d-104) then
        tmp = t_1
    else if (nachar <= 8.5d-7) then
        tmp = t_0
    else if (nachar <= 6.5d+76) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
	double t_1 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_2 = NdChar + (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	double tmp;
	if (NaChar <= -4.2e+182) {
		tmp = t_1;
	} else if (NaChar <= -2.75e+113) {
		tmp = t_2;
	} else if (NaChar <= -1.1e-140) {
		tmp = t_1;
	} else if (NaChar <= 5.8e-132) {
		tmp = t_0;
	} else if (NaChar <= 1.3e-104) {
		tmp = t_1;
	} else if (NaChar <= 8.5e-7) {
		tmp = t_0;
	} else if (NaChar <= 6.5e+76) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Ev / KbT) + 2.0))
	t_1 = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)))
	t_2 = NdChar + (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))))
	tmp = 0
	if NaChar <= -4.2e+182:
		tmp = t_1
	elif NaChar <= -2.75e+113:
		tmp = t_2
	elif NaChar <= -1.1e-140:
		tmp = t_1
	elif NaChar <= 5.8e-132:
		tmp = t_0
	elif NaChar <= 1.3e-104:
		tmp = t_1
	elif NaChar <= 8.5e-7:
		tmp = t_0
	elif NaChar <= 6.5e+76:
		tmp = t_1
	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(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))))
	t_2 = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))))
	tmp = 0.0
	if (NaChar <= -4.2e+182)
		tmp = t_1;
	elseif (NaChar <= -2.75e+113)
		tmp = t_2;
	elseif (NaChar <= -1.1e-140)
		tmp = t_1;
	elseif (NaChar <= 5.8e-132)
		tmp = t_0;
	elseif (NaChar <= 1.3e-104)
		tmp = t_1;
	elseif (NaChar <= 8.5e-7)
		tmp = t_0;
	elseif (NaChar <= 6.5e+76)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
	t_1 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	t_2 = NdChar + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	tmp = 0.0;
	if (NaChar <= -4.2e+182)
		tmp = t_1;
	elseif (NaChar <= -2.75e+113)
		tmp = t_2;
	elseif (NaChar <= -1.1e-140)
		tmp = t_1;
	elseif (NaChar <= 5.8e-132)
		tmp = t_0;
	elseif (NaChar <= 1.3e-104)
		tmp = t_1;
	elseif (NaChar <= 8.5e-7)
		tmp = t_0;
	elseif (NaChar <= 6.5e+76)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -4.2e+182], t$95$1, If[LessEqual[NaChar, -2.75e+113], t$95$2, If[LessEqual[NaChar, -1.1e-140], t$95$1, If[LessEqual[NaChar, 5.8e-132], t$95$0, If[LessEqual[NaChar, 1.3e-104], t$95$1, If[LessEqual[NaChar, 8.5e-7], t$95$0, If[LessEqual[NaChar, 6.5e+76], t$95$1, t$95$2]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -4.1999999999999998e182 or -2.75e113 < NaChar < -1.1e-140 or 5.79999999999999967e-132 < NaChar < 1.30000000000000001e-104 or 8.50000000000000014e-7 < NaChar < 6.5000000000000005e76

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 56.4%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 35.4%

      \[\leadsto \color{blue}{\frac{KbT \cdot NdChar}{EDonor}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-/l* 32.4%

         \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Simplified 32.4%

      \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   8. Taylor expanded in KbT around 0 77.9%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   if -4.1999999999999998e182 < NaChar < -2.75e113 or 6.5000000000000005e76 < NaChar

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 61.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 60.7%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 80.3%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if -1.1e-140 < NaChar < 5.79999999999999967e-132 or 1.30000000000000001e-104 < NaChar < 8.50000000000000014e-7

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Ev around inf 79.3%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]

   5. Taylor expanded in Ev around 0 70.1%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\color{blue}{2 + \frac{Ev}{KbT}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 76.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -4.2 \cdot 10^{+182}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -2.75 \cdot 10^{+113}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -1.1 \cdot 10^{-140}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 5.8 \cdot 10^{-132}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 1.3 \cdot 10^{-104}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 8.5 \cdot 10^{-7}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 6.5 \cdot 10^{+76}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \end{array} \]

Alternative 10: 56.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ t_1 := NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;Ec \leq -4.5 \cdot 10^{+186}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;Ec \leq -1.95 \cdot 10^{+126}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Ec \leq -3.5 \cdot 10^{-45}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;Ec \leq -1.15 \cdot 10^{-121}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;Ec \leq -4.7 \cdot 10^{-240}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ec \leq 1.35 \cdot 10^{+140} \lor \neg \left(Ec \leq 1.16 \cdot 10^{+198}\right):\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))
        (t_1 (+ NdChar (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))
   (if (<= Ec -4.5e+186)
     t_0
     (if (<= Ec -1.95e+126)
       t_1
       (if (<= Ec -3.5e-45)
         t_0
         (if (<= Ec -1.15e-121)
           (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (/ NaChar 2.0))
           (if (<= Ec -4.7e-240)
             (+ NdChar (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
             (if (or (<= Ec 1.35e+140) (not (<= Ec 1.16e+198))) t_0 t_1))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = NdChar + (NaChar / (1.0 + exp((EAccept / KbT))));
	double tmp;
	if (Ec <= -4.5e+186) {
		tmp = t_0;
	} else if (Ec <= -1.95e+126) {
		tmp = t_1;
	} else if (Ec <= -3.5e-45) {
		tmp = t_0;
	} else if (Ec <= -1.15e-121) {
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / 2.0);
	} else if (Ec <= -4.7e-240) {
		tmp = NdChar + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if ((Ec <= 1.35e+140) || !(Ec <= 1.16e+198)) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    t_1 = ndchar + (nachar / (1.0d0 + exp((eaccept / kbt))))
    if (ec <= (-4.5d+186)) then
        tmp = t_0
    else if (ec <= (-1.95d+126)) then
        tmp = t_1
    else if (ec <= (-3.5d-45)) then
        tmp = t_0
    else if (ec <= (-1.15d-121)) then
        tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / 2.0d0)
    else if (ec <= (-4.7d-240)) then
        tmp = ndchar + (nachar / (1.0d0 + exp((ev / kbt))))
    else if ((ec <= 1.35d+140) .or. (.not. (ec <= 1.16d+198))) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = NdChar + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	double tmp;
	if (Ec <= -4.5e+186) {
		tmp = t_0;
	} else if (Ec <= -1.95e+126) {
		tmp = t_1;
	} else if (Ec <= -3.5e-45) {
		tmp = t_0;
	} else if (Ec <= -1.15e-121) {
		tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / 2.0);
	} else if (Ec <= -4.7e-240) {
		tmp = NdChar + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if ((Ec <= 1.35e+140) || !(Ec <= 1.16e+198)) {
		tmp = t_0;
	} 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((((EAccept + (Vef + Ev)) - mu) / KbT)))
	t_1 = NdChar + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	tmp = 0
	if Ec <= -4.5e+186:
		tmp = t_0
	elif Ec <= -1.95e+126:
		tmp = t_1
	elif Ec <= -3.5e-45:
		tmp = t_0
	elif Ec <= -1.15e-121:
		tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / 2.0)
	elif Ec <= -4.7e-240:
		tmp = NdChar + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif (Ec <= 1.35e+140) or not (Ec <= 1.16e+198):
		tmp = t_0
	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(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))))
	t_1 = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))))
	tmp = 0.0
	if (Ec <= -4.5e+186)
		tmp = t_0;
	elseif (Ec <= -1.95e+126)
		tmp = t_1;
	elseif (Ec <= -3.5e-45)
		tmp = t_0;
	elseif (Ec <= -1.15e-121)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / 2.0));
	elseif (Ec <= -4.7e-240)
		tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif ((Ec <= 1.35e+140) || !(Ec <= 1.16e+198))
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	t_1 = NdChar + (NaChar / (1.0 + exp((EAccept / KbT))));
	tmp = 0.0;
	if (Ec <= -4.5e+186)
		tmp = t_0;
	elseif (Ec <= -1.95e+126)
		tmp = t_1;
	elseif (Ec <= -3.5e-45)
		tmp = t_0;
	elseif (Ec <= -1.15e-121)
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / 2.0);
	elseif (Ec <= -4.7e-240)
		tmp = NdChar + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif ((Ec <= 1.35e+140) || ~((Ec <= 1.16e+198)))
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ec, -4.5e+186], t$95$0, If[LessEqual[Ec, -1.95e+126], t$95$1, If[LessEqual[Ec, -3.5e-45], t$95$0, If[LessEqual[Ec, -1.15e-121], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, -4.7e-240], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[Ec, 1.35e+140], N[Not[LessEqual[Ec, 1.16e+198]], $MachinePrecision]], t$95$0, t$95$1]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if Ec < -4.50000000000000045e186 or -1.94999999999999997e126 < Ec < -3.5e-45 or -4.70000000000000012e-240 < Ec < 1.35000000000000009e140 or 1.16000000000000001e198 < Ec

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 54.8%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 35.3%

      \[\leadsto \color{blue}{\frac{KbT \cdot NdChar}{EDonor}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-/l* 32.6%

         \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Simplified 32.6%

      \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   8. Taylor expanded in KbT around 0 71.9%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   if -4.50000000000000045e186 < Ec < -1.94999999999999997e126 or 1.35000000000000009e140 < Ec < 1.16000000000000001e198

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 33.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 46.5%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 83.1%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in EAccept around inf 73.3%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   if -3.5e-45 < Ec < -1.15000000000000006e-121

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 94.2%

      \[\leadsto \frac{NdChar}{1 + e^{\color{blue}{\frac{Vef}{KbT}}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 77.1%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{\color{blue}{2}} \]

   if -1.15000000000000006e-121 < Ec < -4.70000000000000012e-240

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 44.7%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 51.4%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 80.0%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in Ev around inf 69.7%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]
3. Recombined 4 regimes into one program.

4. Final simplification 72.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ec \leq -4.5 \cdot 10^{+186}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;Ec \leq -1.95 \cdot 10^{+126}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;Ec \leq -3.5 \cdot 10^{-45}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;Ec \leq -1.15 \cdot 10^{-121}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;Ec \leq -4.7 \cdot 10^{-240}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ec \leq 1.35 \cdot 10^{+140} \lor \neg \left(Ec \leq 1.16 \cdot 10^{+198}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 11: 60.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{if}\;Ec \leq -4.5 \cdot 10^{+188}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;Ec \leq -5 \cdot 10^{-242}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{elif}\;Ec \leq 2.2 \cdot 10^{+140} \lor \neg \left(Ec \leq 1.8 \cdot 10^{+198}\right):\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))))
   (if (<= Ec -4.5e+188)
     t_0
     (if (<= Ec -5e-242)
       (+
        NdChar
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
       (if (or (<= Ec 2.2e+140) (not (<= Ec 1.8e+198)))
         t_0
         (+ NdChar (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double tmp;
	if (Ec <= -4.5e+188) {
		tmp = t_0;
	} else if (Ec <= -5e-242) {
		tmp = NdChar + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	} else if ((Ec <= 2.2e+140) || !(Ec <= 1.8e+198)) {
		tmp = t_0;
	} else {
		tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    if (ec <= (-4.5d+188)) then
        tmp = t_0
    else if (ec <= (-5d-242)) then
        tmp = ndchar + (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt))))
    else if ((ec <= 2.2d+140) .or. (.not. (ec <= 1.8d+198))) then
        tmp = t_0
    else
        tmp = ndchar + (nachar / (1.0d0 + exp((eaccept / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double tmp;
	if (Ec <= -4.5e+188) {
		tmp = t_0;
	} else if (Ec <= -5e-242) {
		tmp = NdChar + (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	} else if ((Ec <= 2.2e+140) || !(Ec <= 1.8e+198)) {
		tmp = t_0;
	} else {
		tmp = NdChar + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)))
	tmp = 0
	if Ec <= -4.5e+188:
		tmp = t_0
	elif Ec <= -5e-242:
		tmp = NdChar + (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))))
	elif (Ec <= 2.2e+140) or not (Ec <= 1.8e+198):
		tmp = t_0
	else:
		tmp = NdChar + (NaChar / (1.0 + math.exp((EAccept / 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(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))))
	tmp = 0.0
	if (Ec <= -4.5e+188)
		tmp = t_0;
	elseif (Ec <= -5e-242)
		tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))));
	elseif ((Ec <= 2.2e+140) || !(Ec <= 1.8e+198))
		tmp = t_0;
	else
		tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	tmp = 0.0;
	if (Ec <= -4.5e+188)
		tmp = t_0;
	elseif (Ec <= -5e-242)
		tmp = NdChar + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
	elseif ((Ec <= 2.2e+140) || ~((Ec <= 1.8e+198)))
		tmp = t_0;
	else
		tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ec, -4.5e+188], t$95$0, If[LessEqual[Ec, -5e-242], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[Ec, 2.2e+140], N[Not[LessEqual[Ec, 1.8e+198]], $MachinePrecision]], t$95$0, N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if Ec < -4.5000000000000001e188 or -4.9999999999999998e-242 < Ec < 2.1999999999999998e140 or 1.8000000000000001e198 < Ec

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 54.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 36.0%

      \[\leadsto \color{blue}{\frac{KbT \cdot NdChar}{EDonor}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-/l* 34.0%

         \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Simplified 34.0%

      \[\leadsto \color{blue}{\frac{KbT}{\frac{EDonor}{NdChar}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   8. Taylor expanded in KbT around 0 73.6%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}} \]

   if -4.5000000000000001e188 < Ec < -4.9999999999999998e-242

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 51.8%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 50.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 73.2%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   if 2.1999999999999998e140 < Ec < 1.8000000000000001e198

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 42.9%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 44.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 76.1%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in EAccept around inf 64.6%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 72.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ec \leq -4.5 \cdot 10^{+188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;Ec \leq -5 \cdot 10^{-242}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{elif}\;Ec \leq 2.2 \cdot 10^{+140} \lor \neg \left(Ec \leq 1.8 \cdot 10^{+198}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 12: 55.6% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;mu \leq -3.8 \cdot 10^{+156} \lor \neg \left(mu \leq 7.5 \cdot 10^{+160}\right):\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= mu -3.8e+156) (not (<= mu 7.5e+160)))
   (+ NdChar (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
   (+ NdChar (/ NaChar (+ 1.0 (exp (/ (+ Vef EAccept) KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((mu <= -3.8e+156) || !(mu <= 7.5e+160)) {
		tmp = NdChar + (NaChar / (1.0 + exp((-mu / KbT))));
	} else {
		tmp = NdChar + (NaChar / (1.0 + exp(((Vef + EAccept) / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((mu <= -3.8e+156) || ~((mu <= 7.5e+160)))
		tmp = NdChar + (NaChar / (1.0 + exp((-mu / KbT))));
	else
		tmp = NdChar + (NaChar / (1.0 + exp(((Vef + EAccept) / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[mu, -3.8e+156], N[Not[LessEqual[mu, 7.5e+160]], $MachinePrecision]], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + EAccept), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if mu < -3.80000000000000024e156 or 7.50000000000000028e160 < mu

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 46.5%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 58.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 66.2%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in mu around inf 63.9%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{-1 \cdot \frac{mu}{KbT}}}} \]
   8. Step-by-step derivation

      1. associate-*r/ 63.9%

         \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{-1 \cdot mu}{KbT}}}} \]

      2. mul-1-neg 63.9%

         \[\leadsto NdChar + \frac{NaChar}{1 + e^{\frac{\color{blue}{-mu}}{KbT}}} \]

   9. Simplified 63.9%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{-mu}{KbT}}}} \]

   if -3.80000000000000024e156 < mu < 7.50000000000000028e160

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 54.6%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 48.0%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 61.1%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in EAccept around inf 56.0%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \color{blue}{EAccept}}{KbT}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 57.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -3.8 \cdot 10^{+156} \lor \neg \left(mu \leq 7.5 \cdot 10^{+160}\right):\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + EAccept}{KbT}}}\\ \end{array} \]

Alternative 13: 51.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;mu \leq -2.9 \cdot 10^{+137} \lor \neg \left(mu \leq 2.5 \cdot 10^{+160}\right):\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= mu -2.9e+137) (not (<= mu 2.5e+160)))
   (+ NdChar (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
   (+ NdChar (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((mu <= -2.9e+137) || !(mu <= 2.5e+160)) {
		tmp = NdChar + (NaChar / (1.0 + exp((-mu / KbT))));
	} else {
		tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((mu <= -2.9e+137) || ~((mu <= 2.5e+160)))
		tmp = NdChar + (NaChar / (1.0 + exp((-mu / KbT))));
	else
		tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[mu, -2.9e+137], N[Not[LessEqual[mu, 2.5e+160]], $MachinePrecision]], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if mu < -2.89999999999999985e137 or 2.5000000000000001e160 < mu

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 47.6%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 58.6%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 67.6%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in mu around inf 63.9%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{-1 \cdot \frac{mu}{KbT}}}} \]
   8. Step-by-step derivation

      1. associate-*r/ 63.9%

         \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{-1 \cdot mu}{KbT}}}} \]

      2. mul-1-neg 63.9%

         \[\leadsto NdChar + \frac{NaChar}{1 + e^{\frac{\color{blue}{-mu}}{KbT}}} \]

   9. Simplified 63.9%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{-mu}{KbT}}}} \]

   if -2.89999999999999985e137 < mu < 2.5000000000000001e160

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 54.5%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 47.6%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 60.5%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in EAccept around inf 51.7%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 54.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -2.9 \cdot 10^{+137} \lor \neg \left(mu \leq 2.5 \cdot 10^{+160}\right):\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 14: 49.4% accurate, 2.0× speedup

Math

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT))))
	tmp = 0.0
	if (KbT <= -1.6e+230)
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))) + t_0);
	elseif (KbT <= 5.1e+179)
		tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	tmp = 0.0;
	if (KbT <= -1.6e+230)
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0;
	elseif (KbT <= 5.1e+179)
		tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT))));
	else
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.6e230

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 87.3%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 80.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]

   6. Taylor expanded in KbT around inf 74.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} \]

   if -1.6e230 < KbT < 5.1000000000000002e179

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 46.5%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 49.6%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 63.9%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in EAccept around inf 49.7%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   if 5.1000000000000002e179 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 72.6%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 70.3%

      \[\leadsto \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\color{blue}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 53.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.6 \cdot 10^{+230}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 5.1 \cdot 10^{+179}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \end{array} \]

Alternative 15: 48.4% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -32000000000:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -3.2e10

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 44.8%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 37.1%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 55.4%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in Ev around inf 50.7%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]

   if -3.2e10 < Ev

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 55.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 54.7%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 64.5%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in EAccept around inf 49.0%

      \[\leadsto NdChar + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 49.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -32000000000:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 16: 39.4% accurate, 4.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ t_1 := \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{if}\;KbT \leq -4.5 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + t_0\\ \mathbf{elif}\;KbT \leq -2 \cdot 10^{-117}:\\ \;\;\;\;NdChar + t_1\\ \mathbf{elif}\;KbT \leq -1.55 \cdot 10^{-152} \lor \neg \left(KbT \leq 4 \cdot 10^{+181}\right):\\ \;\;\;\;t_0 + t_1\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (/
          NdChar
          (+
           1.0
           (-
            (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
            (/ Ec KbT)))))
        (t_1
         (/
          NaChar
          (-
           (+ 2.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
           (/ mu KbT)))))
   (if (<= KbT -4.5e+135)
     (+ (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))) t_0)
     (if (<= KbT -2e-117)
       (+ NdChar t_1)
       (if (or (<= KbT -1.55e-152) (not (<= KbT 4e+181)))
         (+ t_0 t_1)
         (+ 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 t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	double t_1 = NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT));
	double tmp;
	if (KbT <= -4.5e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0;
	} else if (KbT <= -2e-117) {
		tmp = NdChar + t_1;
	} else if ((KbT <= -1.55e-152) || !(KbT <= 4e+181)) {
		tmp = t_0 + t_1;
	} 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) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + ((1.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt)))
    t_1 = nachar / ((2.0d0 + ((eaccept / kbt) + ((ev / kbt) + (vef / kbt)))) - (mu / kbt))
    if (kbt <= (-4.5d+135)) then
        tmp = (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt)))) + t_0
    else if (kbt <= (-2d-117)) then
        tmp = ndchar + t_1
    else if ((kbt <= (-1.55d-152)) .or. (.not. (kbt <= 4d+181))) then
        tmp = t_0 + t_1
    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 t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	double t_1 = NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT));
	double tmp;
	if (KbT <= -4.5e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0;
	} else if (KbT <= -2e-117) {
		tmp = NdChar + t_1;
	} else if ((KbT <= -1.55e-152) || !(KbT <= 4e+181)) {
		tmp = t_0 + t_1;
	} else {
		tmp = NdChar + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)))
	t_1 = NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))
	tmp = 0
	if KbT <= -4.5e+135:
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0
	elif KbT <= -2e-117:
		tmp = NdChar + t_1
	elif (KbT <= -1.55e-152) or not (KbT <= 4e+181):
		tmp = t_0 + t_1
	else:
		tmp = NdChar + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT))))
	t_1 = Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT)))
	tmp = 0.0
	if (KbT <= -4.5e+135)
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))) + t_0);
	elseif (KbT <= -2e-117)
		tmp = Float64(NdChar + t_1);
	elseif ((KbT <= -1.55e-152) || !(KbT <= 4e+181))
		tmp = Float64(t_0 + t_1);
	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)
	t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	t_1 = NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT));
	tmp = 0.0;
	if (KbT <= -4.5e+135)
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0;
	elseif (KbT <= -2e-117)
		tmp = NdChar + t_1;
	elseif ((KbT <= -1.55e-152) || ~((KbT <= 4e+181)))
		tmp = t_0 + t_1;
	else
		tmp = NdChar + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[(N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -4.5e+135], N[(N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[KbT, -2e-117], N[(NdChar + t$95$1), $MachinePrecision], If[Or[LessEqual[KbT, -1.55e-152], N[Not[LessEqual[KbT, 4e+181]], $MachinePrecision]], N[(t$95$0 + t$95$1), $MachinePrecision], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -4.50000000000000007e135

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 73.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 70.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]

   6. Taylor expanded in KbT around inf 64.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} \]

   if -4.50000000000000007e135 < KbT < -2.00000000000000006e-117

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 50.4%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 57.6%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 62.7%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 38.9%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}} \]

   if -2.00000000000000006e-117 < KbT < -1.5499999999999999e-152 or 3.9999999999999997e181 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 77.0%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 65.9%

      \[\leadsto \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\color{blue}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}} \]

   if -1.5499999999999999e-152 < KbT < 3.9999999999999997e181

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 37.9%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 44.9%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 65.1%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 38.5%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{2}} \]
3. Recombined 4 regimes into one program.

4. Final simplification 46.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -4.5 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq -2 \cdot 10^{-117}:\\ \;\;\;\;NdChar + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;KbT \leq -1.55 \cdot 10^{-152} \lor \neg \left(KbT \leq 4 \cdot 10^{+181}\right):\\ \;\;\;\;\frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \end{array} \]

Alternative 17: 39.9% accurate, 6.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{if}\;KbT \leq -8.3 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + t_0\\ \mathbf{elif}\;KbT \leq 1.02 \cdot 10^{+155}:\\ \;\;\;\;NdChar + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (/
          NdChar
          (+
           1.0
           (-
            (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
            (/ Ec KbT))))))
   (if (<= KbT -8.3e+135)
     (+ (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))) t_0)
     (if (<= KbT 1.02e+155)
       (+
        NdChar
        (/
         NaChar
         (-
          (+ 2.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
          (/ mu KbT))))
       (+ (/ NaChar 2.0) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	double tmp;
	if (KbT <= -8.3e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0;
	} else if (KbT <= 1.02e+155) {
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else {
		tmp = (NaChar / 2.0) + t_0;
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	double tmp;
	if (KbT <= -8.3e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0;
	} else if (KbT <= 1.02e+155) {
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else {
		tmp = (NaChar / 2.0) + t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)))
	tmp = 0
	if KbT <= -8.3e+135:
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0
	elif KbT <= 1.02e+155:
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)))
	else:
		tmp = (NaChar / 2.0) + t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT))))
	tmp = 0.0
	if (KbT <= -8.3e+135)
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))) + t_0);
	elseif (KbT <= 1.02e+155)
		tmp = Float64(NdChar + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT))));
	else
		tmp = Float64(Float64(NaChar / 2.0) + t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT)));
	tmp = 0.0;
	if (KbT <= -8.3e+135)
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + t_0;
	elseif (KbT <= 1.02e+155)
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	else
		tmp = (NaChar / 2.0) + t_0;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -8.2999999999999996e135

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 73.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 70.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]

   6. Taylor expanded in KbT around inf 64.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} \]

   if -8.2999999999999996e135 < KbT < 1.02e155

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 45.1%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 49.5%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 63.8%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 36.9%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}} \]

   if 1.02e155 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 63.7%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 59.3%

      \[\leadsto \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\color{blue}{2}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 44.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -8.3 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 1.02 \cdot 10^{+155}:\\ \;\;\;\;NdChar + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \end{array} \]

Alternative 18: 39.9% accurate, 7.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.08 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 9.6 \cdot 10^{+154}:\\ \;\;\;\;NdChar + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.08e+135)
   (+ (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))) (* NdChar 0.5))
   (if (<= KbT 9.6e+154)
     (+
      NdChar
      (/
       NaChar
       (- (+ 2.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT)))) (/ mu KbT))))
     (+
      (/ NaChar 2.0)
      (/
       NdChar
       (+
        1.0
        (-
         (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
         (/ Ec KbT))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1.08e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 9.6e+154) {
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (kbt <= (-1.08d+135)) then
        tmp = (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= 9.6d+154) then
        tmp = ndchar + (nachar / ((2.0d0 + ((eaccept / kbt) + ((ev / kbt) + (vef / kbt)))) - (mu / kbt)))
    else
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + ((1.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1.08e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 9.6e+154) {
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1.08e+135:
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5)
	elif KbT <= 9.6e+154:
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)))
	else:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.08e135

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 73.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 70.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]

   6. Taylor expanded in KbT around inf 64.0%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} \]

   if -1.08e135 < KbT < 9.60000000000000059e154

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 45.1%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 49.5%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 63.8%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 36.9%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}} \]

   if 9.60000000000000059e154 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 63.7%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 59.3%

      \[\leadsto \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\color{blue}{2}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 44.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.08 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 9.6 \cdot 10^{+154}:\\ \;\;\;\;NdChar + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \end{array} \]

Alternative 19: 39.8% accurate, 8.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{if}\;KbT \leq -1.85 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 2.7 \cdot 10^{+224}:\\ \;\;\;\;NdChar + t_0\\ \mathbf{else}:\\ \;\;\;\;t_0 + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (/
          NaChar
          (-
           (+ 2.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
           (/ mu KbT)))))
   (if (<= KbT -1.85e+135)
     (+ (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))) (* NdChar 0.5))
     (if (<= KbT 2.7e+224) (+ NdChar t_0) (+ t_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 t_0 = NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT));
	double tmp;
	if (KbT <= -1.85e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 2.7e+224) {
		tmp = NdChar + t_0;
	} else {
		tmp = t_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) :: t_0
    real(8) :: tmp
    t_0 = nachar / ((2.0d0 + ((eaccept / kbt) + ((ev / kbt) + (vef / kbt)))) - (mu / kbt))
    if (kbt <= (-1.85d+135)) then
        tmp = (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= 2.7d+224) then
        tmp = ndchar + t_0
    else
        tmp = t_0 + (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 t_0 = NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT));
	double tmp;
	if (KbT <= -1.85e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 2.7e+224) {
		tmp = NdChar + t_0;
	} else {
		tmp = t_0 + (NdChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))
	tmp = 0
	if KbT <= -1.85e+135:
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5)
	elif KbT <= 2.7e+224:
		tmp = NdChar + t_0
	else:
		tmp = t_0 + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT)))
	tmp = 0.0
	if (KbT <= -1.85e+135)
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= 2.7e+224)
		tmp = Float64(NdChar + t_0);
	else
		tmp = Float64(t_0 + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT));
	tmp = 0.0;
	if (KbT <= -1.85e+135)
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= 2.7e+224)
		tmp = NdChar + t_0;
	else
		tmp = t_0 + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.85e+135], N[(N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.7e+224], N[(NdChar + t$95$0), $MachinePrecision], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.84999999999999999e135

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 73.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 70.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]

   6. Taylor expanded in KbT around inf 64.0%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} \]

   if -1.84999999999999999e135 < KbT < 2.6999999999999999e224

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 44.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 48.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 62.3%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 36.0%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}} \]

   if 2.6999999999999999e224 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 88.1%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 87.5%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{\color{blue}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 44.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.85 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 2.7 \cdot 10^{+224}:\\ \;\;\;\;NdChar + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 20: 39.9% accurate, 9.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.85 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 3.5 \cdot 10^{+219}:\\ \;\;\;\;NdChar + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2 + \left(\frac{Vef}{KbT} + \frac{EAccept}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -2.85e+135)
   (+ (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))) (* NdChar 0.5))
   (if (<= KbT 3.5e+219)
     (+
      NdChar
      (/
       NaChar
       (- (+ 2.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT)))) (/ mu KbT))))
     (+ (* NdChar 0.5) (/ NaChar (+ 2.0 (+ (/ Vef KbT) (/ EAccept 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 <= -2.85e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 3.5e+219) {
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (NaChar / (2.0 + ((Vef / KbT) + (EAccept / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (kbt <= (-2.85d+135)) then
        tmp = (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= 3.5d+219) then
        tmp = ndchar + (nachar / ((2.0d0 + ((eaccept / kbt) + ((ev / kbt) + (vef / kbt)))) - (mu / kbt)))
    else
        tmp = (ndchar * 0.5d0) + (nachar / (2.0d0 + ((vef / kbt) + (eaccept / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -2.85e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 3.5e+219) {
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (NaChar / (2.0 + ((Vef / KbT) + (EAccept / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -2.85e+135:
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5)
	elif KbT <= 3.5e+219:
		tmp = NdChar + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)))
	else:
		tmp = (NdChar * 0.5) + (NaChar / (2.0 + ((Vef / KbT) + (EAccept / KbT))))
	return tmp

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.85e+135], N[(N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.5e+219], N[(NdChar + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(2.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.8500000000000001e135

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 73.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 70.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]

   6. Taylor expanded in KbT around inf 64.0%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} \]

   if -2.8500000000000001e135 < KbT < 3.5000000000000001e219

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 44.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 48.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 62.3%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 36.0%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}} \]

   if 3.5000000000000001e219 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 88.1%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EAccept around inf 87.5%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \color{blue}{EAccept}}{KbT}}} \]

   6. Taylor expanded in KbT around inf 87.4%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{\color{blue}{2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 44.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.85 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 3.5 \cdot 10^{+219}:\\ \;\;\;\;NdChar + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2 + \left(\frac{Vef}{KbT} + \frac{EAccept}{KbT}\right)}\\ \end{array} \]

Alternative 21: 39.7% accurate, 12.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.95 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 3 \cdot 10^{+220}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2 + \left(\frac{Vef}{KbT} + \frac{EAccept}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.95e+135)
   (+ (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))) (* NdChar 0.5))
   (if (<= KbT 3e+220)
     (+ NdChar (/ NaChar 2.0))
     (+ (* NdChar 0.5) (/ NaChar (+ 2.0 (+ (/ Vef KbT) (/ EAccept 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.95e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 3e+220) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar * 0.5) + (NaChar / (2.0 + ((Vef / KbT) + (EAccept / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (kbt <= (-1.95d+135)) then
        tmp = (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= 3d+220) then
        tmp = ndchar + (nachar / 2.0d0)
    else
        tmp = (ndchar * 0.5d0) + (nachar / (2.0d0 + ((vef / kbt) + (eaccept / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1.95e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 3e+220) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar * 0.5) + (NaChar / (2.0 + ((Vef / KbT) + (EAccept / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1.95e+135:
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5)
	elif KbT <= 3e+220:
		tmp = NdChar + (NaChar / 2.0)
	else:
		tmp = (NdChar * 0.5) + (NaChar / (2.0 + ((Vef / KbT) + (EAccept / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -1.95e+135)
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= 3e+220)
		tmp = Float64(NdChar + Float64(NaChar / 2.0));
	else
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(2.0 + Float64(Float64(Vef / KbT) + Float64(EAccept / 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.95e+135)
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= 3e+220)
		tmp = NdChar + (NaChar / 2.0);
	else
		tmp = (NdChar * 0.5) + (NaChar / (2.0 + ((Vef / KbT) + (EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.95e+135], N[(N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3e+220], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(2.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.95000000000000016e135

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 73.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 70.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]

   6. Taylor expanded in KbT around inf 64.0%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} \]

   if -1.95000000000000016e135 < KbT < 3.00000000000000024e220

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 44.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 48.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 62.3%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 36.0%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{2}} \]

   if 3.00000000000000024e220 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 88.1%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EAccept around inf 87.5%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \color{blue}{EAccept}}{KbT}}} \]

   6. Taylor expanded in KbT around inf 87.4%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{\color{blue}{2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 44.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.95 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 3 \cdot 10^{+220}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2 + \left(\frac{Vef}{KbT} + \frac{EAccept}{KbT}\right)}\\ \end{array} \]

Alternative 22: 39.7% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.4 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 4 \cdot 10^{+219}:\\ \;\;\;\;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.4e+135)
   (+ (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))) (* NdChar 0.5))
   (if (<= KbT 4e+219)
     (+ 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.4e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 4e+219) {
		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.4d+135)) then
        tmp = (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= 4d+219) 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.4e+135) {
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 4e+219) {
		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.4e+135:
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5)
	elif KbT <= 4e+219:
		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.4e+135)
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= 4e+219)
		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.4e+135)
		tmp = (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= 4e+219)
		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.4e+135], N[(N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4e+219], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.40000000000000001e135

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 73.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]

   5. Taylor expanded in EAccept around 0 70.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \color{blue}{\left(1 + \frac{EAccept}{KbT}\right)}} \]

   6. Taylor expanded in KbT around inf 64.0%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} \]

   if -1.40000000000000001e135 < KbT < 3.99999999999999986e219

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 44.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 48.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 62.3%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 36.0%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{2}} \]

   if 3.99999999999999986e219 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 88.1%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 86.5%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{\color{blue}{2}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 43.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.4 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 4 \cdot 10^{+219}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 23: 39.7% accurate, 17.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.65 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + 2} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.15 \cdot 10^{+221}:\\ \;\;\;\;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.65e+135)
   (+ (/ NaChar (+ (/ Ev KbT) 2.0)) (* NdChar 0.5))
   (if (<= KbT 1.15e+221)
     (+ 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.65e+135) {
		tmp = (NaChar / ((Ev / KbT) + 2.0)) + (NdChar * 0.5);
	} else if (KbT <= 1.15e+221) {
		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.65d+135)) then
        tmp = (nachar / ((ev / kbt) + 2.0d0)) + (ndchar * 0.5d0)
    else if (kbt <= 1.15d+221) 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.65e+135) {
		tmp = (NaChar / ((Ev / KbT) + 2.0)) + (NdChar * 0.5);
	} else if (KbT <= 1.15e+221) {
		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.65e+135:
		tmp = (NaChar / ((Ev / KbT) + 2.0)) + (NdChar * 0.5)
	elif KbT <= 1.15e+221:
		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.65e+135)
		tmp = Float64(Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)) + Float64(NdChar * 0.5));
	elseif (KbT <= 1.15e+221)
		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.65e+135)
		tmp = (NaChar / ((Ev / KbT) + 2.0)) + (NdChar * 0.5);
	elseif (KbT <= 1.15e+221)
		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.65e+135], N[(N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.15e+221], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.65e135

   1. Initial program 99.9%

      \[\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}}} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Ev around inf 79.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\color{blue}{\frac{Ev}{KbT}}}} \]

   5. Taylor expanded in KbT around inf 70.0%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} \]

   6. Taylor expanded in Ev around 0 64.7%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{\color{blue}{2 + \frac{Ev}{KbT}}} \]

   if -1.65e135 < KbT < 1.14999999999999993e221

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 44.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 48.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 62.3%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 36.0%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{2}} \]

   if 1.14999999999999993e221 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 88.1%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 86.5%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{\color{blue}{2}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 44.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.65 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + 2} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.15 \cdot 10^{+221}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 24: 39.7% accurate, 20.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.9 \cdot 10^{+135} \lor \neg \left(KbT \leq 3.5 \cdot 10^{+219}\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.9e+135) (not (<= KbT 3.5e+219)))
   (+ (/ 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.9e+135) || !(KbT <= 3.5e+219)) {
		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.9d+135)) .or. (.not. (kbt <= 3.5d+219))) 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.9e+135) || !(KbT <= 3.5e+219)) {
		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.9e+135) or not (KbT <= 3.5e+219):
		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.9e+135) || !(KbT <= 3.5e+219))
		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.9e+135) || ~((KbT <= 3.5e+219)))
		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.9e+135], N[Not[LessEqual[KbT, 3.5e+219]], $MachinePrecision]], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -1.9000000000000001e135 or 3.5000000000000001e219 < KbT

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 84.3%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in KbT around inf 73.6%

      \[\leadsto 0.5 \cdot NdChar + \frac{NaChar}{\color{blue}{2}} \]

   if -1.9000000000000001e135 < KbT < 3.5000000000000001e219

   1. Initial program 100.0%

      \[\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}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 44.3%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in EDonor around inf 48.2%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   6. Taylor expanded in EDonor around 0 62.3%

      \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   7. Taylor expanded in KbT around inf 36.0%

      \[\leadsto NdChar + \frac{NaChar}{\color{blue}{2}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 43.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.9 \cdot 10^{+135} \lor \neg \left(KbT \leq 3.5 \cdot 10^{+219}\right):\\ \;\;\;\;\frac{NaChar}{2} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \end{array} \]

Alternative 25: 36.0% 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

1. Initial program 100.0%

   \[\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}}} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

4. Taylor expanded in KbT around inf 52.7%

   \[\leadsto \frac{NdChar}{1 + \color{blue}{\left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

5. Taylor expanded in EDonor around inf 50.4%

   \[\leadsto \frac{NdChar}{1 + \color{blue}{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

6. Taylor expanded in EDonor around 0 62.3%

   \[\leadsto \color{blue}{NdChar} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

7. Taylor expanded in KbT around inf 38.9%

   \[\leadsto NdChar + \frac{NaChar}{\color{blue}{2}} \]

8. Final simplification 38.9%

   \[\leadsto NdChar + \frac{NaChar}{2} \]

Reproduce

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