Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 43.3s

Alternatives: 27

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

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 / Math.exp(Math.log1p(Math.exp((((Vef + EDonor) - (Ec - mu)) / KbT))))) + (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
}

Python

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

Julia

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

   1. add-exp-log 100.0%

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

   2. log1p-udef 100.0%

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

   3. div-inv 100.0%

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

   4. associate-*r/ 100.0%

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

   5. *-commutative 100.0%

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

   6. *-un-lft-identity 100.0%

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

   7. +-commutative 100.0%

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

   8. associate-+l- 100.0%

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

5. Applied egg-rr 100.0%

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

7. Simplified 100.0%

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

8. Final simplification 100.0%

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

Alternative 2: 70.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + t_0\\ t_2 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + t_0\\ \mathbf{if}\;mu \leq -6.8 \cdot 10^{+54}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -1.2 \cdot 10^{-292}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq 4.2 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 4.7 \cdot 10^{-91}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq 2.8 \cdot 10^{+187}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t_0\\ \mathbf{elif}\;mu \leq 2.6 \cdot 10^{+212}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ Vef mu)) KbT)))))
        (t_1 (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) t_0))
        (t_2 (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) t_0)))
   (if (<= mu -6.8e+54)
     t_2
     (if (<= mu -1.2e-292)
       t_1
       (if (<= mu 4.2e-188)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/
           NdChar
           (-
            (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT))))
            (/ Ec KbT))))
         (if (<= mu 4.7e-91)
           t_1
           (if (<= mu 2.8e+187)
             (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)
             (if (<= mu 2.6e+212)
               (+
                (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
                (/ NaChar (+ 1.0 (/ Ev KbT))))
               t_2))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT)));
	double t_1 = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	double t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_0;
	double tmp;
	if (mu <= -6.8e+54) {
		tmp = t_2;
	} else if (mu <= -1.2e-292) {
		tmp = t_1;
	} else if (mu <= 4.2e-188) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	} else if (mu <= 4.7e-91) {
		tmp = t_1;
	} else if (mu <= 2.8e+187) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	} else if (mu <= 2.6e+212) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (Ev / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (vef + mu)) / kbt)))
    t_1 = (nachar / (1.0d0 + exp((vef / kbt)))) + t_0
    t_2 = (nachar / (1.0d0 + exp((-mu / kbt)))) + t_0
    if (mu <= (-6.8d+54)) then
        tmp = t_2
    else if (mu <= (-1.2d-292)) then
        tmp = t_1
    else if (mu <= 4.2d-188) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / kbt)))
    else if (mu <= 4.7d-91) then
        tmp = t_1
    else if (mu <= 2.8d+187) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_0
    else if (mu <= 2.6d+212) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + (ev / kbt)))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (Vef + mu)) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
	double t_2 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + t_0;
	double tmp;
	if (mu <= -6.8e+54) {
		tmp = t_2;
	} else if (mu <= -1.2e-292) {
		tmp = t_1;
	} else if (mu <= 4.2e-188) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	} else if (mu <= 4.7e-91) {
		tmp = t_1;
	} else if (mu <= 2.8e+187) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_0;
	} else if (mu <= 2.6e+212) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (Ev / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (Vef + mu)) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + t_0
	t_2 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + t_0
	tmp = 0
	if mu <= -6.8e+54:
		tmp = t_2
	elif mu <= -1.2e-292:
		tmp = t_1
	elif mu <= 4.2e-188:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	elif mu <= 4.7e-91:
		tmp = t_1
	elif mu <= 2.8e+187:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_0
	elif mu <= 2.6e+212:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (Ev / KbT)))
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(Vef + mu)) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0)
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + t_0)
	tmp = 0.0
	if (mu <= -6.8e+54)
		tmp = t_2;
	elseif (mu <= -1.2e-292)
		tmp = t_1;
	elseif (mu <= 4.2e-188)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))));
	elseif (mu <= 4.7e-91)
		tmp = t_1;
	elseif (mu <= 2.8e+187)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_0);
	elseif (mu <= 2.6e+212)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT)));
	t_1 = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_0;
	tmp = 0.0;
	if (mu <= -6.8e+54)
		tmp = t_2;
	elseif (mu <= -1.2e-292)
		tmp = t_1;
	elseif (mu <= 4.2e-188)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	elseif (mu <= 4.7e-91)
		tmp = t_1;
	elseif (mu <= 2.8e+187)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	elseif (mu <= 2.6e+212)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (Ev / KbT)));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, If[LessEqual[mu, -6.8e+54], t$95$2, If[LessEqual[mu, -1.2e-292], t$95$1, If[LessEqual[mu, 4.2e-188], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 4.7e-91], t$95$1, If[LessEqual[mu, 2.8e+187], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[mu, 2.6e+212], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if mu < -6.8000000000000001e54 or 2.5999999999999998e212 < mu

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in mu around inf 90.1%

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

      1. mul-1-neg 90.1%

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

   6. Simplified 90.1%

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

   7. Taylor expanded in Ec around 0 86.9%

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

      1. +-commutative 56.8%

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

      2. +-commutative 56.8%

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

      3. +-commutative 56.8%

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

   9. Simplified 86.9%

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

   if -6.8000000000000001e54 < mu < -1.2000000000000001e-292 or 4.1999999999999998e-188 < mu < 4.70000000000000006e-91

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 85.7%

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

   5. Taylor expanded in Ec around 0 79.2%

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

      1. +-commutative 79.2%

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

      2. +-commutative 79.2%

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

      3. +-commutative 79.2%

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

   7. Simplified 79.2%

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

   if -1.2000000000000001e-292 < mu < 4.1999999999999998e-188

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 86.2%

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

   if 4.70000000000000006e-91 < mu < 2.79999999999999989e187

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 75.6%

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

   5. Taylor expanded in Ec around 0 71.0%

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

      1. +-commutative 54.8%

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

      2. +-commutative 54.8%

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

      3. +-commutative 54.8%

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

   7. Simplified 71.0%

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

   if 2.79999999999999989e187 < mu < 2.5999999999999998e212

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 45.7%

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

   5. Taylor expanded in Ev around inf 91.1%

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

4. Final simplification 81.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -6.8 \cdot 10^{+54}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.2 \cdot 10^{-292}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;mu \leq 4.2 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 4.7 \cdot 10^{-91}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.8 \cdot 10^{+187}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.6 \cdot 10^{+212}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \end{array} \]

Alternative 3: 73.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{if}\;mu \leq -3.6 \cdot 10^{+106}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -2.6 \cdot 10^{-294}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq 6 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 2 \cdot 10^{-91}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq 1.62 \cdot 10^{+187}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.6 \cdot 10^{+212}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ Vef mu)) KbT)))))))
   (if (<= mu -3.6e+106)
     t_2
     (if (<= mu -2.6e-294)
       t_1
       (if (<= mu 6e-188)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/
           NdChar
           (-
            (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT))))
            (/ Ec KbT))))
         (if (<= mu 2e-91)
           t_1
           (if (<= mu 1.62e+187)
             (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
             (if (<= mu 2.6e+212)
               (+ t_0 (/ NaChar (+ 1.0 (/ Ev KbT))))
               t_2))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	double t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT))));
	double tmp;
	if (mu <= -3.6e+106) {
		tmp = t_2;
	} else if (mu <= -2.6e-294) {
		tmp = t_1;
	} else if (mu <= 6e-188) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	} else if (mu <= 2e-91) {
		tmp = t_1;
	} else if (mu <= 1.62e+187) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (mu <= 2.6e+212) {
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = t_0 + (nachar / (1.0d0 + exp((vef / kbt))))
    t_2 = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp(((edonor + (vef + mu)) / kbt))))
    if (mu <= (-3.6d+106)) then
        tmp = t_2
    else if (mu <= (-2.6d-294)) then
        tmp = t_1
    else if (mu <= 6d-188) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / kbt)))
    else if (mu <= 2d-91) then
        tmp = t_1
    else if (mu <= 1.62d+187) then
        tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (mu <= 2.6d+212) then
        tmp = t_0 + (nachar / (1.0d0 + (ev / kbt)))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
	double t_2 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp(((EDonor + (Vef + mu)) / KbT))));
	double tmp;
	if (mu <= -3.6e+106) {
		tmp = t_2;
	} else if (mu <= -2.6e-294) {
		tmp = t_1;
	} else if (mu <= 6e-188) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	} else if (mu <= 2e-91) {
		tmp = t_1;
	} else if (mu <= 1.62e+187) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (mu <= 2.6e+212) {
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT))))
	t_2 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp(((EDonor + (Vef + mu)) / KbT))))
	tmp = 0
	if mu <= -3.6e+106:
		tmp = t_2
	elif mu <= -2.6e-294:
		tmp = t_1
	elif mu <= 6e-188:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	elif mu <= 2e-91:
		tmp = t_1
	elif mu <= 1.62e+187:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif mu <= 2.6e+212:
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)))
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(Vef + mu)) / KbT)))))
	tmp = 0.0
	if (mu <= -3.6e+106)
		tmp = t_2;
	elseif (mu <= -2.6e-294)
		tmp = t_1;
	elseif (mu <= 6e-188)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))));
	elseif (mu <= 2e-91)
		tmp = t_1;
	elseif (mu <= 1.62e+187)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (mu <= 2.6e+212)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT))));
	tmp = 0.0;
	if (mu <= -3.6e+106)
		tmp = t_2;
	elseif (mu <= -2.6e-294)
		tmp = t_1;
	elseif (mu <= 6e-188)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	elseif (mu <= 2e-91)
		tmp = t_1;
	elseif (mu <= 1.62e+187)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (mu <= 2.6e+212)
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -3.6e+106], t$95$2, If[LessEqual[mu, -2.6e-294], t$95$1, If[LessEqual[mu, 6e-188], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2e-91], t$95$1, If[LessEqual[mu, 1.62e+187], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.6e+212], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if mu < -3.6000000000000001e106 or 2.5999999999999998e212 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 93.1%

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

      1. mul-1-neg 93.1%

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

   6. Simplified 93.1%

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

   7. Taylor expanded in Ec around 0 90.8%

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

      1. +-commutative 57.8%

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

      2. +-commutative 57.8%

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

      3. +-commutative 57.8%

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

   9. Simplified 90.8%

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

   if -3.6000000000000001e106 < mu < -2.5999999999999999e-294 or 6.00000000000000033e-188 < mu < 2.00000000000000004e-91

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 84.6%

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

   if -2.5999999999999999e-294 < mu < 6.00000000000000033e-188

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 86.2%

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

   if 2.00000000000000004e-91 < mu < 1.61999999999999993e187

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 75.6%

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

   if 1.61999999999999993e187 < mu < 2.5999999999999998e212

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 45.7%

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

   5. Taylor expanded in Ev around inf 91.1%

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

4. Final simplification 85.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -3.6 \cdot 10^{+106}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;mu \leq -2.6 \cdot 10^{-294}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 6 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 2 \cdot 10^{-91}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.62 \cdot 10^{+187}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.6 \cdot 10^{+212}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \end{array} \]

