Bulmash initializePoisson

Percentage Accurate: 100.0% → 99.9%

Time: 35.6s

Alternatives: 33

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

Math

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

FPCore

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

C

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

Java

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Power[N[Power[N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision], 3.0], $MachinePrecision], 1/3], $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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing
5. Step-by-step derivation

   1. add-cbrt-cube 100.0%

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

   2. pow3 100.0%

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

   3. +-commutative 100.0%

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

   4. associate-+l- 100.0%

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

6. Applied egg-rr 100.0%

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

7. Final simplification 100.0%

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

Alternative 2: 65.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_2 := t\_1 + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ t_3 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ t_4 := t\_3 + \frac{NdChar}{1 + e^{\frac{Vef - Ec}{KbT}}}\\ \mathbf{if}\;mu \leq -1.25 \cdot 10^{+147}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;mu \leq -3.6 \cdot 10^{-189}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;mu \leq -1.35 \cdot 10^{-290}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;mu \leq 1.55 \cdot 10^{-37}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;mu \leq 38:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{mu}{KbT} + \frac{EDonor}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 5.8 \cdot 10^{+43}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;mu \leq 6.4 \cdot 10^{+151}:\\ \;\;\;\;t\_3 + t\_1\\ \mathbf{elif}\;mu \leq 3.5 \cdot 10^{+159}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
        (t_2 (+ t_1 (/ NaChar (+ 1.0 (exp (- (/ mu KbT)))))))
        (t_3 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
        (t_4 (+ t_3 (/ NdChar (+ 1.0 (exp (/ (- Vef Ec) KbT)))))))
   (if (<= mu -1.25e+147)
     t_2
     (if (<= mu -3.6e-189)
       t_4
       (if (<= mu -1.35e-290)
         t_0
         (if (<= mu 1.55e-37)
           t_4
           (if (<= mu 38.0)
             (+
              (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
              (/ NdChar (- (+ 2.0 (+ (/ mu KbT) (/ EDonor KbT))) (/ Ec KbT))))
             (if (<= mu 5.8e+43)
               t_4
               (if (<= mu 6.4e+151)
                 (+ t_3 t_1)
                 (if (<= mu 3.5e+159) t_0 t_2))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double t_1 = NdChar / (1.0 + exp((mu / KbT)));
	double t_2 = t_1 + (NaChar / (1.0 + exp(-(mu / KbT))));
	double t_3 = NaChar / (1.0 + exp((Ev / KbT)));
	double t_4 = t_3 + (NdChar / (1.0 + exp(((Vef - Ec) / KbT))));
	double tmp;
	if (mu <= -1.25e+147) {
		tmp = t_2;
	} else if (mu <= -3.6e-189) {
		tmp = t_4;
	} else if (mu <= -1.35e-290) {
		tmp = t_0;
	} else if (mu <= 1.55e-37) {
		tmp = t_4;
	} else if (mu <= 38.0) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((mu / KbT) + (EDonor / KbT))) - (Ec / KbT)));
	} else if (mu <= 5.8e+43) {
		tmp = t_4;
	} else if (mu <= 6.4e+151) {
		tmp = t_3 + t_1;
	} else if (mu <= 3.5e+159) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    t_1 = ndchar / (1.0d0 + exp((mu / kbt)))
    t_2 = t_1 + (nachar / (1.0d0 + exp(-(mu / kbt))))
    t_3 = nachar / (1.0d0 + exp((ev / kbt)))
    t_4 = t_3 + (ndchar / (1.0d0 + exp(((vef - ec) / kbt))))
    if (mu <= (-1.25d+147)) then
        tmp = t_2
    else if (mu <= (-3.6d-189)) then
        tmp = t_4
    else if (mu <= (-1.35d-290)) then
        tmp = t_0
    else if (mu <= 1.55d-37) then
        tmp = t_4
    else if (mu <= 38.0d0) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / ((2.0d0 + ((mu / kbt) + (edonor / kbt))) - (ec / kbt)))
    else if (mu <= 5.8d+43) then
        tmp = t_4
    else if (mu <= 6.4d+151) then
        tmp = t_3 + t_1
    else if (mu <= 3.5d+159) then
        tmp = t_0
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double t_1 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double t_2 = t_1 + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
	double t_3 = NaChar / (1.0 + Math.exp((Ev / KbT)));
	double t_4 = t_3 + (NdChar / (1.0 + Math.exp(((Vef - Ec) / KbT))));
	double tmp;
	if (mu <= -1.25e+147) {
		tmp = t_2;
	} else if (mu <= -3.6e-189) {
		tmp = t_4;
	} else if (mu <= -1.35e-290) {
		tmp = t_0;
	} else if (mu <= 1.55e-37) {
		tmp = t_4;
	} else if (mu <= 38.0) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((mu / KbT) + (EDonor / KbT))) - (Ec / KbT)));
	} else if (mu <= 5.8e+43) {
		tmp = t_4;
	} else if (mu <= 6.4e+151) {
		tmp = t_3 + t_1;
	} else if (mu <= 3.5e+159) {
		tmp = t_0;
	} 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((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	t_1 = NdChar / (1.0 + math.exp((mu / KbT)))
	t_2 = t_1 + (NaChar / (1.0 + math.exp(-(mu / KbT))))
	t_3 = NaChar / (1.0 + math.exp((Ev / KbT)))
	t_4 = t_3 + (NdChar / (1.0 + math.exp(((Vef - Ec) / KbT))))
	tmp = 0
	if mu <= -1.25e+147:
		tmp = t_2
	elif mu <= -3.6e-189:
		tmp = t_4
	elif mu <= -1.35e-290:
		tmp = t_0
	elif mu <= 1.55e-37:
		tmp = t_4
	elif mu <= 38.0:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((mu / KbT) + (EDonor / KbT))) - (Ec / KbT)))
	elif mu <= 5.8e+43:
		tmp = t_4
	elif mu <= 6.4e+151:
		tmp = t_3 + t_1
	elif mu <= 3.5e+159:
		tmp = t_0
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	t_2 = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))))
	t_3 = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))
	t_4 = Float64(t_3 + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef - Ec) / KbT)))))
	tmp = 0.0
	if (mu <= -1.25e+147)
		tmp = t_2;
	elseif (mu <= -3.6e-189)
		tmp = t_4;
	elseif (mu <= -1.35e-290)
		tmp = t_0;
	elseif (mu <= 1.55e-37)
		tmp = t_4;
	elseif (mu <= 38.0)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(mu / KbT) + Float64(EDonor / KbT))) - Float64(Ec / KbT))));
	elseif (mu <= 5.8e+43)
		tmp = t_4;
	elseif (mu <= 6.4e+151)
		tmp = Float64(t_3 + t_1);
	elseif (mu <= 3.5e+159)
		tmp = t_0;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	t_1 = NdChar / (1.0 + exp((mu / KbT)));
	t_2 = t_1 + (NaChar / (1.0 + exp(-(mu / KbT))));
	t_3 = NaChar / (1.0 + exp((Ev / KbT)));
	t_4 = t_3 + (NdChar / (1.0 + exp(((Vef - Ec) / KbT))));
	tmp = 0.0;
	if (mu <= -1.25e+147)
		tmp = t_2;
	elseif (mu <= -3.6e-189)
		tmp = t_4;
	elseif (mu <= -1.35e-290)
		tmp = t_0;
	elseif (mu <= 1.55e-37)
		tmp = t_4;
	elseif (mu <= 38.0)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((mu / KbT) + (EDonor / KbT))) - (Ec / KbT)));
	elseif (mu <= 5.8e+43)
		tmp = t_4;
	elseif (mu <= 6.4e+151)
		tmp = t_3 + t_1;
	elseif (mu <= 3.5e+159)
		tmp = t_0;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$3 + N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.25e+147], t$95$2, If[LessEqual[mu, -3.6e-189], t$95$4, If[LessEqual[mu, -1.35e-290], t$95$0, If[LessEqual[mu, 1.55e-37], t$95$4, If[LessEqual[mu, 38.0], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(mu / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 5.8e+43], t$95$4, If[LessEqual[mu, 6.4e+151], N[(t$95$3 + t$95$1), $MachinePrecision], If[LessEqual[mu, 3.5e+159], t$95$0, t$95$2]]]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if mu < -1.2500000000000001e147 or 3.4999999999999999e159 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 85.0%

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

   6. Taylor expanded in mu around inf 79.1%

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

      1. associate-*r/ 27.5%

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

      2. mul-1-neg 27.5%

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

   8. Simplified 79.1%

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

   if -1.2500000000000001e147 < mu < -3.60000000000000017e-189 or -1.34999999999999999e-290 < mu < 1.54999999999999997e-37 or 38 < mu < 5.8000000000000004e43

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 79.2%

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

   6. Taylor expanded in EDonor around 0 73.8%

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

      1. +-commutative 44.7%

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

   8. Simplified 73.8%

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

   9. Taylor expanded in mu around 0 73.1%

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

   if -3.60000000000000017e-189 < mu < -1.34999999999999999e-290 or 6.39999999999999988e151 < mu < 3.4999999999999999e159

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 81.2%

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

   6. Taylor expanded in EDonor around inf 72.5%

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

   if 1.54999999999999997e-37 < mu < 38

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 72.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 72.5%

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

   7. Simplified 72.5%

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

   8. Taylor expanded in Vef around 0 83.9%

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

   if 5.8000000000000004e43 < mu < 6.39999999999999988e151

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 72.4%

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

   6. Taylor expanded in mu around inf 68.4%

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

4. Final simplification 74.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1.25 \cdot 10^{+147}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -3.6 \cdot 10^{-189}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.35 \cdot 10^{-290}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.55 \cdot 10^{-37}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 38:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{mu}{KbT} + \frac{EDonor}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 5.8 \cdot 10^{+43}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 6.4 \cdot 10^{+151}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 3.5 \cdot 10^{+159}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 58.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;NdChar \leq -3.3 \cdot 10^{+201}:\\ \;\;\;\;t\_1 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -2 \cdot 10^{+95}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NdChar \leq -1.8 \cdot 10^{-89}:\\ \;\;\;\;t\_1 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 4.2 \cdot 10^{+132}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\frac{EDonor}{KbT} - \frac{Ec}{KbT}\right)}\\ \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 (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (- (/ mu KbT)))))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= NdChar -3.3e+201)
     (+ t_1 (/ NaChar (+ (/ Ev KbT) 2.0)))
     (if (<= NdChar -2e+95)
       t_0
       (if (<= NdChar -1.8e-89)
         (+ t_1 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
         (if (<= NdChar 4.2e+132)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
            (/ NdChar (+ 1.0 (- (/ EDonor KbT) (/ Ec KbT)))))
           t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	double t_1 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -3.3e+201) {
		tmp = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (NdChar <= -2e+95) {
		tmp = t_0;
	} else if (NdChar <= -1.8e-89) {
		tmp = t_1 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else if (NdChar <= 4.2e+132) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
	} 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((mu / kbt)))) + (nachar / (1.0d0 + exp(-(mu / kbt))))
    t_1 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    if (ndchar <= (-3.3d+201)) then
        tmp = t_1 + (nachar / ((ev / kbt) + 2.0d0))
    else if (ndchar <= (-2d+95)) then
        tmp = t_0
    else if (ndchar <= (-1.8d-89)) then
        tmp = t_1 + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
    else if (ndchar <= 4.2d+132) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + ((edonor / kbt) - (ec / kbt))))
    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((mu / KbT)))) + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
	double t_1 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -3.3e+201) {
		tmp = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (NdChar <= -2e+95) {
		tmp = t_0;
	} else if (NdChar <= -1.8e-89) {
		tmp = t_1 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else if (NdChar <= 4.2e+132) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
	} 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((mu / KbT)))) + (NaChar / (1.0 + math.exp(-(mu / KbT))))
	t_1 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if NdChar <= -3.3e+201:
		tmp = t_1 + (NaChar / ((Ev / KbT) + 2.0))
	elif NdChar <= -2e+95:
		tmp = t_0
	elif NdChar <= -1.8e-89:
		tmp = t_1 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))))
	elif NdChar <= 4.2e+132:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))))
	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(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (NdChar <= -3.3e+201)
		tmp = Float64(t_1 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	elseif (NdChar <= -2e+95)
		tmp = t_0;
	elseif (NdChar <= -1.8e-89)
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))));
	elseif (NdChar <= 4.2e+132)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(EDonor / KbT) - Float64(Ec / KbT)))));
	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((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	t_1 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (NdChar <= -3.3e+201)
		tmp = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	elseif (NdChar <= -2e+95)
		tmp = t_0;
	elseif (NdChar <= -1.8e-89)
		tmp = t_1 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	elseif (NdChar <= 4.2e+132)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
	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[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -3.3e+201], N[(t$95$1 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2e+95], t$95$0, If[LessEqual[NdChar, -1.8e-89], N[(t$95$1 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 4.2e+132], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -3.3e201

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 78.9%

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

   6. Taylor expanded in Ev around 0 63.4%

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

   if -3.3e201 < NdChar < -2.00000000000000004e95 or 4.19999999999999987e132 < NdChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 80.9%

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

   6. Taylor expanded in mu around inf 70.4%

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

      1. associate-*r/ 16.0%

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

      2. mul-1-neg 16.0%

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

   8. Simplified 70.4%

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

   if -2.00000000000000004e95 < NdChar < -1.80000000000000003e-89

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 72.9%

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

   6. Taylor expanded in EAccept around 0 64.5%

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

   if -1.80000000000000003e-89 < NdChar < 4.19999999999999987e132

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 63.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 63.3%

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

   7. Simplified 63.3%

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

   8. Taylor expanded in EDonor around inf 69.9%

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

4. Final simplification 68.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -3.3 \cdot 10^{+201}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -2 \cdot 10^{+95}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -1.8 \cdot 10^{-89}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 4.2 \cdot 10^{+132}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\frac{EDonor}{KbT} - \frac{Ec}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 66.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{if}\;EAccept \leq 5.8 \cdot 10^{-301}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_1\\ \mathbf{elif}\;EAccept \leq 4.1 \cdot 10^{+55}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 6 \cdot 10^{+178}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))))
   (if (<= EAccept 5.8e-301)
     (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_1)
     (if (<= EAccept 4.1e+55)
       (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
       (if (<= EAccept 6e+178)
         (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	double tmp;
	if (EAccept <= 5.8e-301) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_1;
	} else if (EAccept <= 4.1e+55) {
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (EAccept <= 6e+178) {
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))
    if (eaccept <= 5.8d-301) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_1
    else if (eaccept <= 4.1d+55) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    else if (eaccept <= 6d+178) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)));
	double tmp;
	if (EAccept <= 5.8e-301) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_1;
	} else if (EAccept <= 4.1e+55) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else if (EAccept <= 6e+178) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))
	tmp = 0
	if EAccept <= 5.8e-301:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_1
	elif EAccept <= 4.1e+55:
		tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif EAccept <= 6e+178:
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT))))
	tmp = 0.0
	if (EAccept <= 5.8e-301)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_1);
	elseif (EAccept <= 4.1e+55)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (EAccept <= 6e+178)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + t_1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	tmp = 0.0;
	if (EAccept <= 5.8e-301)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_1;
	elseif (EAccept <= 4.1e+55)
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (EAccept <= 6e+178)
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if EAccept < 5.79999999999999968e-301

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 72.8%

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

   6. Taylor expanded in EDonor around 0 66.8%

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

      1. +-commutative 46.2%

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

   8. Simplified 66.8%

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

   if 5.79999999999999968e-301 < EAccept < 4.09999999999999981e55

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 78.4%

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

   if 4.09999999999999981e55 < EAccept < 6.00000000000000031e178

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EDonor around inf 72.0%

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

   if 6.00000000000000031e178 < EAccept

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 96.1%

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

   6. Taylor expanded in EDonor around 0 87.4%

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