Alternative 4: 74.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_2 := t_1 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;mu \leq -6.2 \cdot 10^{+103}:\\ \;\;\;\;t_1 + t_0\\ \mathbf{elif}\;mu \leq -2.3 \cdot 10^{-294}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 6 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 3.8 \cdot 10^{-92}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 2.9 \cdot 10^{+187}:\\ \;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.6 \cdot 10^{+212}:\\ \;\;\;\;t_1 + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{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 (/ (- mu) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_2 (+ t_1 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))))
   (if (<= mu -6.2e+103)
     (+ t_1 t_0)
     (if (<= mu -2.3e-294)
       t_2
       (if (<= mu 6e-188)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/
           NdChar
           (-
            (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT))))
            (/ Ec KbT))))
         (if (<= mu 3.8e-92)
           t_2
           (if (<= mu 2.9e+187)
             (+ t_1 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
             (if (<= mu 2.6e+212)
               (+ t_1 (/ NaChar (+ 1.0 (/ Ev KbT))))
               (+
                t_0
                (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ Vef mu)) KbT)))))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((-mu / KbT)));
	double t_1 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_2 = t_1 + (NaChar / (1.0 + exp((Vef / KbT))));
	double tmp;
	if (mu <= -6.2e+103) {
		tmp = t_1 + t_0;
	} else if (mu <= -2.3e-294) {
		tmp = t_2;
	} else if (mu <= 6e-188) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	} else if (mu <= 3.8e-92) {
		tmp = t_2;
	} else if (mu <= 2.9e+187) {
		tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (mu <= 2.6e+212) {
		tmp = t_1 + (NaChar / (1.0 + (Ev / KbT)));
	} else {
		tmp = t_0 + (NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((-mu / kbt)))
    t_1 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_2 = t_1 + (nachar / (1.0d0 + exp((vef / kbt))))
    if (mu <= (-6.2d+103)) then
        tmp = t_1 + t_0
    else if (mu <= (-2.3d-294)) then
        tmp = t_2
    else if (mu <= 6d-188) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / kbt)))
    else if (mu <= 3.8d-92) then
        tmp = t_2
    else if (mu <= 2.9d+187) then
        tmp = t_1 + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (mu <= 2.6d+212) then
        tmp = t_1 + (nachar / (1.0d0 + (ev / kbt)))
    else
        tmp = t_0 + (ndchar / (1.0d0 + exp(((edonor + (vef + mu)) / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((-mu / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_2 = t_1 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
	double tmp;
	if (mu <= -6.2e+103) {
		tmp = t_1 + t_0;
	} else if (mu <= -2.3e-294) {
		tmp = t_2;
	} else if (mu <= 6e-188) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	} else if (mu <= 3.8e-92) {
		tmp = t_2;
	} else if (mu <= 2.9e+187) {
		tmp = t_1 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (mu <= 2.6e+212) {
		tmp = t_1 + (NaChar / (1.0 + (Ev / KbT)));
	} else {
		tmp = t_0 + (NdChar / (1.0 + Math.exp(((EDonor + (Vef + mu)) / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((-mu / KbT)))
	t_1 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_2 = t_1 + (NaChar / (1.0 + math.exp((Vef / KbT))))
	tmp = 0
	if mu <= -6.2e+103:
		tmp = t_1 + t_0
	elif mu <= -2.3e-294:
		tmp = t_2
	elif mu <= 6e-188:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	elif mu <= 3.8e-92:
		tmp = t_2
	elif mu <= 2.9e+187:
		tmp = t_1 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif mu <= 2.6e+212:
		tmp = t_1 + (NaChar / (1.0 + (Ev / KbT)))
	else:
		tmp = t_0 + (NdChar / (1.0 + math.exp(((EDonor + (Vef + mu)) / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_2 = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	tmp = 0.0
	if (mu <= -6.2e+103)
		tmp = Float64(t_1 + t_0);
	elseif (mu <= -2.3e-294)
		tmp = t_2;
	elseif (mu <= 6e-188)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))));
	elseif (mu <= 3.8e-92)
		tmp = t_2;
	elseif (mu <= 2.9e+187)
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (mu <= 2.6e+212)
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	else
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(Vef + mu)) / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((-mu / KbT)));
	t_1 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_2 = t_1 + (NaChar / (1.0 + exp((Vef / KbT))));
	tmp = 0.0;
	if (mu <= -6.2e+103)
		tmp = t_1 + t_0;
	elseif (mu <= -2.3e-294)
		tmp = t_2;
	elseif (mu <= 6e-188)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	elseif (mu <= 3.8e-92)
		tmp = t_2;
	elseif (mu <= 2.9e+187)
		tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (mu <= 2.6e+212)
		tmp = t_1 + (NaChar / (1.0 + (Ev / KbT)));
	else
		tmp = t_0 + (NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -6.2e+103], N[(t$95$1 + t$95$0), $MachinePrecision], If[LessEqual[mu, -2.3e-294], t$95$2, If[LessEqual[mu, 6e-188], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3.8e-92], t$95$2, If[LessEqual[mu, 2.9e+187], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.6e+212], N[(t$95$1 + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if mu < -6.2000000000000003e103

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 92.3%

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

      1. mul-1-neg 92.3%

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

   6. Simplified 92.3%

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

   if -6.2000000000000003e103 < mu < -2.30000000000000016e-294 or 6.00000000000000033e-188 < mu < 3.8000000000000001e-92

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 84.6%

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

   if -2.30000000000000016e-294 < mu < 6.00000000000000033e-188

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 86.2%

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

   if 3.8000000000000001e-92 < mu < 2.9000000000000001e187

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 75.6%

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

   if 2.9000000000000001e187 < mu < 2.5999999999999998e212

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 45.7%

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

   5. Taylor expanded in Ev around inf 91.1%

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

   if 2.5999999999999998e212 < mu

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in mu around inf 94.2%

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

      1. mul-1-neg 94.2%

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

   6. Simplified 94.2%

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

   7. Taylor expanded in Ec around 0 94.2%

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

      1. +-commutative 57.7%

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

      2. +-commutative 57.7%

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

      3. +-commutative 57.7%

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

   9. Simplified 94.2%

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

4. Final simplification 86.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -6.2 \cdot 10^{+103}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -2.3 \cdot 10^{-294}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 6 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 3.8 \cdot 10^{-92}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.9 \cdot 10^{+187}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.6 \cdot 10^{+212}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \end{array} \]

Alternative 5: 73.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + t_0\\ t_2 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;EAccept \leq -2.9 \cdot 10^{-30}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;EAccept \leq -6.8 \cdot 10^{-291}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;EAccept \leq 1.6 \cdot 10^{-178}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + t_0\\ \mathbf{elif}\;EAccept \leq 1.35 \cdot 10^{+27}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ Vef mu)) KbT)))))
        (t_1 (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) t_0))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))
   (if (<= EAccept -2.9e-30)
     t_2
     (if (<= EAccept -6.8e-291)
       t_1
       (if (<= EAccept 1.6e-178)
         (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) t_0)
         (if (<= EAccept 1.35e+27) t_1 t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT)));
	double t_1 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_0;
	double t_2 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	double tmp;
	if (EAccept <= -2.9e-30) {
		tmp = t_2;
	} else if (EAccept <= -6.8e-291) {
		tmp = t_1;
	} else if (EAccept <= 1.6e-178) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	} else if (EAccept <= 1.35e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (vef + mu)) / kbt)))
    t_1 = (nachar / (1.0d0 + exp((-mu / kbt)))) + t_0
    t_2 = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    if (eaccept <= (-2.9d-30)) then
        tmp = t_2
    else if (eaccept <= (-6.8d-291)) then
        tmp = t_1
    else if (eaccept <= 1.6d-178) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + t_0
    else if (eaccept <= 1.35d+27) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (Vef + mu)) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + t_0;
	double t_2 = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	double tmp;
	if (EAccept <= -2.9e-30) {
		tmp = t_2;
	} else if (EAccept <= -6.8e-291) {
		tmp = t_1;
	} else if (EAccept <= 1.6e-178) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
	} else if (EAccept <= 1.35e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (Vef + mu)) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + t_0
	t_2 = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	tmp = 0
	if EAccept <= -2.9e-30:
		tmp = t_2
	elif EAccept <= -6.8e-291:
		tmp = t_1
	elif EAccept <= 1.6e-178:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + t_0
	elif EAccept <= 1.35e+27:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(Vef + mu)) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + t_0)
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))))
	tmp = 0.0
	if (EAccept <= -2.9e-30)
		tmp = t_2;
	elseif (EAccept <= -6.8e-291)
		tmp = t_1;
	elseif (EAccept <= 1.6e-178)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0);
	elseif (EAccept <= 1.35e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT)));
	t_1 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_0;
	t_2 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	tmp = 0.0;
	if (EAccept <= -2.9e-30)
		tmp = t_2;
	elseif (EAccept <= -6.8e-291)
		tmp = t_1;
	elseif (EAccept <= 1.6e-178)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	elseif (EAccept <= 1.35e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $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]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -2.9e-30], t$95$2, If[LessEqual[EAccept, -6.8e-291], t$95$1, If[LessEqual[EAccept, 1.6e-178], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[EAccept, 1.35e+27], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if EAccept < -2.89999999999999989e-30 or 1.3499999999999999e27 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 76.7%

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

   if -2.89999999999999989e-30 < EAccept < -6.80000000000000053e-291 or 1.6e-178 < EAccept < 1.3499999999999999e27

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 78.9%

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

      1. mul-1-neg 78.9%

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

   6. Simplified 78.9%

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

   7. Taylor expanded in Ec around 0 76.9%

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

      1. +-commutative 72.5%

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

      2. +-commutative 72.5%

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

      3. +-commutative 72.5%

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

   9. Simplified 76.9%

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

   if -6.80000000000000053e-291 < EAccept < 1.6e-178

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 75.1%

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

   5. Taylor expanded in Ec around 0 70.5%

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

      1. +-commutative 70.5%

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

      2. +-commutative 70.5%

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

      3. +-commutative 70.5%

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

   7. Simplified 70.5%

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

4. Final simplification 76.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq -2.9 \cdot 10^{-30}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;EAccept \leq -6.8 \cdot 10^{-291}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.6 \cdot 10^{-178}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.35 \cdot 10^{+27}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 6: 100.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
  (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ 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) {
	return (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT))));
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Final simplification 100.0%

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