4. Final simplification 72.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 5.8 \cdot 10^{-301}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 4.1 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 6 \cdot 10^{+178}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 68.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ \mathbf{if}\;EAccept \leq 3.6 \cdot 10^{-301}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 2.35 \cdot 10^{+57}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 3.1 \cdot 10^{+101}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \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 (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))))
   (if (<= EAccept 3.6e-301)
     (+
      (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
      (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
     (if (<= EAccept 2.35e+57)
       (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
       (if (<= EAccept 3.1e+101)
         (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          (/ 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(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double tmp;
	if (EAccept <= 3.6e-301) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	} else if (EAccept <= 2.35e+57) {
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (EAccept <= 3.1e+101) {
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (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(((vef + (eaccept + (ev - mu))) / kbt)))
    if (eaccept <= 3.6d-301) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    else if (eaccept <= 2.35d+57) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    else if (eaccept <= 3.1d+101) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (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(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double tmp;
	if (EAccept <= 3.6e-301) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	} else if (EAccept <= 2.35e+57) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else if (EAccept <= 3.1e+101) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (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(((Vef + (EAccept + (Ev - mu))) / KbT)))
	tmp = 0
	if EAccept <= 3.6e-301:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	elif EAccept <= 2.35e+57:
		tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif EAccept <= 3.1e+101:
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (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(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	tmp = 0.0
	if (EAccept <= 3.6e-301)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))));
	elseif (EAccept <= 2.35e+57)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (EAccept <= 3.1e+101)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	tmp = 0.0;
	if (EAccept <= 3.6e-301)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	elseif (EAccept <= 2.35e+57)
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (EAccept <= 3.1e+101)
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (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[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, 3.6e-301], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 2.35e+57], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.1e+101], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if EAccept < 3.60000000000000007e-301

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 72.8%

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

   6. Taylor expanded in EDonor around 0 66.8%

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

      1. +-commutative 46.2%

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

   8. Simplified 66.8%

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

   if 3.60000000000000007e-301 < EAccept < 2.3500000000000001e57

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 78.4%

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

   if 2.3500000000000001e57 < EAccept < 3.09999999999999999e101

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EDonor around inf 78.6%

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

   if 3.09999999999999999e101 < EAccept

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 86.2%

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

4. Final simplification 74.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 3.6 \cdot 10^{-301}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 2.35 \cdot 10^{+57}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 3.1 \cdot 10^{+101}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 71.8% accurate, 1.0× speedup

Math

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

Derivation

1. Split input into 4 regimes

2. if EAccept < 4.40000000000000009e-179

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 73.9%

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

   if 4.40000000000000009e-179 < EAccept < 1.50000000000000003e56

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 74.2%

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

   if 1.50000000000000003e56 < EAccept < 2.49999999999999994e101

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EDonor around inf 78.6%

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

   if 2.49999999999999994e101 < EAccept

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 86.2%

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

4. Final simplification 76.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 4.4 \cdot 10^{-179}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.5 \cdot 10^{+56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 2.5 \cdot 10^{+101}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 73.7% accurate, 1.0× speedup

Math

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

2. if Ev < -3.99999999999999993e77

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 79.0%

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

   if -3.99999999999999993e77 < Ev < -4.80000000000000031e-39

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 88.9%

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

   if -4.80000000000000031e-39 < Ev < -2.2500000000000001e-210

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Vef around inf 82.4%

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

   if -2.2500000000000001e-210 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 71.7%

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

4. Final simplification 76.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -4 \cdot 10^{+77}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -4.8 \cdot 10^{-39}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;Ev \leq -2.25 \cdot 10^{-210}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 56.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;NdChar \leq -1.2 \cdot 10^{+186}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -3.5 \cdot 10^{+128}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NdChar \leq -1.8 \cdot 10^{-89}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 6.8 \cdot 10^{+130}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\frac{EDonor}{KbT} - \frac{Ec}{KbT}\right)}\\ \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 (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))
   (if (<= NdChar -1.2e+186)
     (+
      (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
      (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
     (if (<= NdChar -3.5e+128)
       t_0
       (if (<= NdChar -1.8e-89)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
         (if (<= NdChar 6.8e+130)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
            (/ NdChar (+ 1.0 (- (/ EDonor KbT) (/ Ec KbT)))))
           t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	double tmp;
	if (NdChar <= -1.2e+186) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (NdChar <= -3.5e+128) {
		tmp = t_0;
	} else if (NdChar <= -1.8e-89) {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else if (NdChar <= 6.8e+130) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    if (ndchar <= (-1.2d+186)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (ndchar <= (-3.5d+128)) then
        tmp = t_0
    else if (ndchar <= (-1.8d-89)) then
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
    else if (ndchar <= 6.8d+130) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + ((edonor / kbt) - (ec / kbt))))
    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((mu / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	double tmp;
	if (NdChar <= -1.2e+186) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (NdChar <= -3.5e+128) {
		tmp = t_0;
	} else if (NdChar <= -1.8e-89) {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else if (NdChar <= 6.8e+130) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
	} 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((mu / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	tmp = 0
	if NdChar <= -1.2e+186:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif NdChar <= -3.5e+128:
		tmp = t_0
	elif NdChar <= -1.8e-89:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))))
	elif NdChar <= 6.8e+130:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))))
	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(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))))
	tmp = 0.0
	if (NdChar <= -1.2e+186)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (NdChar <= -3.5e+128)
		tmp = t_0;
	elseif (NdChar <= -1.8e-89)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))));
	elseif (NdChar <= 6.8e+130)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(EDonor / KbT) - Float64(Ec / KbT)))));
	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((mu / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	tmp = 0.0;
	if (NdChar <= -1.2e+186)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (NdChar <= -3.5e+128)
		tmp = t_0;
	elseif (NdChar <= -1.8e-89)
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	elseif (NdChar <= 6.8e+130)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
	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[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.2e+186], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -3.5e+128], t$95$0, If[LessEqual[NdChar, -1.8e-89], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 6.8e+130], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -1.19999999999999998e186

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 78.3%

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

   6. Taylor expanded in EDonor around inf 56.1%

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

   if -1.19999999999999998e186 < NdChar < -3.49999999999999969e128 or 6.8000000000000001e130 < NdChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 80.2%

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

   6. Taylor expanded in EAccept around inf 67.0%

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

   if -3.49999999999999969e128 < NdChar < -1.80000000000000003e-89

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 71.7%

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

   6. Taylor expanded in EAccept around 0 64.1%

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

   if -1.80000000000000003e-89 < NdChar < 6.8000000000000001e130

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 63.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 63.3%

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

   7. Simplified 63.3%

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

   8. Taylor expanded in EDonor around inf 69.9%

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

4. Final simplification 66.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -1.2 \cdot 10^{+186}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -3.5 \cdot 10^{+128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -1.8 \cdot 10^{-89}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 6.8 \cdot 10^{+130}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\frac{EDonor}{KbT} - \frac{Ec}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 65.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_0\\ \mathbf{if}\;Ev \leq -3.2 \cdot 10^{+22}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Ev \leq -1.02 \cdot 10^{-86}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;Ev \leq -1.05 \cdot 10^{-169}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
        (t_1 (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)))
   (if (<= Ev -3.2e+22)
     t_1
     (if (<= Ev -1.02e-86)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
        (/
         NdChar
         (+
          1.0
          (-
           (+ (+ 1.0 (/ EDonor KbT)) (+ (/ mu KbT) (/ Vef KbT)))
           (/ Ec KbT)))))
       (if (<= Ev -1.05e-169)
         t_1
         (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	double tmp;
	if (Ev <= -3.2e+22) {
		tmp = t_1;
	} else if (Ev <= -1.02e-86) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if (Ev <= -1.05e-169) {
		tmp = t_1;
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))
    t_1 = (nachar / (1.0d0 + exp((ev / kbt)))) + t_0
    if (ev <= (-3.2d+22)) then
        tmp = t_1
    else if (ev <= (-1.02d-86)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + (((1.0d0 + (edonor / kbt)) + ((mu / kbt) + (vef / kbt))) - (ec / kbt))))
    else if (ev <= (-1.05d-169)) then
        tmp = t_1
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_0;
	double tmp;
	if (Ev <= -3.2e+22) {
		tmp = t_1;
	} else if (Ev <= -1.02e-86) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if (Ev <= -1.05e-169) {
		tmp = t_1;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_0
	tmp = 0
	if Ev <= -3.2e+22:
		tmp = t_1
	elif Ev <= -1.02e-86:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))))
	elif Ev <= -1.05e-169:
		tmp = t_1
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_0)
	tmp = 0.0
	if (Ev <= -3.2e+22)
		tmp = t_1;
	elseif (Ev <= -1.02e-86)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(1.0 + Float64(EDonor / KbT)) + Float64(Float64(mu / KbT) + Float64(Vef / KbT))) - Float64(Ec / KbT)))));
	elseif (Ev <= -1.05e-169)
		tmp = t_1;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	t_1 = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	tmp = 0.0;
	if (Ev <= -3.2e+22)
		tmp = t_1;
	elseif (Ev <= -1.02e-86)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	elseif (Ev <= -1.05e-169)
		tmp = t_1;
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_0;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -3.2e22 or -1.02000000000000005e-86 < Ev < -1.05e-169

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 76.4%

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

   6. Taylor expanded in EDonor around 0 69.6%

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

      1. +-commutative 33.4%

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

   8. Simplified 69.6%

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

   if -3.2e22 < Ev < -1.02000000000000005e-86

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 60.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 60.4%

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

   7. Simplified 60.4%

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

   if -1.05e-169 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 72.2%

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

   6. Taylor expanded in EDonor around 0 69.0%

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