Alternative 7: 67.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ t_1 := NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_2 := \frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\ \mathbf{if}\;Vef \leq -1.1 \cdot 10^{+64}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;Vef \leq -3.7 \cdot 10^{-16}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq 2.85 \cdot 10^{-192}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;Vef \leq 8.8 \cdot 10^{+153}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 1.0 (exp (/ Vef KbT))))
        (t_1
         (+
          NaChar
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))))
        (t_2 (+ (/ NaChar t_0) (/ NdChar t_0))))
   (if (<= Vef -1.1e+64)
     t_2
     (if (<= Vef -3.7e-16)
       t_1
       (if (<= Vef 2.85e-192)
         (+
          (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ Vef mu)) KbT)))))
         (if (<= Vef 8.8e+153) t_1 t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + exp((Vef / KbT));
	double t_1 = NaChar + (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT))));
	double t_2 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -1.1e+64) {
		tmp = t_2;
	} else if (Vef <= -3.7e-16) {
		tmp = t_1;
	} else if (Vef <= 2.85e-192) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT))));
	} else if (Vef <= 8.8e+153) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = 1.0d0 + exp((vef / kbt))
    t_1 = nachar + (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt))))
    t_2 = (nachar / t_0) + (ndchar / t_0)
    if (vef <= (-1.1d+64)) then
        tmp = t_2
    else if (vef <= (-3.7d-16)) then
        tmp = t_1
    else if (vef <= 2.85d-192) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp(((edonor + (vef + mu)) / kbt))))
    else if (vef <= 8.8d+153) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + Math.exp((Vef / KbT));
	double t_1 = NaChar + (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT))));
	double t_2 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -1.1e+64) {
		tmp = t_2;
	} else if (Vef <= -3.7e-16) {
		tmp = t_1;
	} else if (Vef <= 2.85e-192) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp(((EDonor + (Vef + mu)) / KbT))));
	} else if (Vef <= 8.8e+153) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	t_1 = NaChar + (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT))))
	t_2 = (NaChar / t_0) + (NdChar / t_0)
	tmp = 0
	if Vef <= -1.1e+64:
		tmp = t_2
	elif Vef <= -3.7e-16:
		tmp = t_1
	elif Vef <= 2.85e-192:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp(((EDonor + (Vef + mu)) / KbT))))
	elif Vef <= 8.8e+153:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + exp(Float64(Vef / KbT)))
	t_1 = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))))
	t_2 = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0))
	tmp = 0.0
	if (Vef <= -1.1e+64)
		tmp = t_2;
	elseif (Vef <= -3.7e-16)
		tmp = t_1;
	elseif (Vef <= 2.85e-192)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(Vef + mu)) / KbT)))));
	elseif (Vef <= 8.8e+153)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	t_1 = NaChar + (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT))));
	t_2 = (NaChar / t_0) + (NdChar / t_0);
	tmp = 0.0;
	if (Vef <= -1.1e+64)
		tmp = t_2;
	elseif (Vef <= -3.7e-16)
		tmp = t_1;
	elseif (Vef <= 2.85e-192)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT))));
	elseif (Vef <= 8.8e+153)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -1.1e+64], t$95$2, If[LessEqual[Vef, -3.7e-16], t$95$1, If[LessEqual[Vef, 2.85e-192], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 8.8e+153], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -1.10000000000000001e64 or 8.7999999999999998e153 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 85.5%

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

   5. Taylor expanded in Ec around 0 83.3%

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

      1. +-commutative 83.3%

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

      2. +-commutative 83.3%

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

      3. +-commutative 83.3%

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

   7. Simplified 83.3%

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

   8. Taylor expanded in Vef around inf 74.9%

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

   if -1.10000000000000001e64 < Vef < -3.7e-16 or 2.8500000000000001e-192 < Vef < 8.7999999999999998e153

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.0%

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

   5. Taylor expanded in Ev around inf 57.8%

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

   6. Taylor expanded in Ev around 0 70.8%

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

   if -3.7e-16 < Vef < 2.8500000000000001e-192

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 73.7%

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

   5. Taylor expanded in Ec around 0 67.8%

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

      1. +-commutative 54.6%

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

      2. +-commutative 54.6%

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

      3. +-commutative 54.6%

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

   7. Simplified 67.8%

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

4. Final simplification 71.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -1.1 \cdot 10^{+64}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq -3.7 \cdot 10^{-16}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{elif}\;Vef \leq 2.85 \cdot 10^{-192}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;Vef \leq 8.8 \cdot 10^{+153}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]

Alternative 8: 70.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + t_0\\ \mathbf{if}\;Vef \leq -2.2 \cdot 10^{+64}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq 8.2 \cdot 10^{-193}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t_0\\ \mathbf{elif}\;Vef \leq 4.2 \cdot 10^{-57}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ Vef mu)) KbT)))))
        (t_1 (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) t_0)))
   (if (<= Vef -2.2e+64)
     t_1
     (if (<= Vef 8.2e-193)
       (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)
       (if (<= Vef 4.2e-57)
         (+
          NaChar
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT)));
	double t_1 = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	double tmp;
	if (Vef <= -2.2e+64) {
		tmp = t_1;
	} else if (Vef <= 8.2e-193) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	} else if (Vef <= 4.2e-57) {
		tmp = NaChar + (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (vef + mu)) / kbt)))
    t_1 = (nachar / (1.0d0 + exp((vef / kbt)))) + t_0
    if (vef <= (-2.2d+64)) then
        tmp = t_1
    else if (vef <= 8.2d-193) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_0
    else if (vef <= 4.2d-57) then
        tmp = nachar + (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (Vef + mu)) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
	double tmp;
	if (Vef <= -2.2e+64) {
		tmp = t_1;
	} else if (Vef <= 8.2e-193) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_0;
	} else if (Vef <= 4.2e-57) {
		tmp = NaChar + (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (Vef + mu)) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + t_0
	tmp = 0
	if Vef <= -2.2e+64:
		tmp = t_1
	elif Vef <= 8.2e-193:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_0
	elif Vef <= 4.2e-57:
		tmp = NaChar + (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(Vef + mu)) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0)
	tmp = 0.0
	if (Vef <= -2.2e+64)
		tmp = t_1;
	elseif (Vef <= 8.2e-193)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_0);
	elseif (Vef <= 4.2e-57)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (Vef + mu)) / KbT)));
	t_1 = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	tmp = 0.0;
	if (Vef <= -2.2e+64)
		tmp = t_1;
	elseif (Vef <= 8.2e-193)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	elseif (Vef <= 4.2e-57)
		tmp = NaChar + (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Vef < -2.20000000000000002e64 or 4.1999999999999999e-57 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 78.9%

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

   5. Taylor expanded in Ec around 0 77.4%

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

      1. +-commutative 77.4%

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

      2. +-commutative 77.4%

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

      3. +-commutative 77.4%

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

   7. Simplified 77.4%

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

   if -2.20000000000000002e64 < Vef < 8.20000000000000005e-193

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 72.3%

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

   5. Taylor expanded in Ec around 0 64.3%

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

      1. +-commutative 53.6%

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

      2. +-commutative 53.6%

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

      3. +-commutative 53.6%

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

   7. Simplified 64.3%

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

   if 8.20000000000000005e-193 < Vef < 4.1999999999999999e-57

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 49.4%

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

   5. Taylor expanded in Ev around inf 56.3%

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

   6. Taylor expanded in Ev around 0 83.1%

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

4. Final simplification 72.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -2.2 \cdot 10^{+64}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;Vef \leq 8.2 \cdot 10^{-193}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \mathbf{elif}\;Vef \leq 4.2 \cdot 10^{-57}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor + \left(Vef + mu\right)}{KbT}}}\\ \end{array} \]

Alternative 9: 71.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

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

   4. Taylor expanded in Ev around inf 66.9%

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

   if 5.2000000000000001e-171 < EAccept < 2.5e29

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 77.1%

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

      1. mul-1-neg 77.1%

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

   6. Simplified 77.1%

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

   7. Taylor expanded in Ec around 0 77.1%

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

      1. +-commutative 71.1%

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

      2. +-commutative 71.1%

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

      3. +-commutative 71.1%

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

   9. Simplified 77.1%

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

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

   4. Taylor expanded in EAccept around inf 82.2%

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

4. Final simplification 71.7%

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