4. Final simplification 68.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -3.2 \cdot 10^{+22}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Ev \leq -1.02 \cdot 10^{-86}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;Ev \leq -1.05 \cdot 10^{-169}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 67.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{if}\;Ev \leq -4 \cdot 10^{+77}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_0\\ \mathbf{elif}\;Ev \leq -9.8 \cdot 10^{-172}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + t\_0\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -3.99999999999999993e77

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 79.0%

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

   6. Taylor expanded in EDonor around 0 70.9%

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

      1. +-commutative 28.1%

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

   8. Simplified 70.9%

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

   if -3.99999999999999993e77 < Ev < -9.8000000000000001e-172

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EDonor around inf 78.0%

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

   if -9.8000000000000001e-172 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 72.2%

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

   6. Taylor expanded in EDonor around 0 69.0%

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

4. Final simplification 71.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -4 \cdot 10^{+77}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Ev \leq -9.8 \cdot 10^{-172}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 64.5% accurate, 1.0× speedup

Math

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

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -2.29999999999999997e95

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 80.0%

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

   6. Taylor expanded in EDonor around 0 71.6%

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

      1. +-commutative 27.3%

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

   8. Simplified 71.6%

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

   9. Taylor expanded in mu around 0 68.1%

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

   if -2.29999999999999997e95 < Ev < -8.5000000000000001e-81

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 59.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 59.4%

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

   7. Simplified 59.4%

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

   if -8.5000000000000001e-81 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 73.1%

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

   6. Taylor expanded in EDonor around 0 69.4%

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

4. Final simplification 67.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -2.3 \cdot 10^{+95}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef - Ec}{KbT}}}\\ \mathbf{elif}\;Ev \leq -8.5 \cdot 10^{-81}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing

5. Final simplification 100.0%

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