Alternative 10: 65.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_2 := NaChar + t_1\\ t_3 := \frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\ \mathbf{if}\;Vef \leq -8.5 \cdot 10^{+62}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;Vef \leq 4.1 \cdot 10^{-256}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;Vef \leq 1.38 \cdot 10^{-192}:\\ \;\;\;\;t_1 + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \frac{KbT \cdot Ev + Vef \cdot KbT}{KbT \cdot KbT}\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;Vef \leq 1.3 \cdot 10^{+152}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 1.0 (exp (/ Vef KbT))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_2 (+ NaChar t_1))
        (t_3 (+ (/ NaChar t_0) (/ NdChar t_0))))
   (if (<= Vef -8.5e+62)
     t_3
     (if (<= Vef 4.1e-256)
       t_2
       (if (<= Vef 1.38e-192)
         (+
          t_1
          (/
           NaChar
           (+
            1.0
            (-
             (+
              1.0
              (+ (/ EAccept KbT) (/ (+ (* KbT Ev) (* Vef KbT)) (* KbT KbT))))
             (/ mu KbT)))))
         (if (<= Vef 1.3e+152) t_2 t_3))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + exp((Vef / KbT));
	double t_1 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_2 = NaChar + t_1;
	double t_3 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -8.5e+62) {
		tmp = t_3;
	} else if (Vef <= 4.1e-256) {
		tmp = t_2;
	} else if (Vef <= 1.38e-192) {
		tmp = t_1 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (((KbT * Ev) + (Vef * KbT)) / (KbT * KbT)))) - (mu / KbT))));
	} else if (Vef <= 1.3e+152) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = 1.0d0 + exp((vef / kbt))
    t_1 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_2 = nachar + t_1
    t_3 = (nachar / t_0) + (ndchar / t_0)
    if (vef <= (-8.5d+62)) then
        tmp = t_3
    else if (vef <= 4.1d-256) then
        tmp = t_2
    else if (vef <= 1.38d-192) then
        tmp = t_1 + (nachar / (1.0d0 + ((1.0d0 + ((eaccept / kbt) + (((kbt * ev) + (vef * kbt)) / (kbt * kbt)))) - (mu / kbt))))
    else if (vef <= 1.3d+152) then
        tmp = t_2
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + Math.exp((Vef / KbT));
	double t_1 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_2 = NaChar + t_1;
	double t_3 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -8.5e+62) {
		tmp = t_3;
	} else if (Vef <= 4.1e-256) {
		tmp = t_2;
	} else if (Vef <= 1.38e-192) {
		tmp = t_1 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (((KbT * Ev) + (Vef * KbT)) / (KbT * KbT)))) - (mu / KbT))));
	} else if (Vef <= 1.3e+152) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	t_1 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_2 = NaChar + t_1
	t_3 = (NaChar / t_0) + (NdChar / t_0)
	tmp = 0
	if Vef <= -8.5e+62:
		tmp = t_3
	elif Vef <= 4.1e-256:
		tmp = t_2
	elif Vef <= 1.38e-192:
		tmp = t_1 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (((KbT * Ev) + (Vef * KbT)) / (KbT * KbT)))) - (mu / KbT))))
	elif Vef <= 1.3e+152:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + exp(Float64(Vef / KbT)))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_2 = Float64(NaChar + t_1)
	t_3 = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0))
	tmp = 0.0
	if (Vef <= -8.5e+62)
		tmp = t_3;
	elseif (Vef <= 4.1e-256)
		tmp = t_2;
	elseif (Vef <= 1.38e-192)
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Float64(KbT * Ev) + Float64(Vef * KbT)) / Float64(KbT * KbT)))) - Float64(mu / KbT)))));
	elseif (Vef <= 1.3e+152)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	t_1 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_2 = NaChar + t_1;
	t_3 = (NaChar / t_0) + (NdChar / t_0);
	tmp = 0.0;
	if (Vef <= -8.5e+62)
		tmp = t_3;
	elseif (Vef <= 4.1e-256)
		tmp = t_2;
	elseif (Vef <= 1.38e-192)
		tmp = t_1 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (((KbT * Ev) + (Vef * KbT)) / (KbT * KbT)))) - (mu / KbT))));
	elseif (Vef <= 1.3e+152)
		tmp = t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -8.5e+62], t$95$3, If[LessEqual[Vef, 4.1e-256], t$95$2, If[LessEqual[Vef, 1.38e-192], N[(t$95$1 + N[(NaChar / N[(1.0 + N[(N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(N[(KbT * Ev), $MachinePrecision] + N[(Vef * KbT), $MachinePrecision]), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.3e+152], t$95$2, t$95$3]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -8.4999999999999997e62 or 1.3e152 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 85.5%

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

   5. Taylor expanded in Ec around 0 83.3%

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

      1. +-commutative 83.3%

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

      2. +-commutative 83.3%

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

      3. +-commutative 83.3%

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

   7. Simplified 83.3%

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

   8. Taylor expanded in Vef around inf 74.9%

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

   if -8.4999999999999997e62 < Vef < 4.1e-256 or 1.38e-192 < Vef < 1.3e152

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 52.5%

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

   5. Taylor expanded in Ev around inf 56.0%

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

   6. Taylor expanded in Ev around 0 70.5%

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

   if 4.1e-256 < Vef < 1.38e-192

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 79.3%

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

      1. frac-add 86.2%

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

   6. Applied egg-rr 86.2%

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

4. Final simplification 72.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -8.5 \cdot 10^{+62}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq 4.1 \cdot 10^{-256}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.38 \cdot 10^{-192}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \frac{KbT \cdot Ev + Vef \cdot KbT}{KbT \cdot KbT}\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;Vef \leq 1.3 \cdot 10^{+152}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]

Alternative 11: 66.3% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := NaChar + t_0\\ t_2 := t_0 + \frac{NaChar}{1 + \left(1 + \frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}\right)}\\ t_3 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{if}\;NdChar \leq -3 \cdot 10^{+199}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq -3.1 \cdot 10^{+115}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -29000:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq -5.8 \cdot 10^{-30}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;NdChar \leq -3.1 \cdot 10^{-56}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;NdChar \leq 5.5 \cdot 10^{-33}:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ NaChar t_0))
        (t_2
         (+
          t_0
          (/ NaChar (+ 1.0 (+ 1.0 (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
        (t_3
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/
           NdChar
           (-
            (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT))))
            (/ Ec KbT))))))
   (if (<= NdChar -3e+199)
     t_2
     (if (<= NdChar -3.1e+115)
       t_1
       (if (<= NdChar -29000.0)
         t_2
         (if (<= NdChar -5.8e-30)
           t_3
           (if (<= NdChar -3.1e-56)
             (+ t_0 (/ NaChar (+ 1.0 (/ Ev KbT))))
             (if (<= NdChar 5.5e-33) t_3 t_1))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = NaChar + t_0;
	double t_2 = t_0 + (NaChar / (1.0 + (1.0 + (((Vef + (Ev + EAccept)) - mu) / KbT))));
	double t_3 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	double tmp;
	if (NdChar <= -3e+199) {
		tmp = t_2;
	} else if (NdChar <= -3.1e+115) {
		tmp = t_1;
	} else if (NdChar <= -29000.0) {
		tmp = t_2;
	} else if (NdChar <= -5.8e-30) {
		tmp = t_3;
	} else if (NdChar <= -3.1e-56) {
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	} else if (NdChar <= 5.5e-33) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = nachar + t_0
    t_2 = t_0 + (nachar / (1.0d0 + (1.0d0 + (((vef + (ev + eaccept)) - mu) / kbt))))
    t_3 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / kbt)))
    if (ndchar <= (-3d+199)) then
        tmp = t_2
    else if (ndchar <= (-3.1d+115)) then
        tmp = t_1
    else if (ndchar <= (-29000.0d0)) then
        tmp = t_2
    else if (ndchar <= (-5.8d-30)) then
        tmp = t_3
    else if (ndchar <= (-3.1d-56)) then
        tmp = t_0 + (nachar / (1.0d0 + (ev / kbt)))
    else if (ndchar <= 5.5d-33) then
        tmp = t_3
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = NaChar + t_0;
	double t_2 = t_0 + (NaChar / (1.0 + (1.0 + (((Vef + (Ev + EAccept)) - mu) / KbT))));
	double t_3 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	double tmp;
	if (NdChar <= -3e+199) {
		tmp = t_2;
	} else if (NdChar <= -3.1e+115) {
		tmp = t_1;
	} else if (NdChar <= -29000.0) {
		tmp = t_2;
	} else if (NdChar <= -5.8e-30) {
		tmp = t_3;
	} else if (NdChar <= -3.1e-56) {
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	} else if (NdChar <= 5.5e-33) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = NaChar + t_0
	t_2 = t_0 + (NaChar / (1.0 + (1.0 + (((Vef + (Ev + EAccept)) - mu) / KbT))))
	t_3 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	tmp = 0
	if NdChar <= -3e+199:
		tmp = t_2
	elif NdChar <= -3.1e+115:
		tmp = t_1
	elif NdChar <= -29000.0:
		tmp = t_2
	elif NdChar <= -5.8e-30:
		tmp = t_3
	elif NdChar <= -3.1e-56:
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)))
	elif NdChar <= 5.5e-33:
		tmp = t_3
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(NaChar + t_0)
	t_2 = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))))
	t_3 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))))
	tmp = 0.0
	if (NdChar <= -3e+199)
		tmp = t_2;
	elseif (NdChar <= -3.1e+115)
		tmp = t_1;
	elseif (NdChar <= -29000.0)
		tmp = t_2;
	elseif (NdChar <= -5.8e-30)
		tmp = t_3;
	elseif (NdChar <= -3.1e-56)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	elseif (NdChar <= 5.5e-33)
		tmp = t_3;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = NaChar + t_0;
	t_2 = t_0 + (NaChar / (1.0 + (1.0 + (((Vef + (Ev + EAccept)) - mu) / KbT))));
	t_3 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	tmp = 0.0;
	if (NdChar <= -3e+199)
		tmp = t_2;
	elseif (NdChar <= -3.1e+115)
		tmp = t_1;
	elseif (NdChar <= -29000.0)
		tmp = t_2;
	elseif (NdChar <= -5.8e-30)
		tmp = t_3;
	elseif (NdChar <= -3.1e-56)
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	elseif (NdChar <= 5.5e-33)
		tmp = t_3;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar + t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -3e+199], t$95$2, If[LessEqual[NdChar, -3.1e+115], t$95$1, If[LessEqual[NdChar, -29000.0], t$95$2, If[LessEqual[NdChar, -5.8e-30], t$95$3, If[LessEqual[NdChar, -3.1e-56], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 5.5e-33], t$95$3, t$95$1]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -3.0000000000000001e199 or -3.10000000000000005e115 < NdChar < -29000

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 72.8%

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

   5. Taylor expanded in KbT around -inf 80.1%

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

      1. mul-1-neg 80.1%

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

      2. unsub-neg 80.1%

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

      3. sub-neg 80.1%

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

      4. associate-+r+ 80.1%

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

      5. mul-1-neg 80.1%

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

      6. unsub-neg 80.1%

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

      7. mul-1-neg 80.1%

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

      8. unsub-neg 80.1%

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

      9. mul-1-neg 80.1%

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

      10. neg-mul-1 80.1%

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

      11. remove-double-neg 80.1%

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

   7. Simplified 80.1%

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

   if -3.0000000000000001e199 < NdChar < -3.10000000000000005e115 or 5.5e-33 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 55.5%

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

   5. Taylor expanded in Ev around inf 63.7%

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

   6. Taylor expanded in Ev around 0 73.4%

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

   if -29000 < NdChar < -5.79999999999999978e-30 or -3.09999999999999987e-56 < NdChar < 5.5e-33

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 72.4%

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

   if -5.79999999999999978e-30 < NdChar < -3.09999999999999987e-56

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 50.1%

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

   5. Taylor expanded in Ev around inf 69.0%

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

4. Final simplification 73.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -3 \cdot 10^{+199}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq -3.1 \cdot 10^{+115}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -29000:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq -5.8 \cdot 10^{-30}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq -3.1 \cdot 10^{-56}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;NdChar \leq 5.5 \cdot 10^{-33}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \end{array} \]

Alternative 12: 63.7% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;NdChar \leq -3 \cdot 10^{+199}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq -7.5 \cdot 10^{-155} \lor \neg \left(NdChar \leq 1.36 \cdot 10^{-33}\right):\\ \;\;\;\;NaChar + t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))))
   (if (<= NdChar -3e+199)
     (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
     (if (or (<= NdChar -7.5e-155) (not (<= NdChar 1.36e-33)))
       (+ NaChar t_0)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
        (/ NdChar 2.0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -3e+199) {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (((Vef + (Ev + EAccept)) - mu) / KbT))));
	} else if ((NdChar <= -7.5e-155) || !(NdChar <= 1.36e-33)) {
		tmp = NaChar + t_0;
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    if (ndchar <= (-3d+199)) then
        tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (((vef + (ev + eaccept)) - mu) / kbt))))
    else if ((ndchar <= (-7.5d-155)) .or. (.not. (ndchar <= 1.36d-33))) then
        tmp = nachar + t_0
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -3e+199) {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (((Vef + (Ev + EAccept)) - mu) / KbT))));
	} else if ((NdChar <= -7.5e-155) || !(NdChar <= 1.36e-33)) {
		tmp = NaChar + t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	tmp = 0
	if NdChar <= -3e+199:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (((Vef + (Ev + EAccept)) - mu) / KbT))))
	elif (NdChar <= -7.5e-155) or not (NdChar <= 1.36e-33):
		tmp = NaChar + t_0
	else:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (NdChar <= -3e+199)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))));
	elseif ((NdChar <= -7.5e-155) || !(NdChar <= 1.36e-33))
		tmp = Float64(NaChar + t_0);
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (NdChar <= -3e+199)
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (((Vef + (Ev + EAccept)) - mu) / KbT))));
	elseif ((NdChar <= -7.5e-155) || ~((NdChar <= 1.36e-33)))
		tmp = NaChar + t_0;
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -3.0000000000000001e199

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 78.6%

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

   5. Taylor expanded in KbT around -inf 83.6%

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

      1. mul-1-neg 83.6%

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

      2. unsub-neg 83.6%

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

      3. sub-neg 83.6%

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

      4. associate-+r+ 83.6%

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

      5. mul-1-neg 83.6%

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

      6. unsub-neg 83.6%

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

      7. mul-1-neg 83.6%

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

      8. unsub-neg 83.6%

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

      9. mul-1-neg 83.6%

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

      10. neg-mul-1 83.6%

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

      11. remove-double-neg 83.6%

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

   7. Simplified 83.6%

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

   if -3.0000000000000001e199 < NdChar < -7.5000000000000006e-155 or 1.36e-33 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 53.7%

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

   5. Taylor expanded in Ev around inf 60.2%

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

   6. Taylor expanded in Ev around 0 70.4%

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

   if -7.5000000000000006e-155 < NdChar < 1.36e-33

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 57.9%

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