Alternative 13: 42.5% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{\frac{mu}{KbT} + 2}\\ t_1 := \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}} + t\_0\\ \mathbf{if}\;mu \leq -5 \cdot 10^{+145}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq -7.2 \cdot 10^{+43}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_0\\ \mathbf{elif}\;mu \leq -7.5 \cdot 10^{-39}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{+92}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;mu \leq 1.65 \cdot 10^{+255}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (/ mu KbT) 2.0)))
        (t_1 (+ (/ NaChar (+ 1.0 (exp (- (/ mu KbT))))) t_0)))
   (if (<= mu -5e+145)
     t_1
     (if (<= mu -7.2e+43)
       (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)
       (if (<= mu -7.5e-39)
         (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))
         (if (<= mu 1.6e+92)
           (+
            (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
            (/ NdChar (+ (/ EDonor KbT) 2.0)))
           (if (<= mu 1.65e+255)
             (+
              (/ NdChar (+ 1.0 (exp (/ mu KbT))))
              (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
             t_1)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / ((mu / KbT) + 2.0);
	double t_1 = (NaChar / (1.0 + exp(-(mu / KbT)))) + t_0;
	double tmp;
	if (mu <= -5e+145) {
		tmp = t_1;
	} else if (mu <= -7.2e+43) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	} else if (mu <= -7.5e-39) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((Vef / KbT))));
	} else if (mu <= 1.6e+92) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (mu <= 1.65e+255) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / ((mu / kbt) + 2.0d0)
    t_1 = (nachar / (1.0d0 + exp(-(mu / kbt)))) + t_0
    if (mu <= (-5d+145)) then
        tmp = t_1
    else if (mu <= (-7.2d+43)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_0
    else if (mu <= (-7.5d-39)) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + exp((vef / kbt))))
    else if (mu <= 1.6d+92) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (mu <= 1.65d+255) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / ((mu / KbT) + 2.0);
	double t_1 = (NaChar / (1.0 + Math.exp(-(mu / KbT)))) + t_0;
	double tmp;
	if (mu <= -5e+145) {
		tmp = t_1;
	} else if (mu <= -7.2e+43) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_0;
	} else if (mu <= -7.5e-39) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	} else if (mu <= 1.6e+92) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (mu <= 1.65e+255) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / ((mu / KbT) + 2.0)
	t_1 = (NaChar / (1.0 + math.exp(-(mu / KbT)))) + t_0
	tmp = 0
	if mu <= -5e+145:
		tmp = t_1
	elif mu <= -7.2e+43:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_0
	elif mu <= -7.5e-39:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + math.exp((Vef / KbT))))
	elif mu <= 1.6e+92:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	elif mu <= 1.65e+255:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(Float64(mu / KbT) + 2.0))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))) + t_0)
	tmp = 0.0
	if (mu <= -5e+145)
		tmp = t_1;
	elseif (mu <= -7.2e+43)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_0);
	elseif (mu <= -7.5e-39)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	elseif (mu <= 1.6e+92)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	elseif (mu <= 1.65e+255)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / ((mu / KbT) + 2.0);
	t_1 = (NaChar / (1.0 + exp(-(mu / KbT)))) + t_0;
	tmp = 0.0;
	if (mu <= -5e+145)
		tmp = t_1;
	elseif (mu <= -7.2e+43)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	elseif (mu <= -7.5e-39)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((Vef / KbT))));
	elseif (mu <= 1.6e+92)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (mu <= 1.65e+255)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, If[LessEqual[mu, -5e+145], t$95$1, If[LessEqual[mu, -7.2e+43], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[mu, -7.5e-39], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.6e+92], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.65e+255], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]

Derivation

1. Split input into 5 regimes

2. if mu < -4.99999999999999967e145 or 1.64999999999999991e255 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 84.2%

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

   6. Taylor expanded in mu around 0 56.3%

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

   7. Taylor expanded in mu around inf 52.0%

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

      1. associate-*r/ 31.4%

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

      2. mul-1-neg 31.4%

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

   9. Simplified 52.0%

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

   if -4.99999999999999967e145 < mu < -7.2000000000000002e43

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 75.4%

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

   6. Taylor expanded in mu around 0 70.3%

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

   7. Taylor expanded in Ev around inf 47.2%

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

   if -7.2000000000000002e43 < mu < -7.49999999999999971e-39

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 67.3%

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

   6. Taylor expanded in EDonor around 0 63.5%

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

      1. +-commutative 63.5%

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

   8. Simplified 63.5%

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

   9. Taylor expanded in Vef around inf 63.0%

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

   if -7.49999999999999971e-39 < mu < 1.60000000000000013e92

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 73.8%

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

   6. Taylor expanded in EDonor around inf 55.8%

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

   7. Taylor expanded in EDonor around 0 47.0%

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

   if 1.60000000000000013e92 < mu < 1.64999999999999991e255

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 86.0%

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

   6. Taylor expanded in EAccept around inf 63.8%

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

   7. Taylor expanded in EAccept around 0 52.8%

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