4. Final simplification 67.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -3 \cdot 10^{+199}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq -7.5 \cdot 10^{-155} \lor \neg \left(NdChar \leq 1.36 \cdot 10^{-33}\right):\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 13: 46.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -2 \cdot 10^{-66}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 7.9 \cdot 10^{-28}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 2.25 \cdot 10^{+60}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -2e-66)
   (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))
   (if (<= NaChar 7.9e-28)
     (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar (+ (/ Vef KbT) 2.0)))
     (if (<= NaChar 2.25e+60)
       (+ (/ NaChar (+ 1.0 (/ Ev KbT))) (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
       (+
        (/ NdChar 2.0)
        (/ NaChar (+ 1.0 (exp (/ (- (+ 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) {
	double tmp;
	if (NaChar <= -2e-66) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	} else if (NaChar <= 7.9e-28) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else if (NaChar <= 2.25e+60) {
		tmp = (NaChar / (1.0 + (Ev / KbT))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (nachar <= (-2d-66)) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
    else if (nachar <= 7.9d-28) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / ((vef / kbt) + 2.0d0))
    else if (nachar <= 2.25d+60) then
        tmp = (nachar / (1.0d0 + (ev / kbt))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    else
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -2e-66) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
	} else if (NaChar <= 7.9e-28) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else if (NaChar <= 2.25e+60) {
		tmp = (NaChar / (1.0 + (Ev / KbT))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -2e-66:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT))))
	elif NaChar <= 7.9e-28:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / ((Vef / KbT) + 2.0))
	elif NaChar <= 2.25e+60:
		tmp = (NaChar / (1.0 + (Ev / KbT))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	else:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -2e-66)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)))));
	elseif (NaChar <= 7.9e-28)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(Float64(Vef / KbT) + 2.0)));
	elseif (NaChar <= 2.25e+60)
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	else
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -2e-66)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	elseif (NaChar <= 7.9e-28)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	elseif (NaChar <= 2.25e+60)
		tmp = (NaChar / (1.0 + (Ev / KbT))) + (NdChar / (1.0 + exp((mu / KbT))));
	else
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -2e-66], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 7.9e-28], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.25e+60], N[(N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -2e-66

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 54.3%

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

   5. Taylor expanded in EAccept around 0 48.5%

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

      1. +-commutative 48.5%

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

   7. Simplified 48.5%

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

   if -2e-66 < NaChar < 7.8999999999999999e-28

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 76.7%

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

   5. Taylor expanded in Vef around 0 68.6%

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

      1. +-commutative 68.6%

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

   7. Simplified 68.6%

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

   8. Taylor expanded in EDonor around inf 51.5%

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

   if 7.8999999999999999e-28 < NaChar < 2.25000000000000006e60

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 56.7%

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

   5. Taylor expanded in Ev around inf 57.3%

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

   6. Taylor expanded in mu around inf 45.0%

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

   if 2.25000000000000006e60 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.3%

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

   5. Taylor expanded in Ev around 0 57.8%

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

      1. +-commutative 57.8%

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

   7. Simplified 57.8%

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

4. Final simplification 51.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2 \cdot 10^{-66}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 7.9 \cdot 10^{-28}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 2.25 \cdot 10^{+60}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \end{array} \]

Alternative 14: 63.9% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -4.4e-155) (not (<= NdChar 1.35e-33)))
   (+ NaChar (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar 2.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -4.3999999999999998e-155 or 1.35e-33 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 56.6%

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

   5. Taylor expanded in Ev around inf 62.7%

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

   6. Taylor expanded in Ev around 0 69.4%

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

   if -4.3999999999999998e-155 < NdChar < 1.35e-33

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 57.9%

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

4. Final simplification 65.8%

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

Alternative 15: 39.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \mathbf{if}\;EAccept \leq 8.2 \cdot 10^{-170}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;EAccept \leq 6 \cdot 10^{-55}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;EAccept \leq 8.2 \cdot 10^{+128}:\\ \;\;\;\;t_0\\ \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
 (let* ((t_0 (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ (+ Vef Ev) KbT)))))))
   (if (<= EAccept 8.2e-170)
     t_0
     (if (<= EAccept 6e-55)
       (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (/ NdChar 2.0))
       (if (<= EAccept 8.2e+128)
         t_0
         (+ (/ 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 t_0 = (NdChar / 2.0) + (NaChar / (1.0 + exp(((Vef + Ev) / KbT))));
	double tmp;
	if (EAccept <= 8.2e-170) {
		tmp = t_0;
	} else if (EAccept <= 6e-55) {
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
	} else if (EAccept <= 8.2e+128) {
		tmp = t_0;
	} 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) :: t_0
    real(8) :: tmp
    t_0 = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp(((vef + ev) / kbt))))
    if (eaccept <= 8.2d-170) then
        tmp = t_0
    else if (eaccept <= 6d-55) then
        tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / 2.0d0)
    else if (eaccept <= 8.2d+128) then
        tmp = t_0
    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 t_0 = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp(((Vef + Ev) / KbT))));
	double tmp;
	if (EAccept <= 8.2e-170) {
		tmp = t_0;
	} else if (EAccept <= 6e-55) {
		tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / 2.0);
	} else if (EAccept <= 8.2e+128) {
		tmp = t_0;
	} 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):
	t_0 = (NdChar / 2.0) + (NaChar / (1.0 + math.exp(((Vef + Ev) / KbT))))
	tmp = 0
	if EAccept <= 8.2e-170:
		tmp = t_0
	elif EAccept <= 6e-55:
		tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / 2.0)
	elif EAccept <= 8.2e+128:
		tmp = t_0
	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)
	t_0 = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Ev) / KbT)))))
	tmp = 0.0
	if (EAccept <= 8.2e-170)
		tmp = t_0;
	elseif (EAccept <= 6e-55)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / 2.0));
	elseif (EAccept <= 8.2e+128)
		tmp = t_0;
	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)
	t_0 = (NdChar / 2.0) + (NaChar / (1.0 + exp(((Vef + Ev) / KbT))));
	tmp = 0.0;
	if (EAccept <= 8.2e-170)
		tmp = t_0;
	elseif (EAccept <= 6e-55)
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
	elseif (EAccept <= 8.2e+128)
		tmp = t_0;
	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_] := Block[{t$95$0 = N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + Ev), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, 8.2e-170], t$95$0, If[LessEqual[EAccept, 6e-55], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 8.2e+128], t$95$0, 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 EAccept < 8.19999999999999931e-170 or 6.00000000000000033e-55 < EAccept < 8.20000000000000023e128

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 46.5%

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

   5. Taylor expanded in EAccept around 0 42.3%

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

      1. +-commutative 42.3%

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

   7. Simplified 42.3%

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

   8. Taylor expanded in mu around 0 38.3%

      \[\leadsto \frac{NdChar}{2} + \color{blue}{\frac{NaChar}{1 + e^{\frac{Ev + Vef}{KbT}}}} \]
   9. Step-by-step derivation

      1. +-commutative 38.3%

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

   10. Simplified 38.3%

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

   if 8.19999999999999931e-170 < EAccept < 6.00000000000000033e-55

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 52.1%

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

   5. Taylor expanded in mu around inf 46.7%

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

      1. neg-mul-1 46.7%

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

   7. Simplified 46.7%

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

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

   4. Taylor expanded in KbT around inf 43.7%

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

   5. Taylor expanded in EAccept around inf 40.0%

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