4. Final simplification 50.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -5 \cdot 10^{+145}:\\ \;\;\;\;\frac{NaChar}{1 + e^{-\frac{mu}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;mu \leq -7.2 \cdot 10^{+43}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;mu \leq -7.5 \cdot 10^{-39}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{+92}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;mu \leq 1.65 \cdot 10^{+255}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{-\frac{mu}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 53.0% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + t\_1\\ \mathbf{if}\;NdChar \leq -7.6 \cdot 10^{-162}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;NdChar \leq 4.1 \cdot 10^{-68}:\\ \;\;\;\;t\_0 + \frac{KbT}{\frac{EDonor}{NdChar}}\\ \mathbf{elif}\;NdChar \leq 3.5 \cdot 10^{-55}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + t\_1\\ \mathbf{elif}\;NdChar \leq 1.5 \cdot 10^{+99}:\\ \;\;\;\;t\_0 + \frac{KbT}{\frac{mu}{NdChar}}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1 (/ NaChar (+ (/ Ev KbT) 2.0)))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          t_1)))
   (if (<= NdChar -7.6e-162)
     t_2
     (if (<= NdChar 4.1e-68)
       (+ t_0 (/ KbT (/ EDonor NdChar)))
       (if (<= NdChar 3.5e-55)
         (+ (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))) t_1)
         (if (<= NdChar 1.5e+99) (+ t_0 (/ KbT (/ mu NdChar))) t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = NaChar / ((Ev / KbT) + 2.0);
	double t_2 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + t_1;
	double tmp;
	if (NdChar <= -7.6e-162) {
		tmp = t_2;
	} else if (NdChar <= 4.1e-68) {
		tmp = t_0 + (KbT / (EDonor / NdChar));
	} else if (NdChar <= 3.5e-55) {
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + t_1;
	} else if (NdChar <= 1.5e+99) {
		tmp = t_0 + (KbT / (mu / NdChar));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = nachar / ((ev / kbt) + 2.0d0)
    t_2 = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + t_1
    if (ndchar <= (-7.6d-162)) then
        tmp = t_2
    else if (ndchar <= 4.1d-68) then
        tmp = t_0 + (kbt / (edonor / ndchar))
    else if (ndchar <= 3.5d-55) then
        tmp = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) + t_1
    else if (ndchar <= 1.5d+99) then
        tmp = t_0 + (kbt / (mu / ndchar))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = NaChar / ((Ev / KbT) + 2.0);
	double t_2 = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + t_1;
	double tmp;
	if (NdChar <= -7.6e-162) {
		tmp = t_2;
	} else if (NdChar <= 4.1e-68) {
		tmp = t_0 + (KbT / (EDonor / NdChar));
	} else if (NdChar <= 3.5e-55) {
		tmp = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) + t_1;
	} else if (NdChar <= 1.5e+99) {
		tmp = t_0 + (KbT / (mu / NdChar));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = NaChar / ((Ev / KbT) + 2.0)
	t_2 = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + t_1
	tmp = 0
	if NdChar <= -7.6e-162:
		tmp = t_2
	elif NdChar <= 4.1e-68:
		tmp = t_0 + (KbT / (EDonor / NdChar))
	elif NdChar <= 3.5e-55:
		tmp = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))) + t_1
	elif NdChar <= 1.5e+99:
		tmp = t_0 + (KbT / (mu / NdChar))
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + t_1)
	tmp = 0.0
	if (NdChar <= -7.6e-162)
		tmp = t_2;
	elseif (NdChar <= 4.1e-68)
		tmp = Float64(t_0 + Float64(KbT / Float64(EDonor / NdChar)));
	elseif (NdChar <= 3.5e-55)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))) + t_1);
	elseif (NdChar <= 1.5e+99)
		tmp = Float64(t_0 + Float64(KbT / Float64(mu / NdChar)));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = NaChar / ((Ev / KbT) + 2.0);
	t_2 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + t_1;
	tmp = 0.0;
	if (NdChar <= -7.6e-162)
		tmp = t_2;
	elseif (NdChar <= 4.1e-68)
		tmp = t_0 + (KbT / (EDonor / NdChar));
	elseif (NdChar <= 3.5e-55)
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + t_1;
	elseif (NdChar <= 1.5e+99)
		tmp = t_0 + (KbT / (mu / NdChar));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[LessEqual[NdChar, -7.6e-162], t$95$2, If[LessEqual[NdChar, 4.1e-68], N[(t$95$0 + N[(KbT / N[(EDonor / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 3.5e-55], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[NdChar, 1.5e+99], N[(t$95$0 + N[(KbT / N[(mu / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -7.6000000000000001e-162 or 1.50000000000000007e99 < NdChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 78.7%

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

   6. Taylor expanded in Ev around 0 60.6%

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

   if -7.6000000000000001e-162 < NdChar < 4.10000000000000021e-68

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 67.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 67.6%

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

   7. Simplified 67.6%

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

   8. Taylor expanded in EDonor around inf 59.7%

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

      1. associate-/l* 61.1%

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

   10. Simplified 61.1%

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

   if 4.10000000000000021e-68 < NdChar < 3.50000000000000025e-55

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 52.1%

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

   6. Taylor expanded in EDonor around 0 52.1%

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

      1. +-commutative 42.0%

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

   8. Simplified 52.1%

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

   9. Taylor expanded in Ev around 0 52.6%

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

   if 3.50000000000000025e-55 < NdChar < 1.50000000000000007e99

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 65.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 65.6%

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

   7. Simplified 65.6%

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

   8. Taylor expanded in mu around inf 57.8%

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

      1. associate-/l* 57.8%

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

   10. Simplified 57.8%

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

4. Final simplification 60.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -7.6 \cdot 10^{-162}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 4.1 \cdot 10^{-68}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{KbT}{\frac{EDonor}{NdChar}}\\ \mathbf{elif}\;NdChar \leq 3.5 \cdot 10^{-55}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 1.5 \cdot 10^{+99}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{KbT}{\frac{mu}{NdChar}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 15: 50.0% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{if}\;NdChar \leq -7.6 \cdot 10^{-162}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 6.5 \cdot 10^{-69}:\\ \;\;\;\;t\_0 + \frac{KbT}{\frac{EDonor}{NdChar}}\\ \mathbf{elif}\;NdChar \leq 4.6 \cdot 10^{-54}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 1.5 \cdot 10^{+99}:\\ \;\;\;\;t\_0 + \frac{KbT}{\frac{mu}{NdChar}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))
          (/ NaChar (+ (/ Ev KbT) 2.0)))))
   (if (<= NdChar -7.6e-162)
     t_1
     (if (<= NdChar 6.5e-69)
       (+ t_0 (/ KbT (/ EDonor NdChar)))
       (if (<= NdChar 4.6e-54)
         t_1
         (if (<= NdChar 1.5e+99)
           (+ t_0 (/ KbT (/ mu NdChar)))
           (+
            (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
            (/ NaChar 2.0))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
	double tmp;
	if (NdChar <= -7.6e-162) {
		tmp = t_1;
	} else if (NdChar <= 6.5e-69) {
		tmp = t_0 + (KbT / (EDonor / NdChar));
	} else if (NdChar <= 4.6e-54) {
		tmp = t_1;
	} else if (NdChar <= 1.5e+99) {
		tmp = t_0 + (KbT / (mu / NdChar));
	} else {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) + (nachar / ((ev / kbt) + 2.0d0))
    if (ndchar <= (-7.6d-162)) then
        tmp = t_1
    else if (ndchar <= 6.5d-69) then
        tmp = t_0 + (kbt / (edonor / ndchar))
    else if (ndchar <= 4.6d-54) then
        tmp = t_1
    else if (ndchar <= 1.5d+99) then
        tmp = t_0 + (kbt / (mu / ndchar))
    else
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
	double tmp;
	if (NdChar <= -7.6e-162) {
		tmp = t_1;
	} else if (NdChar <= 6.5e-69) {
		tmp = t_0 + (KbT / (EDonor / NdChar));
	} else if (NdChar <= 4.6e-54) {
		tmp = t_1;
	} else if (NdChar <= 1.5e+99) {
		tmp = t_0 + (KbT / (mu / NdChar));
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / ((Ev / KbT) + 2.0))
	tmp = 0
	if NdChar <= -7.6e-162:
		tmp = t_1
	elif NdChar <= 6.5e-69:
		tmp = t_0 + (KbT / (EDonor / NdChar))
	elif NdChar <= 4.6e-54:
		tmp = t_1
	elif NdChar <= 1.5e+99:
		tmp = t_0 + (KbT / (mu / NdChar))
	else:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)))
	tmp = 0.0
	if (NdChar <= -7.6e-162)
		tmp = t_1;
	elseif (NdChar <= 6.5e-69)
		tmp = Float64(t_0 + Float64(KbT / Float64(EDonor / NdChar)));
	elseif (NdChar <= 4.6e-54)
		tmp = t_1;
	elseif (NdChar <= 1.5e+99)
		tmp = Float64(t_0 + Float64(KbT / Float64(mu / NdChar)));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
	tmp = 0.0;
	if (NdChar <= -7.6e-162)
		tmp = t_1;
	elseif (NdChar <= 6.5e-69)
		tmp = t_0 + (KbT / (EDonor / NdChar));
	elseif (NdChar <= 4.6e-54)
		tmp = t_1;
	elseif (NdChar <= 1.5e+99)
		tmp = t_0 + (KbT / (mu / NdChar));
	else
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -7.6e-162], t$95$1, If[LessEqual[NdChar, 6.5e-69], N[(t$95$0 + N[(KbT / N[(EDonor / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 4.6e-54], t$95$1, If[LessEqual[NdChar, 1.5e+99], N[(t$95$0 + N[(KbT / N[(mu / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -7.6000000000000001e-162 or 6.49999999999999951e-69 < NdChar < 4.5999999999999998e-54

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 77.4%

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

   6. Taylor expanded in EDonor around 0 72.4%

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

      1. +-commutative 47.5%

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

   8. Simplified 72.4%

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

   9. Taylor expanded in Ev around 0 57.4%

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

   if -7.6000000000000001e-162 < NdChar < 6.49999999999999951e-69

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 67.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 67.6%

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

   7. Simplified 67.6%

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

   8. Taylor expanded in EDonor around inf 59.7%

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

      1. associate-/l* 61.1%

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

   10. Simplified 61.1%

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

   if 4.5999999999999998e-54 < NdChar < 1.50000000000000007e99

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 65.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 65.6%

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

   7. Simplified 65.6%

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

   8. Taylor expanded in mu around inf 57.8%

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

      1. associate-/l* 57.8%

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

   10. Simplified 57.8%

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

   if 1.50000000000000007e99 < NdChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 53.5%

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

4. Final simplification 57.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -7.6 \cdot 10^{-162}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 6.5 \cdot 10^{-69}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{KbT}{\frac{EDonor}{NdChar}}\\ \mathbf{elif}\;NdChar \leq 4.6 \cdot 10^{-54}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 1.5 \cdot 10^{+99}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{KbT}{\frac{mu}{NdChar}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 39.2% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{if}\;NaChar \leq -3.7 \cdot 10^{-210}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NaChar \leq 1.1 \cdot 10^{-180}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq 2.1 \cdot 10^{-144}:\\ \;\;\;\;\frac{NaChar}{1 + e^{-\frac{mu}{KbT}}} + \frac{NdChar \cdot KbT}{EDonor}\\ \mathbf{elif}\;NaChar \leq 4.7 \cdot 10^{-63}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ (/ EDonor KbT) 2.0)))))
   (if (<= NaChar -3.7e-210)
     t_0
     (if (<= NaChar 1.1e-180)
       (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (* NaChar 0.5))
       (if (<= NaChar 2.1e-144)
         (+ (/ NaChar (+ 1.0 (exp (- (/ mu KbT))))) (/ (* NdChar KbT) EDonor))
         (if (<= NaChar 4.7e-63)
           (+
            (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
            (/ NdChar (+ (/ mu KbT) 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 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	double tmp;
	if (NaChar <= -3.7e-210) {
		tmp = t_0;
	} else if (NaChar <= 1.1e-180) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar * 0.5);
	} else if (NaChar <= 2.1e-144) {
		tmp = (NaChar / (1.0 + exp(-(mu / KbT)))) + ((NdChar * KbT) / EDonor);
	} else if (NaChar <= 4.7e-63) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    if (nachar <= (-3.7d-210)) then
        tmp = t_0
    else if (nachar <= 1.1d-180) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar * 0.5d0)
    else if (nachar <= 2.1d-144) then
        tmp = (nachar / (1.0d0 + exp(-(mu / kbt)))) + ((ndchar * kbt) / edonor)
    else if (nachar <= 4.7d-63) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / ((mu / kbt) + 2.0d0))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	double tmp;
	if (NaChar <= -3.7e-210) {
		tmp = t_0;
	} else if (NaChar <= 1.1e-180) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar * 0.5);
	} else if (NaChar <= 2.1e-144) {
		tmp = (NaChar / (1.0 + Math.exp(-(mu / KbT)))) + ((NdChar * KbT) / EDonor);
	} else if (NaChar <= 4.7e-63) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	tmp = 0
	if NaChar <= -3.7e-210:
		tmp = t_0
	elif NaChar <= 1.1e-180:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar * 0.5)
	elif NaChar <= 2.1e-144:
		tmp = (NaChar / (1.0 + math.exp(-(mu / KbT)))) + ((NdChar * KbT) / EDonor)
	elif NaChar <= 4.7e-63:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / ((mu / KbT) + 2.0))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)))
	tmp = 0.0
	if (NaChar <= -3.7e-210)
		tmp = t_0;
	elseif (NaChar <= 1.1e-180)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar * 0.5));
	elseif (NaChar <= 2.1e-144)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))) + Float64(Float64(NdChar * KbT) / EDonor));
	elseif (NaChar <= 4.7e-63)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(Float64(mu / KbT) + 2.0)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	tmp = 0.0;
	if (NaChar <= -3.7e-210)
		tmp = t_0;
	elseif (NaChar <= 1.1e-180)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar * 0.5);
	elseif (NaChar <= 2.1e-144)
		tmp = (NaChar / (1.0 + exp(-(mu / KbT)))) + ((NdChar * KbT) / EDonor);
	elseif (NaChar <= 4.7e-63)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -3.7e-210], t$95$0, If[LessEqual[NaChar, 1.1e-180], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.1e-144], N[(N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(NdChar * KbT), $MachinePrecision] / EDonor), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 4.7e-63], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -3.7000000000000003e-210 or 4.7000000000000001e-63 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 65.7%

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

   6. Taylor expanded in EDonor around inf 50.5%

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

   7. Taylor expanded in EDonor around 0 44.8%

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

   if -3.7000000000000003e-210 < NaChar < 1.10000000000000007e-180

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 52.3%

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

   6. Taylor expanded in EAccept around inf 48.6%

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

   7. Taylor expanded in EAccept around 0 44.9%

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

   if 1.10000000000000007e-180 < NaChar < 2.1000000000000001e-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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 67.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 67.2%

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

   7. Simplified 67.2%

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

   8. Taylor expanded in EDonor around inf 69.0%

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

   9. Taylor expanded in mu around inf 68.0%

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

       1. associate-*r/ 68.0%

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

       2. mul-1-neg 68.0%

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

   11. Simplified 68.0%

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

   if 2.1000000000000001e-144 < NaChar < 4.7000000000000001e-63

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 71.1%

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

   6. Taylor expanded in mu around 0 65.6%

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

   7. Taylor expanded in Vef around inf 60.2%

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

4. Final simplification 46.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3.7 \cdot 10^{-210}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 1.1 \cdot 10^{-180}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq 2.1 \cdot 10^{-144}:\\ \;\;\;\;\frac{NaChar}{1 + e^{-\frac{mu}{KbT}}} + \frac{NdChar \cdot KbT}{EDonor}\\ \mathbf{elif}\;NaChar \leq 4.7 \cdot 10^{-63}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 61.2% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;NdChar \leq -5 \cdot 10^{-90}:\\ \;\;\;\;t\_0 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 1.45 \cdot 10^{+131}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\frac{EDonor}{KbT} - \frac{Ec}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= NdChar -5e-90)
     (+ t_0 (/ NaChar (+ (/ Ev KbT) 2.0)))
     (if (<= NdChar 1.45e+131)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
        (/ NdChar (+ 1.0 (- (/ EDonor KbT) (/ Ec KbT)))))
       (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if NdChar <= -5e-90:
		tmp = t_0 + (NaChar / ((Ev / KbT) + 2.0))
	elif NdChar <= 1.45e+131:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))))
	else:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (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(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (NdChar <= -5e-90)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	elseif (NdChar <= 1.45e+131)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(EDonor / KbT) - Float64(Ec / KbT)))));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (NdChar <= -5e-90)
		tmp = t_0 + (NaChar / ((Ev / KbT) + 2.0));
	elseif (NdChar <= 1.45e+131)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
	else
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (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[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -5e-90], N[(t$95$0 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.45e+131], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -5.00000000000000019e-90

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 79.4%

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

   6. Taylor expanded in Ev around 0 61.0%

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

   if -5.00000000000000019e-90 < NdChar < 1.45000000000000005e131

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 63.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 63.3%

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

   7. Simplified 63.3%

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

   8. Taylor expanded in EDonor around inf 69.9%

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

   if 1.45000000000000005e131 < NdChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 71.9%

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

   6. Taylor expanded in EAccept around 0 56.7%

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

4. Final simplification 65.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -5 \cdot 10^{-90}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 1.45 \cdot 10^{+131}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\frac{EDonor}{KbT} - \frac{Ec}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 61.3% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;NdChar \leq -6.8 \cdot 10^{-171}:\\ \;\;\;\;t\_0 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 4 \cdot 10^{+130}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= NdChar -6.8e-171)
     (+ t_0 (/ NaChar (+ (/ Ev KbT) 2.0)))
     (if (<= NdChar 4e+130)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
        (/ NdChar (- 1.0 (/ Ec KbT))))
       (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if NdChar <= -6.8e-171:
		tmp = t_0 + (NaChar / ((Ev / KbT) + 2.0))
	elif NdChar <= 4e+130:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 - (Ec / KbT)))
	else:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (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(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (NdChar <= -6.8e-171)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	elseif (NdChar <= 4e+130)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (NdChar <= -6.8e-171)
		tmp = t_0 + (NaChar / ((Ev / KbT) + 2.0));
	elseif (NdChar <= 4e+130)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 - (Ec / KbT)));
	else
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (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[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -6.8e-171], N[(t$95$0 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 4e+130], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -6.7999999999999997e-171

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 79.7%

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

   6. Taylor expanded in Ev around 0 59.3%

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

   if -6.7999999999999997e-171 < NdChar < 4.0000000000000002e130

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 64.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 64.6%

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

   7. Simplified 64.6%

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

   8. Taylor expanded in Ec around inf 71.3%

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

      1. neg-mul-1 71.3%

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

      2. distribute-neg-frac 71.3%

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

   10. Simplified 71.3%

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

   if 4.0000000000000002e130 < NdChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 71.9%

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

   6. Taylor expanded in EAccept around 0 56.7%

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

4. Final simplification 64.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -6.8 \cdot 10^{-171}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 4 \cdot 10^{+130}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 19: 44.9% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -3.3e+42)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
   (if (<= NaChar 5.8e-196)
     (+ (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))) (/ NaChar 2.0))
     (if (<= NaChar 2.2e-103)
       (+
        (/ NaChar (+ 1.0 (exp (- (/ mu KbT)))))
        (/ NdChar (+ (/ mu KbT) 2.0)))
       (+
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
        (/ NdChar (+ (/ EDonor KbT) 2.0)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -3.3e+42) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	} else if (NaChar <= 5.8e-196) {
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	} else if (NaChar <= 2.2e-103) {
		tmp = (NaChar / (1.0 + exp(-(mu / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (nachar <= (-3.3d+42)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 2.0d0)
    else if (nachar <= 5.8d-196) then
        tmp = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) + (nachar / 2.0d0)
    else if (nachar <= 2.2d-103) then
        tmp = (nachar / (1.0d0 + exp(-(mu / kbt)))) + (ndchar / ((mu / kbt) + 2.0d0))
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -3.3e+42) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
	} else if (NaChar <= 5.8e-196) {
		tmp = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	} else if (NaChar <= 2.2e-103) {
		tmp = (NaChar / (1.0 + Math.exp(-(mu / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -3.3e+42:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	elif NaChar <= 5.8e-196:
		tmp = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / 2.0)
	elif NaChar <= 2.2e-103:
		tmp = (NaChar / (1.0 + math.exp(-(mu / KbT)))) + (NdChar / ((mu / KbT) + 2.0))
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -3.3e+42)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0));
	elseif (NaChar <= 5.8e-196)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))) + Float64(NaChar / 2.0));
	elseif (NaChar <= 2.2e-103)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))) + Float64(NdChar / Float64(Float64(mu / KbT) + 2.0)));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -3.3e+42)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	elseif (NaChar <= 5.8e-196)
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	elseif (NaChar <= 2.2e-103)
		tmp = (NaChar / (1.0 + exp(-(mu / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if NaChar < -3.2999999999999999e42

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 65.6%

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

   6. Taylor expanded in KbT around inf 44.7%

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

   if -3.2999999999999999e42 < NaChar < 5.79999999999999974e-196

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 55.1%

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

   6. Taylor expanded in EDonor around 0 52.5%

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

      1. +-commutative 52.5%

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

   8. Simplified 52.5%

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

   if 5.79999999999999974e-196 < NaChar < 2.1999999999999999e-103

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 79.2%

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

   6. Taylor expanded in mu around 0 79.0%

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

   7. Taylor expanded in mu around inf 71.1%

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

      1. associate-*r/ 34.3%

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

      2. mul-1-neg 34.3%

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

   9. Simplified 71.1%

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

   if 2.1999999999999999e-103 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 59.4%

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

   6. Taylor expanded in EDonor around inf 47.6%

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

   7. Taylor expanded in EDonor around 0 41.0%

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

4. Final simplification 48.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3.3 \cdot 10^{+42}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;NaChar \leq 5.8 \cdot 10^{-196}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;NaChar \leq 2.2 \cdot 10^{-103}:\\ \;\;\;\;\frac{NaChar}{1 + e^{-\frac{mu}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 20: 60.5% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.65e+71) (not (<= NaChar 6.8e-181)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar (+ (/ mu KbT) 2.0)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
    (/ NaChar (+ (/ Ev KbT) 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.65e+71], N[Not[LessEqual[NaChar, 6.8e-181]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.6499999999999999e71 or 6.8000000000000001e-181 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 75.0%

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

   6. Taylor expanded in mu around 0 57.8%

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

   if -1.6499999999999999e71 < NaChar < 6.8000000000000001e-181

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 80.3%

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

   6. Taylor expanded in Ev around 0 61.9%

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

4. Final simplification 59.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.65 \cdot 10^{+71} \lor \neg \left(NaChar \leq 6.8 \cdot 10^{-181}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 21: 60.6% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;NdChar \leq -6.8 \cdot 10^{-171}:\\ \;\;\;\;t\_0 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 3.8 \cdot 10^{+130}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t\_0 + \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 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= NdChar -6.8e-171)
     (+ t_0 (/ NaChar (+ (/ Ev KbT) 2.0)))
     (if (<= NdChar 3.8e+130)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
        (/ NdChar (- 1.0 (/ Ec KbT))))
       (+ t_0 (/ NaChar 2.0))))))

C

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

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    if (ndchar <= (-6.8d-171)) then
        tmp = t_0 + (nachar / ((ev / kbt) + 2.0d0))
    else if (ndchar <= 3.8d+130) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 - (ec / kbt)))
    else
        tmp = t_0 + (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 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -6.8e-171) {
		tmp = t_0 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (NdChar <= 3.8e+130) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 - (Ec / KbT)));
	} else {
		tmp = t_0 + (NaChar / 2.0);
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (NdChar <= -6.8e-171)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	elseif (NdChar <= 3.8e+130)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))));
	else
		tmp = Float64(t_0 + 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 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (NdChar <= -6.8e-171)
		tmp = t_0 + (NaChar / ((Ev / KbT) + 2.0));
	elseif (NdChar <= 3.8e+130)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 - (Ec / KbT)));
	else
		tmp = t_0 + (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[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -6.8e-171], N[(t$95$0 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 3.8e+130], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -6.7999999999999997e-171

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 79.7%

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

   6. Taylor expanded in Ev around 0 59.3%

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

   if -6.7999999999999997e-171 < NdChar < 3.8000000000000002e130

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 64.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 64.6%

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

   7. Simplified 64.6%

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

   8. Taylor expanded in Ec around inf 71.3%

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

      1. neg-mul-1 71.3%

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

      2. distribute-neg-frac 71.3%

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

   10. Simplified 71.3%

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

   if 3.8000000000000002e130 < NdChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 55.2%

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

4. Final simplification 64.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -6.8 \cdot 10^{-171}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 3.8 \cdot 10^{+130}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 22: 37.6% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{if}\;KbT \leq -2.1 \cdot 10^{-299}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 9.5 \cdot 10^{-260}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;KbT \leq 8 \cdot 10^{-194}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 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 (/ EAccept KbT))))
          (/ NdChar (+ (/ EDonor KbT) 2.0)))))
   (if (<= KbT -2.1e-299)
     t_0
     (if (<= KbT 9.5e-260)
       (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))
       (if (<= KbT 8e-194)
         t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
          (/ NdChar (+ (/ mu KbT) 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 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	double tmp;
	if (KbT <= -2.1e-299) {
		tmp = t_0;
	} else if (KbT <= 9.5e-260) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((Vef / KbT))));
	} else if (KbT <= 8e-194) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    if (kbt <= (-2.1d-299)) then
        tmp = t_0
    else if (kbt <= 9.5d-260) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + exp((vef / kbt))))
    else if (kbt <= 8d-194) then
        tmp = t_0
    else
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / ((mu / kbt) + 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 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	double tmp;
	if (KbT <= -2.1e-299) {
		tmp = t_0;
	} else if (KbT <= 9.5e-260) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	} else if (KbT <= 8e-194) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	tmp = 0
	if KbT <= -2.1e-299:
		tmp = t_0
	elif KbT <= 9.5e-260:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + math.exp((Vef / KbT))))
	elif KbT <= 8e-194:
		tmp = t_0
	else:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / ((mu / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)))
	tmp = 0.0
	if (KbT <= -2.1e-299)
		tmp = t_0;
	elseif (KbT <= 9.5e-260)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	elseif (KbT <= 8e-194)
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(Float64(mu / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	tmp = 0.0;
	if (KbT <= -2.1e-299)
		tmp = t_0;
	elseif (KbT <= 9.5e-260)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((Vef / KbT))));
	elseif (KbT <= 8e-194)
		tmp = t_0;
	else
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.1e-299], t$95$0, If[LessEqual[KbT, 9.5e-260], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 8e-194], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.1000000000000001e-299 or 9.5000000000000001e-260 < KbT < 8.00000000000000014e-194

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 68.0%

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

   6. Taylor expanded in EDonor around inf 49.5%

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

   7. Taylor expanded in EDonor around 0 42.4%

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

   if -2.1000000000000001e-299 < KbT < 9.5000000000000001e-260

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 38.2%

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

   6. Taylor expanded in EDonor around 0 30.0%

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

      1. +-commutative 30.0%

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

   8. Simplified 30.0%

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

   9. Taylor expanded in Vef around inf 38.1%

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

   if 8.00000000000000014e-194 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 70.4%

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

   6. Taylor expanded in mu around 0 52.7%

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

   7. Taylor expanded in Ev around inf 38.5%

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

4. Final simplification 40.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.1 \cdot 10^{-299}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq 9.5 \cdot 10^{-260}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;KbT \leq 8 \cdot 10^{-194}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 23: 47.2% accurate, 1.8× speedup

Math

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

FPCore

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

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.25e+73) || !(KbT <= 3.2e-38)) {
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * (KbT / EDonor));
	}
	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.25d+73)) .or. (.not. (kbt <= 3.2d-38))) then
        tmp = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) + (nachar / 2.0d0)
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * (kbt / edonor))
    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.25e+73) || !(KbT <= 3.2e-38)) {
		tmp = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * (KbT / EDonor));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -1.25e+73], N[Not[LessEqual[KbT, 3.2e-38]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * N[(KbT / EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -1.24999999999999994e73 or 3.19999999999999977e-38 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 60.4%

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

   6. Taylor expanded in EDonor around 0 58.5%

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

      1. +-commutative 58.5%

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

   8. Simplified 58.5%

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

   if -1.24999999999999994e73 < KbT < 3.19999999999999977e-38

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 48.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 48.9%

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

   7. Simplified 48.9%

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

   8. Taylor expanded in EDonor around inf 48.5%

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

      1. associate-/l* 46.4%

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

      2. associate-/r/ 49.1%

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

   10. Applied egg-rr 49.1%

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

4. Final simplification 53.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.25 \cdot 10^{+73} \lor \neg \left(KbT \leq 3.2 \cdot 10^{-38}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot \frac{KbT}{EDonor}\\ \end{array} \]
5. Add Preprocessing

Alternative 24: 50.3% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -7.6e-149) (not (<= NdChar 1.5e+99)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
    (/ NaChar 2.0))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ KbT (/ EDonor NdChar)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -7.6e-149], N[Not[LessEqual[NdChar, 1.5e+99]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(KbT / N[(EDonor / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -7.6000000000000001e-149 or 1.50000000000000007e99 < NdChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 52.0%

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

   if -7.6000000000000001e-149 < NdChar < 1.50000000000000007e99

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 64.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 64.9%

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

   7. Simplified 64.9%

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

   8. Taylor expanded in EDonor around inf 54.7%

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

      1. associate-/l* 55.7%

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

   10. Simplified 55.7%

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

4. Final simplification 53.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -7.6 \cdot 10^{-149} \lor \neg \left(NdChar \leq 1.5 \cdot 10^{+99}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{KbT}{\frac{EDonor}{NdChar}}\\ \end{array} \]
5. Add Preprocessing

Alternative 25: 40.2% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{if}\;Ev \leq -4.2 \cdot 10^{+216}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_0\\ \mathbf{elif}\;Ev \leq -1.8 \cdot 10^{-174}:\\ \;\;\;\;\frac{NaChar}{1 + e^{-\frac{mu}{KbT}}} + t\_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (/ mu KbT) 2.0))))
   (if (<= Ev -4.2e+216)
     (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)
     (if (<= Ev -1.8e-174)
       (+ (/ NaChar (+ 1.0 (exp (- (/ mu KbT))))) t_0)
       (+
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
        (/ NdChar (+ (/ EDonor KbT) 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 / ((mu / KbT) + 2.0);
	double tmp;
	if (Ev <= -4.2e+216) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	} else if (Ev <= -1.8e-174) {
		tmp = (NaChar / (1.0 + exp(-(mu / KbT)))) + t_0;
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / ((mu / kbt) + 2.0d0)
    if (ev <= (-4.2d+216)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_0
    else if (ev <= (-1.8d-174)) then
        tmp = (nachar / (1.0d0 + exp(-(mu / kbt)))) + t_0
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / ((edonor / kbt) + 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 / ((mu / KbT) + 2.0);
	double tmp;
	if (Ev <= -4.2e+216) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_0;
	} else if (Ev <= -1.8e-174) {
		tmp = (NaChar / (1.0 + Math.exp(-(mu / KbT)))) + t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / ((mu / KbT) + 2.0);
	tmp = 0.0;
	if (Ev <= -4.2e+216)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	elseif (Ev <= -1.8e-174)
		tmp = (NaChar / (1.0 + exp(-(mu / KbT)))) + t_0;
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 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[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -4.2e+216], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[Ev, -1.8e-174], N[(N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if Ev < -4.20000000000000003e216

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 70.7%

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

   6. Taylor expanded in mu around 0 45.4%

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

   7. Taylor expanded in Ev around inf 40.9%

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

   if -4.20000000000000003e216 < Ev < -1.79999999999999999e-174

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 67.3%

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

   6. Taylor expanded in mu around 0 46.1%

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

   7. Taylor expanded in mu around inf 38.8%

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

      1. associate-*r/ 16.6%

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

      2. mul-1-neg 16.6%

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

   9. Simplified 38.8%

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

   if -1.79999999999999999e-174 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 72.4%

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

   6. Taylor expanded in EDonor around inf 51.9%

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

   7. Taylor expanded in EDonor around 0 46.0%

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

4. Final simplification 43.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -4.2 \cdot 10^{+216}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;Ev \leq -1.8 \cdot 10^{-174}:\\ \;\;\;\;\frac{NaChar}{1 + e^{-\frac{mu}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 26: 38.6% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -7.4 \cdot 10^{+143}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;Ev \leq -6.5 \cdot 10^{-280}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Ev <= -7.4e+143:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	elif Ev <= -6.5e-280:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar * 0.5)
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Ev <= -7.4e+143)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0));
	elseif (Ev <= -6.5e-280)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar * 0.5));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Ev <= -7.4e+143)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	elseif (Ev <= -6.5e-280)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar * 0.5);
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -7.4e+143], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -6.5e-280], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if Ev < -7.4000000000000003e143

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 80.3%

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

   6. Taylor expanded in KbT around inf 35.1%

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

   if -7.4000000000000003e143 < Ev < -6.5000000000000005e-280

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 72.6%

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

   6. Taylor expanded in EAccept around inf 51.7%

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

   7. Taylor expanded in EAccept around 0 40.3%

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

   if -6.5000000000000005e-280 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 72.0%

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

   6. Taylor expanded in EDonor around inf 52.9%

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

   7. Taylor expanded in EDonor around 0 45.2%

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

4. Final simplification 41.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -7.4 \cdot 10^{+143}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;Ev \leq -6.5 \cdot 10^{-280}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 27: 31.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -3.5 \cdot 10^{+142}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;Ev \leq 9 \cdot 10^{-189}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar \cdot KbT}{EDonor}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -3.5e+142)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
   (if (<= Ev 9e-189)
     (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (* NaChar 0.5))
     (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ (* NdChar KbT) EDonor)))))

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 <= -3.5e+142) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	} else if (Ev <= 9e-189) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar * 0.5);
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + ((NdChar * KbT) / EDonor);
	}
	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 <= (-3.5d+142)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 2.0d0)
    else if (ev <= 9d-189) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar * 0.5d0)
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + ((ndchar * kbt) / edonor)
    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 <= -3.5e+142) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
	} else if (Ev <= 9e-189) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar * 0.5);
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + ((NdChar * KbT) / EDonor);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Ev <= -3.5e+142:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	elif Ev <= 9e-189:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar * 0.5)
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + ((NdChar * KbT) / EDonor)
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -3.49999999999999997e142

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 80.3%

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

   6. Taylor expanded in KbT around inf 35.1%

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

   if -3.49999999999999997e142 < Ev < 8.9999999999999992e-189

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 70.9%

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

   6. Taylor expanded in EAccept around inf 53.2%

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

   7. Taylor expanded in EAccept around 0 42.3%

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

   if 8.9999999999999992e-189 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in KbT around inf 53.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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   6. Step-by-step derivation

      1. associate-+r+ 53.6%

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

   7. Simplified 53.6%

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

   8. Taylor expanded in EDonor around inf 45.3%

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

   9. Taylor expanded in EAccept around inf 30.7%

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