4. Final simplification 39.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 8.2 \cdot 10^{-170}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 6 \cdot 10^{-55}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;EAccept \leq 8.2 \cdot 10^{+128}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 16: 46.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -3.2 \cdot 10^{+31}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 2.05 \cdot 10^{-85}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -3.2e+31)
   (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))
   (if (<= NaChar 2.05e-85)
     (+ (/ NaChar (+ 1.0 (/ Ev KbT))) (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
     (+
      (/ NdChar 2.0)
      (/ NaChar (+ 1.0 (exp (/ (- (+ 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) {
	double tmp;
	if (NaChar <= -3.2e+31) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	} else if (NaChar <= 2.05e-85) {
		tmp = (NaChar / (1.0 + (Ev / KbT))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -3.2e+31)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)))));
	elseif (NaChar <= 2.05e-85)
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -3.2e+31)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	elseif (NaChar <= 2.05e-85)
		tmp = (NaChar / (1.0 + (Ev / KbT))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -3.2e+31], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.05e-85], N[(N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -3.2000000000000001e31

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 60.0%

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

   5. Taylor expanded in EAccept around 0 55.9%

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

      1. +-commutative 55.9%

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

   7. Simplified 55.9%

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

   if -3.2000000000000001e31 < NaChar < 2.04999999999999997e-85

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 58.1%

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

   5. Taylor expanded in Ev around inf 68.2%

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

   6. Taylor expanded in EDonor around inf 49.3%

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

   if 2.04999999999999997e-85 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 54.0%

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

   5. Taylor expanded in Ev around 0 51.2%

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

      1. +-commutative 51.2%

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

   7. Simplified 51.2%

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

4. Final simplification 51.5%

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

Alternative 17: 47.3% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -3.5e-65)
   (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))
   (if (<= NaChar 1.2e-23)
     (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar (+ (/ Vef KbT) 2.0)))
     (+
      (/ NdChar 2.0)
      (/ NaChar (+ 1.0 (exp (/ (- (+ 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) {
	double tmp;
	if (NaChar <= -3.5e-65) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	} else if (NaChar <= 1.2e-23) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -3.50000000000000005e-65

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 54.3%

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

   5. Taylor expanded in EAccept around 0 48.5%

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

      1. +-commutative 48.5%

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

   7. Simplified 48.5%

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

   if -3.50000000000000005e-65 < NaChar < 1.19999999999999998e-23

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 76.0%

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

   5. Taylor expanded in Vef around 0 68.0%

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

      1. +-commutative 68.0%

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

   7. Simplified 68.0%

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

   8. Taylor expanded in EDonor around inf 51.1%

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

   if 1.19999999999999998e-23 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 55.9%

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

   5. Taylor expanded in Ev around 0 52.5%

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

      1. +-commutative 52.5%

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

   7. Simplified 52.5%

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

4. Final simplification 50.7%

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

Alternative 18: 43.7% accurate, 2.0× speedup

Math

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

FPCore

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -7.1999999999999998e143

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 47.6%

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

   5. Taylor expanded in EAccept around 0 44.7%

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

      1. +-commutative 44.7%

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

   7. Simplified 44.7%

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

   8. Taylor expanded in mu around 0 41.8%

      \[\leadsto \frac{NdChar}{2} + \color{blue}{\frac{NaChar}{1 + e^{\frac{Ev + Vef}{KbT}}}} \]
   9. Step-by-step derivation

      1. +-commutative 41.8%

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

   10. Simplified 41.8%

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

   if -7.1999999999999998e143 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 46.5%

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

   5. Taylor expanded in Ev around 0 44.6%

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

      1. +-commutative 44.6%

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

   7. Simplified 44.6%

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

4. Final simplification 44.2%

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

Alternative 19: 44.0% accurate, 2.0× speedup

Math

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

FPCore

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 1.9999999999999998e131

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.1%

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

   5. Taylor expanded in EAccept around 0 43.5%

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

      1. +-commutative 43.5%

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

   7. Simplified 43.5%

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

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

   4. Taylor expanded in KbT around inf 43.7%

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

   5. Taylor expanded in Ev around 0 43.7%

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

      1. +-commutative 43.7%

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

   7. Simplified 43.7%

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

4. Final simplification 43.5%

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

Alternative 20: 61.5% accurate, 2.0× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.5e59

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.9%

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

   5. Taylor expanded in EAccept around 0 59.6%

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

      1. +-commutative 59.6%

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

   7. Simplified 59.6%

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

   if -1.5e59 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.7%

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

   5. Taylor expanded in Ev around inf 56.8%

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

   6. Taylor expanded in Ev around 0 64.1%

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

4. Final simplification 63.1%

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

Alternative 21: 36.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 1.32 \cdot 10^{-167}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;EAccept \leq 10^{+70}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\ \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 (<= EAccept 1.32e-167)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
   (if (<= EAccept 1e+70)
     (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (/ NdChar 2.0))
     (+ (/ 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 (EAccept <= 1.32e-167) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	} else if (EAccept <= 1e+70) {
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
	} 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 (eaccept <= 1.32d-167) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 2.0d0)
    else if (eaccept <= 1d+70) then
        tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / 2.0d0)
    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 (EAccept <= 1.32e-167) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
	} else if (EAccept <= 1e+70) {
		tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / 2.0);
	} 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 EAccept <= 1.32e-167:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	elif EAccept <= 1e+70:
		tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / 2.0)
	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 (EAccept <= 1.32e-167)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0));
	elseif (EAccept <= 1e+70)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / 2.0));
	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 (EAccept <= 1.32e-167)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	elseif (EAccept <= 1e+70)
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
	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[EAccept, 1.32e-167], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1e+70], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $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 EAccept < 1.3200000000000001e-167

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 46.4%

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

   5. Taylor expanded in Ev around inf 32.8%

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

   if 1.3200000000000001e-167 < EAccept < 1.00000000000000007e70

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 52.3%

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

   5. Taylor expanded in mu around inf 48.9%

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

      1. neg-mul-1 48.9%

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

   7. Simplified 48.9%

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

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

   4. Taylor expanded in KbT around inf 41.8%

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

   5. Taylor expanded in EAccept around inf 37.7%

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

4. Final simplification 36.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 1.32 \cdot 10^{-167}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;EAccept \leq 10^{+70}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 22: 33.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -1.9 \cdot 10^{+56}:\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \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 (<= Vef -1.9e+56)
   (+
    (/
     NdChar
     (- (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT)))) (/ Ec KbT)))
    (/ NaChar (+ 1.0 (/ Ev KbT))))
   (+ (/ 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 (Vef <= -1.9e+56) {
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / (1.0 + (Ev / KbT)));
	} 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 (vef <= (-1.9d+56)) then
        tmp = (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / kbt))) + (nachar / (1.0d0 + (ev / kbt)))
    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 (Vef <= -1.9e+56) {
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / (1.0 + (Ev / KbT)));
	} 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 Vef <= -1.9e+56:
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / (1.0 + (Ev / KbT)))
	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 (Vef <= -1.9e+56)
		tmp = Float64(Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))) + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	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 (Vef <= -1.9e+56)
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / (1.0 + (Ev / KbT)));
	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[Vef, -1.9e+56], N[(N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $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 2 regimes

2. if Vef < -1.89999999999999998e56

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 42.4%

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

   5. Taylor expanded in Ev around inf 51.1%

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

   6. Taylor expanded in KbT around inf 30.4%

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

   if -1.89999999999999998e56 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 50.6%

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

   5. Taylor expanded in EAccept around inf 40.0%

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

4. Final simplification 38.0%

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

Alternative 23: 36.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 3.2 \cdot 10^{+131}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \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 (<= EAccept 3.2e+131)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
   (+ (/ 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 (EAccept <= 3.2e+131) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	} 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 (eaccept <= 3.2d+131) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 2.0d0)
    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 (EAccept <= 3.2e+131) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
	} 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 EAccept <= 3.2e+131:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	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 (EAccept <= 3.2e+131)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0));
	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 (EAccept <= 3.2e+131)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	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[EAccept, 3.2e+131], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $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 2 regimes