4. Final simplification 36.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -3.5 \cdot 10^{+142}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;Ev \leq 9 \cdot 10^{-189}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar \cdot KbT}{EDonor}\\ \end{array} \]
5. Add Preprocessing

Alternative 28: 38.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -2.6 \cdot 10^{-206} \lor \neg \left(NaChar \leq 3.5 \cdot 10^{+84}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -2.6e-206) (not (<= NaChar 3.5e+84)))
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
   (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 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 ((NaChar <= -2.6e-206) || !(NaChar <= 3.5e+84)) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 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 ((nachar <= (-2.6d-206)) .or. (.not. (nachar <= 3.5d+84))) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 2.0d0)
    else
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar * 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 ((NaChar <= -2.6e-206) || !(NaChar <= 3.5e+84)) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar * 0.5);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -2.6e-206], N[Not[LessEqual[NaChar, 3.5e+84]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.6e-206 or 3.4999999999999999e84 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 69.0%

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

   6. Taylor expanded in KbT around inf 40.1%

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

   if -2.6e-206 < NaChar < 3.4999999999999999e84

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 68.8%

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

   6. Taylor expanded in EDonor around inf 45.0%

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

   7. Taylor expanded in EAccept around 0 36.0%

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

4. Final simplification 38.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.6 \cdot 10^{-206} \lor \neg \left(NaChar \leq 3.5 \cdot 10^{+84}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 29: 38.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -7.5 \cdot 10^{+142} \lor \neg \left(Ev \leq 4.6 \cdot 10^{-36}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Ev, -7.5e+142], N[Not[LessEqual[Ev, 4.6e-36]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Ev < -7.5000000000000002e142 or 4.59999999999999993e-36 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 81.9%

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

   6. Taylor expanded in KbT around inf 39.3%

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

   if -7.5000000000000002e142 < Ev < 4.59999999999999993e-36

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 72.4%

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

   6. Taylor expanded in EAccept around inf 54.4%

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

   7. Taylor expanded in EAccept around 0 40.1%

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

4. Final simplification 39.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -7.5 \cdot 10^{+142} \lor \neg \left(Ev \leq 4.6 \cdot 10^{-36}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 30: 37.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -4 \cdot 10^{+141}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;Ev \leq 2.6 \cdot 10^{-226}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -4e+141)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
   (if (<= Ev 2.6e-226)
     (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (* NaChar 0.5))
     (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -4e+141) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	} else if (Ev <= 2.6e-226) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar * 0.5);
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (ev <= (-4d+141)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 2.0d0)
    else if (ev <= 2.6d-226) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar * 0.5d0)
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -4e+141) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
	} else if (Ev <= 2.6e-226) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar * 0.5);
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Ev <= -4e+141:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	elif Ev <= 2.6e-226:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar * 0.5)
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Ev <= -4e+141)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0));
	elseif (Ev <= 2.6e-226)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar * 0.5));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Ev <= -4e+141)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	elseif (Ev <= 2.6e-226)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar * 0.5);
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -4e+141], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 2.6e-226], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if Ev < -4.00000000000000007e141

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Ev around inf 80.3%

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

   6. Taylor expanded in KbT around inf 35.1%

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

   if -4.00000000000000007e141 < Ev < 2.5999999999999998e-226

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in mu around inf 71.7%

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

   6. Taylor expanded in EAccept around inf 53.7%

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

   7. Taylor expanded in EAccept around 0 42.8%

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

   if 2.5999999999999998e-226 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in EAccept around inf 69.2%

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

   6. Taylor expanded in EDonor around inf 50.9%

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

   7. Taylor expanded in EDonor around 0 38.9%

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