2. if EAccept < 3.2000000000000002e131

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.1%

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

   5. Taylor expanded in Ev around inf 34.7%

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

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

   4. Taylor expanded in KbT around inf 43.7%

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

   5. Taylor expanded in EAccept around inf 40.0%

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

4. Final simplification 35.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 3.2 \cdot 10^{+131}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 24: 27.3% accurate, 7.4× speedup

Math

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

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (Vef <= -5.9e+54) or not (Vef <= 1.65e+204):
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / (1.0 + (Ev / KbT)))
	else:
		tmp = (NdChar / 2.0) + (NaChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((Vef <= -5.9e+54) || !(Vef <= 1.65e+204))
		tmp = Float64(Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))) + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	else
		tmp = Float64(Float64(NdChar / 2.0) + 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 ((Vef <= -5.9e+54) || ~((Vef <= 1.65e+204)))
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / (1.0 + (Ev / KbT)));
	else
		tmp = (NdChar / 2.0) + (NaChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -5.9e+54], N[Not[LessEqual[Vef, 1.65e+204]], $MachinePrecision]], N[(N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -5.8999999999999997e54 or 1.6499999999999999e204 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 40.1%

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

   5. Taylor expanded in Ev around inf 50.7%

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

   6. Taylor expanded in KbT around inf 27.9%

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

   if -5.8999999999999997e54 < Vef < 1.6499999999999999e204

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 53.2%

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

   5. Taylor expanded in KbT around inf 28.6%

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

      1. +-commutative 28.6%

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

   7. Simplified 28.6%

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

   8. Taylor expanded in KbT around inf 31.5%

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

4. Final simplification 30.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -5.9 \cdot 10^{+54} \lor \neg \left(Vef \leq 1.65 \cdot 10^{+204}\right):\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2} + NaChar \cdot 0.5\\ \end{array} \]

Alternative 25: 27.7% accurate, 7.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 4.5e169

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 71.2%

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

   5. Taylor expanded in Vef around 0 51.3%

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

      1. +-commutative 51.3%

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

   7. Simplified 51.3%

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

   8. Taylor expanded in KbT around inf 28.3%

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

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

   4. Taylor expanded in KbT around inf 43.2%

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

   5. Taylor expanded in Ev around inf 59.1%

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

   6. Taylor expanded in KbT around inf 34.3%

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

4. Final simplification 29.1%

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

Alternative 26: 27.7% accurate, 17.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 2.15 \cdot 10^{+168}:\\ \;\;\;\;\frac{NdChar}{2} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 2.15e+168)
   (+ (/ NdChar 2.0) (* NaChar 0.5))
   (+ (/ NaChar (+ 1.0 (/ Ev KbT))) (/ NdChar 2.0))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if EAccept <= 2.15e+168:
		tmp = (NdChar / 2.0) + (NaChar * 0.5)
	else:
		tmp = (NaChar / (1.0 + (Ev / KbT))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (EAccept <= 2.15e+168)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar * 0.5));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (EAccept <= 2.15e+168)
		tmp = (NdChar / 2.0) + (NaChar * 0.5);
	else
		tmp = (NaChar / (1.0 + (Ev / KbT))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EAccept, 2.15e+168], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if EAccept < 2.1499999999999999e168

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 46.5%

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

   5. Taylor expanded in KbT around inf 24.1%

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

      1. +-commutative 24.1%

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

   7. Simplified 24.1%

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

   8. Taylor expanded in KbT around inf 26.7%

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

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

   4. Taylor expanded in KbT around inf 43.2%

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

   5. Taylor expanded in Ev around inf 59.1%

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

   6. Taylor expanded in KbT around inf 34.3%

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

4. Final simplification 27.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 2.15 \cdot 10^{+168}:\\ \;\;\;\;\frac{NdChar}{2} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 27: 27.0% accurate, 32.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+ (/ NdChar 2.0) (* 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 (NdChar / 2.0) + (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 = (ndchar / 2.0d0) + (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 (NdChar / 2.0) + (NaChar * 0.5);
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 46.6%

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

5. Taylor expanded in KbT around inf 22.9%

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

   1. +-commutative 22.9%

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

7. Simplified 22.9%

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

8. Taylor expanded in KbT around inf 25.9%

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

9. Final simplification 25.9%

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

Reproduce

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