4. Final simplification 39.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -4 \cdot 10^{+141}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;Ev \leq 2.6 \cdot 10^{-226}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 31: 35.7% accurate, 2.1× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 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 = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 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 (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing

5. Taylor expanded in Ev around inf 72.4%

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

6. Taylor expanded in KbT around inf 35.0%

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

7. Final simplification 35.0%

   \[\leadsto \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2} \]
8. Add Preprocessing

Alternative 32: 28.1% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing

5. Taylor expanded in mu around inf 70.5%

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

6. Taylor expanded in mu around 0 51.4%

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

7. Taylor expanded in KbT around inf 24.6%

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

8. Taylor expanded in mu around 0 25.3%

   \[\leadsto \color{blue}{0.5 \cdot NaChar + 0.5 \cdot NdChar} \]
9. Step-by-step derivation

   1. distribute-lft-out 25.3%

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

10. Simplified 25.3%

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

11. Final simplification 25.3%

    \[\leadsto 0.5 \cdot \left(NdChar + NaChar\right) \]
12. Add Preprocessing

Alternative 33: 18.3% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing

5. Taylor expanded in mu around inf 70.5%

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

6. Taylor expanded in mu around 0 51.4%

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

7. Taylor expanded in KbT around inf 24.6%

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

8. Taylor expanded in NdChar around 0 17.2%

   \[\leadsto \color{blue}{0.5 \cdot NaChar} \]

9. Final simplification 17.2%

   \[\leadsto NaChar \cdot 0.5 \]
10. Add Preprocessing

Reproduce

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