Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 43.7s

Alternatives: 32

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Power[N[Sqrt[N[Exp[N[(N[(EDonor + N[(N[(Vef + mu), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], 2.0], $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-sqr-sqrt 100.0%

      \[\leadsto \frac{NdChar}{1 + \color{blue}{\sqrt{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} \cdot \sqrt{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}}} \]

   2. pow2 100.0%

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

   3. *-un-lft-identity 100.0%

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

   4. *-un-lft-identity 100.0%

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

   5. associate-+r- 100.0%

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

   6. +-commutative 100.0%

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

5. Applied egg-rr 100.0%

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

6. Final simplification 100.0%

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

Alternative 2: 100.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \mathsf{expm1}\left(\mathsf{log1p}\left(e^{\frac{EDonor + \left(\left(Vef + mu\right) - Ec\right)}{KbT}}\right)\right)} \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 (expm1 (log1p (exp (/ (+ EDonor (- (+ Vef mu) 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 + expm1(log1p(exp(((EDonor + ((Vef + mu) - Ec)) / 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 (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + Math.expm1(Math.log1p(Math.exp(((EDonor + ((Vef + mu) - 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.expm1(math.log1p(math.exp(((EDonor + ((Vef + mu) - 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 + expm1(log1p(exp(Float64(Float64(EDonor + Float64(Float64(Vef + mu) - 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[Log[1 + N[Exp[N[(N[(EDonor + N[(N[(Vef + mu), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]] - 1), $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. expm1-log1p-u 100.0%

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

   2. *-un-lft-identity 100.0%

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

   3. *-un-lft-identity 100.0%

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

   4. associate-+r- 100.0%

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

   5. +-commutative 100.0%

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

5. Applied egg-rr 100.0%

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

6. Final simplification 100.0%

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

Alternative 3: 75.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_2 := t_1 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -2.4 \cdot 10^{+84}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -1.05 \cdot 10^{-293}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 2.85 \cdot 10^{-188}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 7.8 \cdot 10^{-107}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 7 \cdot 10^{+139}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + e^{\frac{EDonor}{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
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor Vef) Ec) KbT))))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
        (t_2 (+ t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -2.4e+84)
     t_2
     (if (<= mu -1.05e-293)
       t_0
       (if (<= mu 2.85e-188)
         (+
          t_1
          (/
           NdChar
           (+
            1.0
            (-
             (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
             (/ Ec KbT)))))
         (if (<= mu 7.8e-107)
           t_0
           (if (<= mu 7e+139)
             (+ t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
             t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((EDonor + Vef) - Ec) / KbT))));
	double t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -2.4e+84) {
		tmp = t_2;
	} else if (mu <= -1.05e-293) {
		tmp = t_0;
	} else if (mu <= 2.85e-188) {
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 7.8e-107) {
		tmp = t_0;
	} else if (mu <= 7e+139) {
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((((edonor + vef) - ec) / kbt))))
    t_1 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    t_2 = t_1 + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-2.4d+84)) then
        tmp = t_2
    else if (mu <= (-1.05d-293)) then
        tmp = t_0
    else if (mu <= 2.85d-188) then
        tmp = t_1 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
    else if (mu <= 7.8d-107) then
        tmp = t_0
    else if (mu <= 7d+139) then
        tmp = t_1 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((((EDonor + Vef) - Ec) / KbT))));
	double t_1 = NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -2.4e+84) {
		tmp = t_2;
	} else if (mu <= -1.05e-293) {
		tmp = t_0;
	} else if (mu <= 2.85e-188) {
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 7.8e-107) {
		tmp = t_0;
	} else if (mu <= 7e+139) {
		tmp = t_1 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((((EDonor + Vef) - Ec) / KbT))))
	t_1 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	t_2 = t_1 + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -2.4e+84:
		tmp = t_2
	elif mu <= -1.05e-293:
		tmp = t_0
	elif mu <= 2.85e-188:
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))))
	elif mu <= 7.8e-107:
		tmp = t_0
	elif mu <= 7e+139:
		tmp = t_1 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Vef) - Ec) / KbT)))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	t_2 = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -2.4e+84)
		tmp = t_2;
	elseif (mu <= -1.05e-293)
		tmp = t_0;
	elseif (mu <= 2.85e-188)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))));
	elseif (mu <= 7.8e-107)
		tmp = t_0;
	elseif (mu <= 7e+139)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((EDonor + Vef) - Ec) / KbT))));
	t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	t_2 = t_1 + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -2.4e+84)
		tmp = t_2;
	elseif (mu <= -1.05e-293)
		tmp = t_0;
	elseif (mu <= 2.85e-188)
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	elseif (mu <= 7.8e-107)
		tmp = t_0;
	elseif (mu <= 7e+139)
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.4e+84], t$95$2, If[LessEqual[mu, -1.05e-293], t$95$0, If[LessEqual[mu, 2.85e-188], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 7.8e-107], t$95$0, If[LessEqual[mu, 7e+139], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if mu < -2.4e84 or 6.99999999999999957e139 < 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 86.9%

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

   if -2.4e84 < mu < -1.05000000000000003e-293 or 2.85000000000000013e-188 < mu < 7.8000000000000002e-107

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

   5. Taylor expanded in mu around 0 84.6%

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

      1. +-commutative 46.4%

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

   7. Simplified 84.6%

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

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

   if 7.8000000000000002e-107 < mu < 6.99999999999999957e139

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 82.7%

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

4. Final simplification 85.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -2.4 \cdot 10^{+84}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.05 \cdot 10^{-293}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.85 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 7.8 \cdot 10^{-107}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 7 \cdot 10^{+139}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]

Alternative 4: 70.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + t_0\\ \mathbf{if}\;mu \leq -1 \cdot 10^{+136}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -9.2 \cdot 10^{-285}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 2.7 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 6 \cdot 10^{-92}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 8.5 \cdot 10^{+195}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{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) Ec) KbT)))))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_2 (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) t_0)))
   (if (<= mu -1e+136)
     t_1
     (if (<= mu -9.2e-285)
       t_2
       (if (<= mu 2.7e-188)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/
           NdChar
           (+
            1.0
            (-
             (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
             (/ Ec KbT)))))
         (if (<= mu 6e-92)
           t_2
           (if (<= mu 8.5e+195)
             (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev 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) - Ec) / KbT)));
	double t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_2 = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	double tmp;
	if (mu <= -1e+136) {
		tmp = t_1;
	} else if (mu <= -9.2e-285) {
		tmp = t_2;
	} else if (mu <= 2.7e-188) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 6e-92) {
		tmp = t_2;
	} else if (mu <= 8.5e+195) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + vef) - ec) / kbt)))
    t_1 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_2 = (nachar / (1.0d0 + exp((vef / kbt)))) + t_0
    if (mu <= (-1d+136)) then
        tmp = t_1
    else if (mu <= (-9.2d-285)) then
        tmp = t_2
    else if (mu <= 2.7d-188) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
    else if (mu <= 6d-92) then
        tmp = t_2
    else if (mu <= 8.5d+195) then
        tmp = t_0 + (nachar / (1.0d0 + exp((ev / 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) - Ec) / KbT)));
	double t_1 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_2 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
	double tmp;
	if (mu <= -1e+136) {
		tmp = t_1;
	} else if (mu <= -9.2e-285) {
		tmp = t_2;
	} else if (mu <= 2.7e-188) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 6e-92) {
		tmp = t_2;
	} else if (mu <= 8.5e+195) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / 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) - Ec) / KbT)))
	t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_2 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + t_0
	tmp = 0
	if mu <= -1e+136:
		tmp = t_1
	elif mu <= -9.2e-285:
		tmp = t_2
	elif mu <= 2.7e-188:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))))
	elif mu <= 6e-92:
		tmp = t_2
	elif mu <= 8.5e+195:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / 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(Float64(EDonor + Vef) - Ec) / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0)
	tmp = 0.0
	if (mu <= -1e+136)
		tmp = t_1;
	elseif (mu <= -9.2e-285)
		tmp = t_2;
	elseif (mu <= 2.7e-188)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))));
	elseif (mu <= 6e-92)
		tmp = t_2;
	elseif (mu <= 8.5e+195)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / 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) - Ec) / KbT)));
	t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_2 = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	tmp = 0.0;
	if (mu <= -1e+136)
		tmp = t_1;
	elseif (mu <= -9.2e-285)
		tmp = t_2;
	elseif (mu <= 2.7e-188)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	elseif (mu <= 6e-92)
		tmp = t_2;
	elseif (mu <= 8.5e+195)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / 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[(N[(EDonor + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, If[LessEqual[mu, -1e+136], t$95$1, If[LessEqual[mu, -9.2e-285], t$95$2, If[LessEqual[mu, 2.7e-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[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 6e-92], t$95$2, If[LessEqual[mu, 8.5e+195], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if mu < -1.00000000000000006e136 or 8.5e195 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 87.8%

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

   5. Taylor expanded in mu around inf 80.8%

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

      1. associate-*r/ 35.2%

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

      2. mul-1-neg 35.2%

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

   7. Simplified 80.8%

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

   if -1.00000000000000006e136 < mu < -9.19999999999999986e-285 or 2.7000000000000001e-188 < mu < 6.00000000000000027e-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.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 mu around 0 83.9%

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

      1. +-commutative 49.6%

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

   7. Simplified 83.9%

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

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

   if 6.00000000000000027e-92 < mu < 8.5e195

   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.0%

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

   5. Taylor expanded in mu around 0 69.8%

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

      1. +-commutative 42.9%

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

   7. Simplified 69.8%

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

4. Final simplification 80.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1 \cdot 10^{+136}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -9.2 \cdot 10^{-285}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.7 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 6 \cdot 10^{-92}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 8.5 \cdot 10^{+195}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \end{array} \]

Alternative 5: 60.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_3 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{if}\;mu \leq -1.25 \cdot 10^{-5}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -1.2 \cdot 10^{-208}:\\ \;\;\;\;t_3 + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq -5.5 \cdot 10^{-278}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + t_0\\ \mathbf{elif}\;mu \leq 4.5 \cdot 10^{-131}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 1.65 \cdot 10^{+115}:\\ \;\;\;\;t_0 + t_3\\ \mathbf{elif}\;mu \leq 9.6 \cdot 10^{+196}:\\ \;\;\;\;t_1 + \frac{NdChar}{2 + \frac{mu}{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 KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_3 (/ NaChar (+ 1.0 (exp (/ Ev KbT))))))
   (if (<= mu -1.25e-5)
     t_2
     (if (<= mu -1.2e-208)
       (+ t_3 (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
       (if (<= mu -5.5e-278)
         (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) t_0)
         (if (<= mu 4.5e-131)
           (+
            t_1
            (/
             NdChar
             (+
              1.0
              (-
               (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
               (/ Ec KbT)))))
           (if (<= mu 1.65e+115)
             (+ t_0 t_3)
             (if (<= mu 9.6e+196)
               (+ t_1 (/ NdChar (+ 2.0 (/ mu 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 / KbT)));
	double t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_3 = NaChar / (1.0 + exp((Ev / KbT)));
	double tmp;
	if (mu <= -1.25e-5) {
		tmp = t_2;
	} else if (mu <= -1.2e-208) {
		tmp = t_3 + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (mu <= -5.5e-278) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	} else if (mu <= 4.5e-131) {
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 1.65e+115) {
		tmp = t_0 + t_3;
	} else if (mu <= 9.6e+196) {
		tmp = t_1 + (NdChar / (2.0 + (mu / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((edonor / kbt)))
    t_1 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    t_2 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_3 = nachar / (1.0d0 + exp((ev / kbt)))
    if (mu <= (-1.25d-5)) then
        tmp = t_2
    else if (mu <= (-1.2d-208)) then
        tmp = t_3 + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (mu <= (-5.5d-278)) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + t_0
    else if (mu <= 4.5d-131) then
        tmp = t_1 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
    else if (mu <= 1.65d+115) then
        tmp = t_0 + t_3
    else if (mu <= 9.6d+196) then
        tmp = t_1 + (ndchar / (2.0d0 + (mu / 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 / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_3 = NaChar / (1.0 + Math.exp((Ev / KbT)));
	double tmp;
	if (mu <= -1.25e-5) {
		tmp = t_2;
	} else if (mu <= -1.2e-208) {
		tmp = t_3 + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (mu <= -5.5e-278) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
	} else if (mu <= 4.5e-131) {
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 1.65e+115) {
		tmp = t_0 + t_3;
	} else if (mu <= 9.6e+196) {
		tmp = t_1 + (NdChar / (2.0 + (mu / 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 / KbT)))
	t_1 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	t_2 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_3 = NaChar / (1.0 + math.exp((Ev / KbT)))
	tmp = 0
	if mu <= -1.25e-5:
		tmp = t_2
	elif mu <= -1.2e-208:
		tmp = t_3 + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif mu <= -5.5e-278:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + t_0
	elif mu <= 4.5e-131:
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))))
	elif mu <= 1.65e+115:
		tmp = t_0 + t_3
	elif mu <= 9.6e+196:
		tmp = t_1 + (NdChar / (2.0 + (mu / 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(EDonor / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_3 = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))
	tmp = 0.0
	if (mu <= -1.25e-5)
		tmp = t_2;
	elseif (mu <= -1.2e-208)
		tmp = Float64(t_3 + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (mu <= -5.5e-278)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0);
	elseif (mu <= 4.5e-131)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))));
	elseif (mu <= 1.65e+115)
		tmp = Float64(t_0 + t_3);
	elseif (mu <= 9.6e+196)
		tmp = Float64(t_1 + Float64(NdChar / Float64(2.0 + Float64(mu / 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 / KbT)));
	t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	t_2 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_3 = NaChar / (1.0 + exp((Ev / KbT)));
	tmp = 0.0;
	if (mu <= -1.25e-5)
		tmp = t_2;
	elseif (mu <= -1.2e-208)
		tmp = t_3 + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (mu <= -5.5e-278)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
	elseif (mu <= 4.5e-131)
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	elseif (mu <= 1.65e+115)
		tmp = t_0 + t_3;
	elseif (mu <= 9.6e+196)
		tmp = t_1 + (NdChar / (2.0 + (mu / 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[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.25e-5], t$95$2, If[LessEqual[mu, -1.2e-208], N[(t$95$3 + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -5.5e-278], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[mu, 4.5e-131], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.65e+115], N[(t$95$0 + t$95$3), $MachinePrecision], If[LessEqual[mu, 9.6e+196], N[(t$95$1 + N[(NdChar / N[(2.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if mu < -1.25000000000000006e-5 or 9.6000000000000002e196 < 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 82.8%

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

   5. Taylor expanded in mu around inf 77.0%

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

      1. associate-*r/ 38.5%

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

      2. mul-1-neg 38.5%

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

   7. Simplified 77.0%

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

   if -1.25000000000000006e-5 < mu < -1.1999999999999999e-208

   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 71.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 inf 58.3%

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

      1. associate-*r/ 58.3%

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

      2. mul-1-neg 58.3%

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

   7. Simplified 58.3%

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

   if -1.1999999999999999e-208 < mu < -5.49999999999999989e-278

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 80.6%

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

   5. Taylor expanded in Vef around inf 70.9%

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

   if -5.49999999999999989e-278 < mu < 4.5000000000000002e-131

   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 73.2%

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

   if 4.5000000000000002e-131 < mu < 1.65000000000000003e115

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 81.8%

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

   5. Taylor expanded in Ev around inf 59.7%

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

   if 1.65000000000000003e115 < mu < 9.6000000000000002e196

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 87.3%

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

   5. Taylor expanded in mu around 0 93.8%

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

4. Final simplification 71.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1.25 \cdot 10^{-5}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.2 \cdot 10^{-208}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq -5.5 \cdot 10^{-278}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 4.5 \cdot 10^{-131}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 1.65 \cdot 10^{+115}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 9.6 \cdot 10^{+196}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2 + \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \end{array} \]

Alternative 6: 71.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{if}\;mu \leq -1.7 \cdot 10^{+134}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 3 \cdot 10^{-277}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{-203}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 7.8 \cdot 10^{+195}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor Vef) Ec) KbT))))
          (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))))
   (if (<= mu -1.7e+134)
     t_0
     (if (<= mu 3e-277)
       t_1
       (if (<= mu 1.6e-203)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/
           NdChar
           (+
            1.0
            (-
             (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
             (/ Ec KbT)))))
         (if (<= mu 7.8e+195) t_1 t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_1 = (NdChar / (1.0 + exp((((EDonor + Vef) - Ec) / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	double tmp;
	if (mu <= -1.7e+134) {
		tmp = t_0;
	} else if (mu <= 3e-277) {
		tmp = t_1;
	} else if (mu <= 1.6e-203) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 7.8e+195) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_1 = (ndchar / (1.0d0 + exp((((edonor + vef) - ec) / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
    if (mu <= (-1.7d+134)) then
        tmp = t_0
    else if (mu <= 3d-277) then
        tmp = t_1
    else if (mu <= 1.6d-203) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
    else if (mu <= 7.8d+195) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_1 = (NdChar / (1.0 + Math.exp((((EDonor + Vef) - Ec) / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	double tmp;
	if (mu <= -1.7e+134) {
		tmp = t_0;
	} else if (mu <= 3e-277) {
		tmp = t_1;
	} else if (mu <= 1.6e-203) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 7.8e+195) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_1 = (NdChar / (1.0 + math.exp((((EDonor + Vef) - Ec) / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	tmp = 0
	if mu <= -1.7e+134:
		tmp = t_0
	elif mu <= 3e-277:
		tmp = t_1
	elif mu <= 1.6e-203:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))))
	elif mu <= 7.8e+195:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Vef) - Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))))
	tmp = 0.0
	if (mu <= -1.7e+134)
		tmp = t_0;
	elseif (mu <= 3e-277)
		tmp = t_1;
	elseif (mu <= 1.6e-203)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))));
	elseif (mu <= 7.8e+195)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_1 = (NdChar / (1.0 + exp((((EDonor + Vef) - Ec) / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	tmp = 0.0;
	if (mu <= -1.7e+134)
		tmp = t_0;
	elseif (mu <= 3e-277)
		tmp = t_1;
	elseif (mu <= 1.6e-203)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	elseif (mu <= 7.8e+195)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.7e+134], t$95$0, If[LessEqual[mu, 3e-277], t$95$1, If[LessEqual[mu, 1.6e-203], 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[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 7.8e+195], t$95$1, t$95$0]]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -1.70000000000000009e134 or 7.7999999999999995e195 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 87.8%

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

   5. Taylor expanded in mu around inf 80.8%

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

      1. associate-*r/ 35.2%

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

      2. mul-1-neg 35.2%

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

   7. Simplified 80.8%

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

   if -1.70000000000000009e134 < mu < 2.99999999999999978e-277 or 1.6e-203 < mu < 7.7999999999999995e195

   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.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 mu around 0 72.0%

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

      1. +-commutative 45.9%

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

   7. Simplified 72.0%

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

   if 2.99999999999999978e-277 < mu < 1.6e-203

   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 83.6%

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

4. Final simplification 75.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1.7 \cdot 10^{+134}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 3 \cdot 10^{-277}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{-203}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 7.8 \cdot 10^{+195}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + Vef\right) - Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \end{array} \]

Alternative 7: 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 8: 62.0% 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 + \left(1 + \frac{Vef}{KbT}\right)}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_3 := t_2 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{if}\;NaChar \leq -4.3 \cdot 10^{+123}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;NaChar \leq -3.3 \cdot 10^{+54}:\\ \;\;\;\;t_0 + \frac{NaChar}{\frac{Ev}{KbT} + \left(2 + 0.5 \cdot \frac{Ev \cdot Ev}{KbT \cdot KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -2.8 \cdot 10^{-40}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;NaChar \leq 5.2 \cdot 10^{-76}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq 2.4 \cdot 10^{-6}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 1.2 \cdot 10^{+61}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2 + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ Vef KbT))))))
        (t_2 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
        (t_3
         (+
          t_2
          (/
           NdChar
           (+
            1.0
            (-
             (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
             (/ Ec KbT)))))))
   (if (<= NaChar -4.3e+123)
     t_3
     (if (<= NaChar -3.3e+54)
       (+
        t_0
        (/ NaChar (+ (/ Ev KbT) (+ 2.0 (* 0.5 (/ (* Ev Ev) (* KbT KbT)))))))
       (if (<= NaChar -2.8e-40)
         t_3
         (if (<= NaChar 5.2e-76)
           t_1
           (if (<= NaChar 2.4e-6)
             (+
              (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
              (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
             (if (<= NaChar 1.2e+61)
               t_1
               (+ t_2 (/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	double t_2 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_3 = t_2 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	double tmp;
	if (NaChar <= -4.3e+123) {
		tmp = t_3;
	} else if (NaChar <= -3.3e+54) {
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	} else if (NaChar <= -2.8e-40) {
		tmp = t_3;
	} else if (NaChar <= 5.2e-76) {
		tmp = t_1;
	} else if (NaChar <= 2.4e-6) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (NaChar <= 1.2e+61) {
		tmp = t_1;
	} else {
		tmp = t_2 + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: 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 = t_0 + (nachar / (1.0d0 + (1.0d0 + (vef / kbt))))
    t_2 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    t_3 = t_2 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
    if (nachar <= (-4.3d+123)) then
        tmp = t_3
    else if (nachar <= (-3.3d+54)) then
        tmp = t_0 + (nachar / ((ev / kbt) + (2.0d0 + (0.5d0 * ((ev * ev) / (kbt * kbt))))))
    else if (nachar <= (-2.8d-40)) then
        tmp = t_3
    else if (nachar <= 5.2d-76) then
        tmp = t_1
    else if (nachar <= 2.4d-6) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (nachar <= 1.2d+61) then
        tmp = t_1
    else
        tmp = t_2 + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	double t_2 = NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_3 = t_2 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	double tmp;
	if (NaChar <= -4.3e+123) {
		tmp = t_3;
	} else if (NaChar <= -3.3e+54) {
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	} else if (NaChar <= -2.8e-40) {
		tmp = t_3;
	} else if (NaChar <= 5.2e-76) {
		tmp = t_1;
	} else if (NaChar <= 2.4e-6) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (NaChar <= 1.2e+61) {
		tmp = t_1;
	} else {
		tmp = t_2 + (NdChar / (1.0 + (1.0 + (EDonor / 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)))
	t_1 = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))))
	t_2 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	t_3 = t_2 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))))
	tmp = 0
	if NaChar <= -4.3e+123:
		tmp = t_3
	elif NaChar <= -3.3e+54:
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))))
	elif NaChar <= -2.8e-40:
		tmp = t_3
	elif NaChar <= 5.2e-76:
		tmp = t_1
	elif NaChar <= 2.4e-6:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif NaChar <= 1.2e+61:
		tmp = t_1
	else:
		tmp = t_2 + (NdChar / (1.0 + (1.0 + (EDonor / 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))))
	t_1 = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / KbT)))))
	t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	t_3 = Float64(t_2 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))))
	tmp = 0.0
	if (NaChar <= -4.3e+123)
		tmp = t_3;
	elseif (NaChar <= -3.3e+54)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(2.0 + Float64(0.5 * Float64(Float64(Ev * Ev) / Float64(KbT * KbT)))))));
	elseif (NaChar <= -2.8e-40)
		tmp = t_3;
	elseif (NaChar <= 5.2e-76)
		tmp = t_1;
	elseif (NaChar <= 2.4e-6)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (NaChar <= 1.2e+61)
		tmp = t_1;
	else
		tmp = Float64(t_2 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / 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)));
	t_1 = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	t_2 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	t_3 = t_2 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	tmp = 0.0;
	if (NaChar <= -4.3e+123)
		tmp = t_3;
	elseif (NaChar <= -3.3e+54)
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	elseif (NaChar <= -2.8e-40)
		tmp = t_3;
	elseif (NaChar <= 5.2e-76)
		tmp = t_1;
	elseif (NaChar <= 2.4e-6)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (NaChar <= 1.2e+61)
		tmp = t_1;
	else
		tmp = t_2 + (NdChar / (1.0 + (1.0 + (EDonor / 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]}, Block[{t$95$1 = N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -4.3e+123], t$95$3, If[LessEqual[NaChar, -3.3e+54], N[(t$95$0 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(2.0 + N[(0.5 * N[(N[(Ev * Ev), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -2.8e-40], t$95$3, If[LessEqual[NaChar, 5.2e-76], t$95$1, If[LessEqual[NaChar, 2.4e-6], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.2e+61], t$95$1, N[(t$95$2 + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if NaChar < -4.29999999999999986e123 or -3.3e54 < NaChar < -2.8e-40

   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 70.6%

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

   if -4.29999999999999986e123 < NaChar < -3.3e54

   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 76.8%

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

   5. Taylor expanded in Ev around 0 76.9%

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

      1. unpow2 41.5%

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

      2. unpow2 41.5%

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

   7. Simplified 76.9%

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

   if -2.8e-40 < NaChar < 5.1999999999999999e-76 or 2.3999999999999999e-6 < NaChar < 1.1999999999999999e61

   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.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.9%

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

   if 5.1999999999999999e-76 < NaChar < 2.3999999999999999e-6

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 79.7%

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

   5. Taylor expanded in Ev around inf 63.6%

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

   if 1.1999999999999999e61 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 81.5%

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

   5. Taylor expanded in EDonor around 0 65.8%

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

4. Final simplification 68.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -4.3 \cdot 10^{+123}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -3.3 \cdot 10^{+54}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + \left(2 + 0.5 \cdot \frac{Ev \cdot Ev}{KbT \cdot KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -2.8 \cdot 10^{-40}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 5.2 \cdot 10^{-76}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 2.4 \cdot 10^{-6}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 1.2 \cdot 10^{+61}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \end{array} \]

Alternative 9: 74.7% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -3e-27) (not (<= Vef 2e+205)))
   (+
    (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
    (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor Vef) Ec) KbT)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((Vef <= -3e-27) || !(Vef <= 2e+205)) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((EDonor + Vef) - Ec) / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -3e-27], N[Not[LessEqual[Vef, 2e+205]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + Vef), $MachinePrecision] - Ec), $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 / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -3.0000000000000001e-27 or 2.00000000000000003e205 < 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 83.3%

      \[\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 mu around 0 81.4%

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

      1. +-commutative 32.1%

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

   7. Simplified 81.4%

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

   if -3.0000000000000001e-27 < Vef < 2.00000000000000003e205

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 80.1%

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

4. Final simplification 80.6%

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

Alternative 10: 75.9% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -3e-27) (not (<= Vef 1.3e+200)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
    (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((Vef <= -3e-27) || !(Vef <= 1.3e+200)) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((Vef / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -3e-27], N[Not[LessEqual[Vef, 1.3e+200]], $MachinePrecision]], 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[(Vef / 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 / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -3.0000000000000001e-27 or 1.3000000000000001e200 < 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 83.3%

      \[\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 -3.0000000000000001e-27 < Vef < 1.3000000000000001e200

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 80.1%

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

4. Final simplification 81.3%

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

Alternative 11: 61.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{if}\;mu \leq -2.7 \cdot 10^{+126}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 1.4 \cdot 10^{-128}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 10^{+119}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 6.2 \cdot 10^{+196}:\\ \;\;\;\;t_1 + \frac{NdChar}{2 + \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))))
   (if (<= mu -2.7e+126)
     t_0
     (if (<= mu 1.4e-128)
       (+
        t_1
        (/
         NdChar
         (+
          1.0
          (-
           (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
           (/ Ec KbT)))))
       (if (<= mu 1e+119)
         (+
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
          (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
         (if (<= mu 6.2e+196) (+ t_1 (/ NdChar (+ 2.0 (/ mu KbT)))) t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double tmp;
	if (mu <= -2.7e+126) {
		tmp = t_0;
	} else if (mu <= 1.4e-128) {
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 1e+119) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (mu <= 6.2e+196) {
		tmp = t_1 + (NdChar / (2.0 + (mu / KbT)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_1 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    if (mu <= (-2.7d+126)) then
        tmp = t_0
    else if (mu <= 1.4d-128) then
        tmp = t_1 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
    else if (mu <= 1d+119) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (mu <= 6.2d+196) then
        tmp = t_1 + (ndchar / (2.0d0 + (mu / kbt)))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_1 = NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double tmp;
	if (mu <= -2.7e+126) {
		tmp = t_0;
	} else if (mu <= 1.4e-128) {
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	} else if (mu <= 1e+119) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (mu <= 6.2e+196) {
		tmp = t_1 + (NdChar / (2.0 + (mu / KbT)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_1 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	tmp = 0
	if mu <= -2.7e+126:
		tmp = t_0
	elif mu <= 1.4e-128:
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))))
	elif mu <= 1e+119:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif mu <= 6.2e+196:
		tmp = t_1 + (NdChar / (2.0 + (mu / KbT)))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	tmp = 0.0
	if (mu <= -2.7e+126)
		tmp = t_0;
	elseif (mu <= 1.4e-128)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))));
	elseif (mu <= 1e+119)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (mu <= 6.2e+196)
		tmp = Float64(t_1 + Float64(NdChar / Float64(2.0 + Float64(mu / KbT))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	tmp = 0.0;
	if (mu <= -2.7e+126)
		tmp = t_0;
	elseif (mu <= 1.4e-128)
		tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	elseif (mu <= 1e+119)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (mu <= 6.2e+196)
		tmp = t_1 + (NdChar / (2.0 + (mu / KbT)));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.7e+126], t$95$0, If[LessEqual[mu, 1.4e-128], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1e+119], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 6.2e+196], N[(t$95$1 + N[(NdChar / N[(2.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]]

Derivation

1. Split input into 4 regimes

2. if mu < -2.70000000000000002e126 or 6.2000000000000002e196 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 87.0%

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

   5. Taylor expanded in mu around inf 81.3%

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

      1. associate-*r/ 35.2%

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

      2. mul-1-neg 35.2%

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

   7. Simplified 81.3%

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

   if -2.70000000000000002e126 < mu < 1.3999999999999999e-128

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 63.0%

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

   if 1.3999999999999999e-128 < mu < 9.99999999999999944e118

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 81.8%

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

   5. Taylor expanded in Ev around inf 59.7%

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

   if 9.99999999999999944e118 < mu < 6.2000000000000002e196

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 87.3%

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

   5. Taylor expanded in mu around 0 93.8%

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

4. Final simplification 69.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -2.7 \cdot 10^{+126}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.4 \cdot 10^{-128}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 10^{+119}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 6.2 \cdot 10^{+196}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2 + \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \end{array} \]

Alternative 12: 62.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 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_2 := t_1 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{if}\;NaChar \leq -1.65 \cdot 10^{+125}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NaChar \leq -1.65 \cdot 10^{+54}:\\ \;\;\;\;t_0 + \frac{NaChar}{\frac{Ev}{KbT} + \left(2 + 0.5 \cdot \frac{Ev \cdot Ev}{KbT \cdot KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -2.9 \cdot 10^{-38}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NaChar \leq 2 \cdot 10^{+60}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
        (t_2
         (+
          t_1
          (/
           NdChar
           (+
            1.0
            (-
             (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
             (/ Ec KbT)))))))
   (if (<= NaChar -1.65e+125)
     t_2
     (if (<= NaChar -1.65e+54)
       (+
        t_0
        (/ NaChar (+ (/ Ev KbT) (+ 2.0 (* 0.5 (/ (* Ev Ev) (* KbT KbT)))))))
       (if (<= NaChar -2.9e-38)
         t_2
         (if (<= NaChar 2e+60)
           (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ Vef KbT)))))
           (+ t_1 (/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	double tmp;
	if (NaChar <= -1.65e+125) {
		tmp = t_2;
	} else if (NaChar <= -1.65e+54) {
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	} else if (NaChar <= -2.9e-38) {
		tmp = t_2;
	} else if (NaChar <= 2e+60) {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	} else {
		tmp = t_1 + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    t_2 = t_1 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
    if (nachar <= (-1.65d+125)) then
        tmp = t_2
    else if (nachar <= (-1.65d+54)) then
        tmp = t_0 + (nachar / ((ev / kbt) + (2.0d0 + (0.5d0 * ((ev * ev) / (kbt * kbt))))))
    else if (nachar <= (-2.9d-38)) then
        tmp = t_2
    else if (nachar <= 2d+60) then
        tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (vef / kbt))))
    else
        tmp = t_1 + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	double tmp;
	if (NaChar <= -1.65e+125) {
		tmp = t_2;
	} else if (NaChar <= -1.65e+54) {
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	} else if (NaChar <= -2.9e-38) {
		tmp = t_2;
	} else if (NaChar <= 2e+60) {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	} else {
		tmp = t_1 + (NdChar / (1.0 + (1.0 + (EDonor / 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)))
	t_1 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	t_2 = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))))
	tmp = 0
	if NaChar <= -1.65e+125:
		tmp = t_2
	elif NaChar <= -1.65e+54:
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))))
	elif NaChar <= -2.9e-38:
		tmp = t_2
	elif NaChar <= 2e+60:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))))
	else:
		tmp = t_1 + (NdChar / (1.0 + (1.0 + (EDonor / 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))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	t_2 = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))))
	tmp = 0.0
	if (NaChar <= -1.65e+125)
		tmp = t_2;
	elseif (NaChar <= -1.65e+54)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(2.0 + Float64(0.5 * Float64(Float64(Ev * Ev) / Float64(KbT * KbT)))))));
	elseif (NaChar <= -2.9e-38)
		tmp = t_2;
	elseif (NaChar <= 2e+60)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / KbT)))));
	else
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / 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)));
	t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	t_2 = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
	tmp = 0.0;
	if (NaChar <= -1.65e+125)
		tmp = t_2;
	elseif (NaChar <= -1.65e+54)
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	elseif (NaChar <= -2.9e-38)
		tmp = t_2;
	elseif (NaChar <= 2e+60)
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	else
		tmp = t_1 + (NdChar / (1.0 + (1.0 + (EDonor / 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]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.65e+125], t$95$2, If[LessEqual[NaChar, -1.65e+54], N[(t$95$0 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(2.0 + N[(0.5 * N[(N[(Ev * Ev), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -2.9e-38], t$95$2, If[LessEqual[NaChar, 2e+60], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -1.65000000000000003e125 or -1.65e54 < NaChar < -2.89999999999999994e-38

   1. Initial program 100.0%

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

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 70.6%

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

   if -1.65000000000000003e125 < NaChar < -1.65e54

   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 76.8%

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

   5. Taylor expanded in Ev around 0 76.9%

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

      1. unpow2 41.5%

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

      2. unpow2 41.5%

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

   7. Simplified 76.9%

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

   if -2.89999999999999994e-38 < NaChar < 1.9999999999999999e60

   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 73.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 65.8%

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

   if 1.9999999999999999e60 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 81.5%

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

   5. Taylor expanded in EDonor around 0 65.8%

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

4. Final simplification 67.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.65 \cdot 10^{+125}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -1.65 \cdot 10^{+54}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + \left(2 + 0.5 \cdot \frac{Ev \cdot Ev}{KbT \cdot KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -2.9 \cdot 10^{-38}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 2 \cdot 10^{+60}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \end{array} \]

Alternative 13: 60.9% 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}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \mathbf{if}\;NaChar \leq -1.05 \cdot 10^{+181}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -3.2 \cdot 10^{+44}:\\ \;\;\;\;t_0 + \frac{NaChar}{\frac{Ev}{KbT} + \left(2 + 0.5 \cdot \frac{Ev \cdot Ev}{KbT \cdot KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 1.85 \cdot 10^{+61}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))))
   (if (<= NaChar -1.05e+181)
     t_1
     (if (<= NaChar -3.2e+44)
       (+
        t_0
        (/ NaChar (+ (/ Ev KbT) (+ 2.0 (* 0.5 (/ (* Ev Ev) (* KbT KbT)))))))
       (if (<= NaChar 1.85e+61)
         (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ Vef 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 + (mu + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	double tmp;
	if (NaChar <= -1.05e+181) {
		tmp = t_1;
	} else if (NaChar <= -3.2e+44) {
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	} else if (NaChar <= 1.85e+61) {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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 + (mu + (vef - ec))) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
    if (nachar <= (-1.05d+181)) then
        tmp = t_1
    else if (nachar <= (-3.2d+44)) then
        tmp = t_0 + (nachar / ((ev / kbt) + (2.0d0 + (0.5d0 * ((ev * ev) / (kbt * kbt))))))
    else if (nachar <= 1.85d+61) then
        tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (vef / 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 + (mu + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	double tmp;
	if (NaChar <= -1.05e+181) {
		tmp = t_1;
	} else if (NaChar <= -3.2e+44) {
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	} else if (NaChar <= 1.85e+61) {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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 + (mu + (Vef - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))))
	tmp = 0
	if NaChar <= -1.05e+181:
		tmp = t_1
	elif NaChar <= -3.2e+44:
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))))
	elif NaChar <= 1.85e+61:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT)))))
	tmp = 0.0
	if (NaChar <= -1.05e+181)
		tmp = t_1;
	elseif (NaChar <= -3.2e+44)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(2.0 + Float64(0.5 * Float64(Float64(Ev * Ev) / Float64(KbT * KbT)))))));
	elseif (NaChar <= 1.85e+61)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / 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 + (mu + (Vef - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	tmp = 0.0;
	if (NaChar <= -1.05e+181)
		tmp = t_1;
	elseif (NaChar <= -3.2e+44)
		tmp = t_0 + (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT))))));
	elseif (NaChar <= 1.85e+61)
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.05e+181], t$95$1, If[LessEqual[NaChar, -3.2e+44], N[(t$95$0 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(2.0 + N[(0.5 * N[(N[(Ev * Ev), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.85e+61], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.04999999999999999e181 or 1.85000000000000001e61 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 82.0%

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

   5. Taylor expanded in EDonor around 0 68.8%

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

   if -1.04999999999999999e181 < NaChar < -3.20000000000000004e44

   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.0%

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

   5. Taylor expanded in Ev around 0 65.4%

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

      1. unpow2 41.8%

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

      2. unpow2 41.8%

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

   7. Simplified 65.4%

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

   if -3.20000000000000004e44 < NaChar < 1.85000000000000001e61

   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 72.4%

      \[\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 62.0%

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

4. Final simplification 64.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.05 \cdot 10^{+181}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -3.2 \cdot 10^{+44}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + \left(2 + 0.5 \cdot \frac{Ev \cdot Ev}{KbT \cdot KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 1.85 \cdot 10^{+61}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \end{array} \]

Alternative 14: 59.5% 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}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;NaChar \leq -1.05 \cdot 10^{+181}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -1.75 \cdot 10^{-19}:\\ \;\;\;\;t_0 + \frac{NaChar}{2 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;NaChar \leq -1.75 \cdot 10^{-36} \lor \neg \left(NaChar \leq 1.55 \cdot 10^{+61}\right):\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= NaChar -1.05e+181)
     t_1
     (if (<= NaChar -1.75e-19)
       (+ t_0 (/ NaChar (+ 2.0 (/ Ev KbT))))
       (if (or (<= NaChar -1.75e-36) (not (<= NaChar 1.55e+61)))
         t_1
         (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ Vef 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 t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -1.05e+181) {
		tmp = t_1;
	} else if (NaChar <= -1.75e-19) {
		tmp = t_0 + (NaChar / (2.0 + (Ev / KbT)));
	} else if ((NaChar <= -1.75e-36) || !(NaChar <= 1.55e+61)) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (nachar <= (-1.05d+181)) then
        tmp = t_1
    else if (nachar <= (-1.75d-19)) then
        tmp = t_0 + (nachar / (2.0d0 + (ev / kbt)))
    else if ((nachar <= (-1.75d-36)) .or. (.not. (nachar <= 1.55d+61))) then
        tmp = t_1
    else
        tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (vef / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -1.05e+181) {
		tmp = t_1;
	} else if (NaChar <= -1.75e-19) {
		tmp = t_0 + (NaChar / (2.0 + (Ev / KbT)));
	} else if ((NaChar <= -1.75e-36) || !(NaChar <= 1.55e+61)) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if NaChar <= -1.05e+181:
		tmp = t_1
	elif NaChar <= -1.75e-19:
		tmp = t_0 + (NaChar / (2.0 + (Ev / KbT)))
	elif (NaChar <= -1.75e-36) or not (NaChar <= 1.55e+61):
		tmp = t_1
	else:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (NaChar <= -1.05e+181)
		tmp = t_1;
	elseif (NaChar <= -1.75e-19)
		tmp = Float64(t_0 + Float64(NaChar / Float64(2.0 + Float64(Ev / KbT))));
	elseif ((NaChar <= -1.75e-36) || !(NaChar <= 1.55e+61))
		tmp = t_1;
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / 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)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (NaChar <= -1.05e+181)
		tmp = t_1;
	elseif (NaChar <= -1.75e-19)
		tmp = t_0 + (NaChar / (2.0 + (Ev / KbT)));
	elseif ((NaChar <= -1.75e-36) || ~((NaChar <= 1.55e+61)))
		tmp = t_1;
	else
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.05e+181], t$95$1, If[LessEqual[NaChar, -1.75e-19], N[(t$95$0 + N[(NaChar / N[(2.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, -1.75e-36], N[Not[LessEqual[NaChar, 1.55e+61]], $MachinePrecision]], t$95$1, N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.04999999999999999e181 or -1.75000000000000008e-19 < NaChar < -1.75e-36 or 1.55e61 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 81.8%

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

   5. Taylor expanded in EDonor around 0 64.0%

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

   if -1.04999999999999999e181 < NaChar < -1.75000000000000008e-19

   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 71.2%

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

   5. Taylor expanded in Ev around 0 56.8%

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

   if -1.75e-36 < NaChar < 1.55e61

   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 73.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 65.8%

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

4. Final simplification 63.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.05 \cdot 10^{+181}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq -1.75 \cdot 10^{-19}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;NaChar \leq -1.75 \cdot 10^{-36} \lor \neg \left(NaChar \leq 1.55 \cdot 10^{+61}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \end{array} \]

Alternative 15: 61.3% 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}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \mathbf{if}\;NaChar \leq -2.4 \cdot 10^{+181}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -4 \cdot 10^{+55}:\\ \;\;\;\;t_0 + \frac{NaChar}{2 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;NaChar \leq -1.8 \cdot 10^{-42} \lor \neg \left(NaChar \leq 5 \cdot 10^{+60}\right):\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))))
   (if (<= NaChar -2.4e+181)
     t_1
     (if (<= NaChar -4e+55)
       (+ t_0 (/ NaChar (+ 2.0 (/ Ev KbT))))
       (if (or (<= NaChar -1.8e-42) (not (<= NaChar 5e+60)))
         t_1
         (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ Vef 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 t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	double tmp;
	if (NaChar <= -2.4e+181) {
		tmp = t_1;
	} else if (NaChar <= -4e+55) {
		tmp = t_0 + (NaChar / (2.0 + (Ev / KbT)));
	} else if ((NaChar <= -1.8e-42) || !(NaChar <= 5e+60)) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
    if (nachar <= (-2.4d+181)) then
        tmp = t_1
    else if (nachar <= (-4d+55)) then
        tmp = t_0 + (nachar / (2.0d0 + (ev / kbt)))
    else if ((nachar <= (-1.8d-42)) .or. (.not. (nachar <= 5d+60))) then
        tmp = t_1
    else
        tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (vef / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	double tmp;
	if (NaChar <= -2.4e+181) {
		tmp = t_1;
	} else if (NaChar <= -4e+55) {
		tmp = t_0 + (NaChar / (2.0 + (Ev / KbT)));
	} else if ((NaChar <= -1.8e-42) || !(NaChar <= 5e+60)) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))))
	tmp = 0
	if NaChar <= -2.4e+181:
		tmp = t_1
	elif NaChar <= -4e+55:
		tmp = t_0 + (NaChar / (2.0 + (Ev / KbT)))
	elif (NaChar <= -1.8e-42) or not (NaChar <= 5e+60):
		tmp = t_1
	else:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT)))))
	tmp = 0.0
	if (NaChar <= -2.4e+181)
		tmp = t_1;
	elseif (NaChar <= -4e+55)
		tmp = Float64(t_0 + Float64(NaChar / Float64(2.0 + Float64(Ev / KbT))));
	elseif ((NaChar <= -1.8e-42) || !(NaChar <= 5e+60))
		tmp = t_1;
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / 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)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	tmp = 0.0;
	if (NaChar <= -2.4e+181)
		tmp = t_1;
	elseif (NaChar <= -4e+55)
		tmp = t_0 + (NaChar / (2.0 + (Ev / KbT)));
	elseif ((NaChar <= -1.8e-42) || ~((NaChar <= 5e+60)))
		tmp = t_1;
	else
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / 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]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -2.4e+181], t$95$1, If[LessEqual[NaChar, -4e+55], N[(t$95$0 + N[(NaChar / N[(2.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, -1.8e-42], N[Not[LessEqual[NaChar, 5e+60]], $MachinePrecision]], t$95$1, N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.40000000000000002e181 or -4.00000000000000004e55 < NaChar < -1.8000000000000001e-42 or 4.99999999999999975e60 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 77.9%

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

   5. Taylor expanded in EDonor around 0 63.9%

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

   if -2.40000000000000002e181 < NaChar < -4.00000000000000004e55

   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.8%

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

   5. Taylor expanded in Ev around 0 69.0%

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

   if -1.8000000000000001e-42 < NaChar < 4.99999999999999975e60

   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 73.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 65.8%

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

4. Final simplification 65.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.4 \cdot 10^{+181}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -4 \cdot 10^{+55}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;NaChar \leq -1.8 \cdot 10^{-42} \lor \neg \left(NaChar \leq 5 \cdot 10^{+60}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \end{array} \]

Alternative 16: 58.9% accurate, 1.8× speedup

Math

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

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -5.4e+181], N[Not[LessEqual[NaChar, 2.2e+61]], $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 * 0.5), $MachinePrecision]), $MachinePrecision], 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[(2.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -5.40000000000000014e181 or 2.2e61 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 82.0%

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

   5. Taylor expanded in EDonor around 0 64.4%

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

   if -5.40000000000000014e181 < NaChar < 2.2e61

   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 69.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 Ev around 0 60.7%

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

4. Final simplification 62.0%

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

Alternative 17: 56.1% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -2.7e-65) (not (<= NaChar 7.4e+59)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (* NdChar 0.5))
   (+
    (* NdChar (/ 1.0 (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
    (/ NaChar 2.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -2.7e-65) || !(NaChar <= 7.4e+59)) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = (NdChar * (1.0 / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT))))) + (NaChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((nachar <= (-2.7d-65)) .or. (.not. (nachar <= 7.4d+59))) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar * 0.5d0)
    else
        tmp = (ndchar * (1.0d0 / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt))))) + (nachar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -2.7e-65) || !(NaChar <= 7.4e+59)) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = (NdChar * (1.0 / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT))))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -2.7e-65], N[Not[LessEqual[NaChar, 7.4e+59]], $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 * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * N[(1.0 / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.6999999999999999e-65 or 7.39999999999999995e59 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 77.9%

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

   5. Taylor expanded in EDonor around 0 57.8%

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

   if -2.6999999999999999e-65 < NaChar < 7.39999999999999995e59

   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 69.8%

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

   5. Taylor expanded in Ev around 0 55.4%

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

      1. div-inv 55.4%

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

   7. Applied egg-rr 55.4%

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

4. Final simplification 56.7%

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

Alternative 18: 34.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{if}\;KbT \leq -1.6 \cdot 10^{-128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;KbT \leq -2.1 \cdot 10^{-237}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + \left(2 + 0.5 \cdot \frac{Ev \cdot Ev}{KbT \cdot KbT}\right)} + \frac{NdChar}{\left(\frac{mu}{KbT} + \left(2 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq -1.56 \cdot 10^{-288}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 4.8 \cdot 10^{-118}:\\ \;\;\;\;t_0 + NdChar \cdot \frac{KbT}{EDonor}\\ \mathbf{else}:\\ \;\;\;\;t_0 + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT))))))
   (if (<= KbT -1.6e-128)
     (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0))
     (if (<= KbT -2.1e-237)
       (+
        (/ NaChar (+ (/ Ev KbT) (+ 2.0 (* 0.5 (/ (* Ev Ev) (* KbT KbT))))))
        (/
         NdChar
         (- (+ (/ mu KbT) (+ 2.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ Ec KbT))))
       (if (<= KbT -1.56e-288)
         (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
         (if (<= KbT 4.8e-118)
           (+ t_0 (* NdChar (/ KbT EDonor)))
           (+ t_0 (* NdChar 0.5))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((Ev / KbT)));
	double tmp;
	if (KbT <= -1.6e-128) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	} else if (KbT <= -2.1e-237) {
		tmp = (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT)))))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)));
	} else if (KbT <= -1.56e-288) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (KbT <= 4.8e-118) {
		tmp = t_0 + (NdChar * (KbT / EDonor));
	} else {
		tmp = t_0 + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((ev / kbt)))
    if (kbt <= (-1.6d-128)) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / 2.0d0)
    else if (kbt <= (-2.1d-237)) then
        tmp = (nachar / ((ev / kbt) + (2.0d0 + (0.5d0 * ((ev * ev) / (kbt * kbt)))))) + (ndchar / (((mu / kbt) + (2.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))
    else if (kbt <= (-1.56d-288)) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (kbt <= 4.8d-118) then
        tmp = t_0 + (ndchar * (kbt / edonor))
    else
        tmp = t_0 + (ndchar * 0.5d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((Ev / KbT)));
	double tmp;
	if (KbT <= -1.6e-128) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 2.0);
	} else if (KbT <= -2.1e-237) {
		tmp = (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT)))))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)));
	} else if (KbT <= -1.56e-288) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (KbT <= 4.8e-118) {
		tmp = t_0 + (NdChar * (KbT / EDonor));
	} else {
		tmp = t_0 + (NdChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((Ev / KbT)))
	tmp = 0
	if KbT <= -1.6e-128:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 2.0)
	elif KbT <= -2.1e-237:
		tmp = (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT)))))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))
	elif KbT <= -1.56e-288:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif KbT <= 4.8e-118:
		tmp = t_0 + (NdChar * (KbT / EDonor))
	else:
		tmp = t_0 + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))
	tmp = 0.0
	if (KbT <= -1.6e-128)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / 2.0));
	elseif (KbT <= -2.1e-237)
		tmp = Float64(Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(2.0 + Float64(0.5 * Float64(Float64(Ev * Ev) / Float64(KbT * KbT)))))) + Float64(NdChar / Float64(Float64(Float64(mu / KbT) + Float64(2.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))));
	elseif (KbT <= -1.56e-288)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (KbT <= 4.8e-118)
		tmp = Float64(t_0 + Float64(NdChar * Float64(KbT / EDonor)));
	else
		tmp = Float64(t_0 + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((Ev / KbT)));
	tmp = 0.0;
	if (KbT <= -1.6e-128)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	elseif (KbT <= -2.1e-237)
		tmp = (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT)))))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)));
	elseif (KbT <= -1.56e-288)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (KbT <= 4.8e-118)
		tmp = t_0 + (NdChar * (KbT / EDonor));
	else
		tmp = t_0 + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.6e-128], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2.1e-237], N[(N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(2.0 + N[(0.5 * N[(N[(Ev * Ev), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(N[(mu / KbT), $MachinePrecision] + N[(2.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -1.56e-288], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4.8e-118], N[(t$95$0 + N[(NdChar * N[(KbT / EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 5 regimes

2. if KbT < -1.5999999999999999e-128

   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 63.5%

      \[\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 mu around inf 49.8%

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

   6. Taylor expanded in Ev around 0 45.5%

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

   if -1.5999999999999999e-128 < KbT < -2.1000000000000001e-237

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 57.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 KbT around inf 28.2%

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

   6. Taylor expanded in Ev around 0 31.5%

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

      1. unpow2 31.5%

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

      2. unpow2 31.5%

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

   8. Simplified 31.5%

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

   if -2.1000000000000001e-237 < KbT < -1.5599999999999999e-288

   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.9%

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

   5. Taylor expanded in EAccept around inf 48.4%

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

   if -1.5599999999999999e-288 < KbT < 4.8000000000000003e-118

   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 76.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 KbT around inf 26.3%

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

   6. Taylor expanded in EDonor around inf 23.5%

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

      1. associate-/l* 23.4%

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

   8. Simplified 23.4%

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

      1. associate-/r/ 32.1%

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

   10. Applied egg-rr 32.1%

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

   if 4.8000000000000003e-118 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 62.1%

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

   5. Taylor expanded in KbT around inf 39.3%

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

   6. Taylor expanded in KbT around inf 39.2%

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

4. Final simplification 39.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.6 \cdot 10^{-128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;KbT \leq -2.1 \cdot 10^{-237}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + \left(2 + 0.5 \cdot \frac{Ev \cdot Ev}{KbT \cdot KbT}\right)} + \frac{NdChar}{\left(\frac{mu}{KbT} + \left(2 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq -1.56 \cdot 10^{-288}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 4.8 \cdot 10^{-118}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot \frac{KbT}{EDonor}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 19: 53.5% accurate, 1.9× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -1.6e-66) || !(NaChar <= 5.5e+38)) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = (NdChar / (1.0 + exp((((EDonor + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((nachar <= (-1.6d-66)) .or. (.not. (nachar <= 5.5d+38))) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar * 0.5d0)
    else
        tmp = (ndchar / (1.0d0 + exp((((edonor + vef) - ec) / kbt)))) + (nachar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -1.6e-66) || !(NaChar <= 5.5e+38)) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = (NdChar / (1.0 + Math.exp((((EDonor + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.6e-66], N[Not[LessEqual[NaChar, 5.5e+38]], $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 * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.59999999999999991e-66 or 5.5000000000000003e38 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 77.4%

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

   5. Taylor expanded in EDonor around 0 57.4%

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

   if -1.59999999999999991e-66 < NaChar < 5.5000000000000003e38

   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 69.3%

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

   5. Taylor expanded in Ev around 0 55.0%

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

   6. Taylor expanded in mu around 0 49.4%

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

      1. +-commutative 49.4%

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

   8. Simplified 49.4%

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

4. Final simplification 53.9%

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

Alternative 20: 56.1% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.12e-66) (not (<= NaChar 8e+59)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (* NdChar 0.5))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
    (/ NaChar 2.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -1.12e-66) || !(NaChar <= 8e+59)) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -1.12e-66) || !(NaChar <= 8e+59)) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.12e-66], N[Not[LessEqual[NaChar, 8e+59]], $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 * 0.5), $MachinePrecision]), $MachinePrecision], 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 / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.12000000000000004e-66 or 7.99999999999999977e59 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 77.9%

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

   5. Taylor expanded in EDonor around 0 57.8%

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

   if -1.12000000000000004e-66 < NaChar < 7.99999999999999977e59

   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 69.8%

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

   5. Taylor expanded in Ev around 0 55.4%

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

4. Final simplification 56.7%

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

Alternative 21: 47.1% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -2.9999999999999999e-82 or 4.8e-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 Ev around inf 68.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 Ev around 0 52.3%

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

   6. Taylor expanded in mu around 0 46.9%

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

      1. +-commutative 46.9%

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

   8. Simplified 46.9%

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

   if -2.9999999999999999e-82 < NdChar < 4.8e-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 Ev around inf 58.8%

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

   5. Taylor expanded in KbT around inf 44.9%

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

   6. Taylor expanded in KbT around inf 43.4%

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

4. Final simplification 45.5%

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

Alternative 22: 45.5% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -1.05e+49)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))
   (if (<= NaChar 7e+59)
     (+ (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor Vef) Ec) KbT)))) (/ NaChar 2.0))
     (+ (/ NdChar 2.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 tmp;
	if (NaChar <= -1.05e+49) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
	} else if (NaChar <= 7e+59) {
		tmp = (NdChar / (1.0 + exp((((EDonor + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	} else {
		tmp = (NdChar / 2.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) :: tmp
    if (nachar <= (-1.05d+49)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
    else if (nachar <= 7d+59) then
        tmp = (ndchar / (1.0d0 + exp((((edonor + vef) - ec) / kbt)))) + (nachar / 2.0d0)
    else
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.05000000000000005e49

   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 62.7%

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

   5. Taylor expanded in KbT around inf 45.9%

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

   6. Taylor expanded in KbT around inf 44.0%

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

   if -1.05000000000000005e49 < NaChar < 7e59

   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 67.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}}}} \]

   5. Taylor expanded in Ev around 0 50.8%

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

   6. Taylor expanded in mu around 0 46.2%

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

      1. +-commutative 46.2%

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

   8. Simplified 46.2%

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

   if 7e59 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.6%

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

   5. Taylor expanded in EAccept around inf 47.8%

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

4. Final simplification 46.1%

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

Alternative 23: 46.0% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -8.5e+47)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar (+ 2.0 (/ mu KbT))))
   (if (<= NaChar 5e+59)
     (+ (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor Vef) Ec) KbT)))) (/ NaChar 2.0))
     (+ (/ NdChar 2.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 tmp;
	if (NaChar <= -8.5e+47) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (2.0 + (mu / KbT)));
	} else if (NaChar <= 5e+59) {
		tmp = (NdChar / (1.0 + exp((((EDonor + Vef) - Ec) / KbT)))) + (NaChar / 2.0);
	} else {
		tmp = (NdChar / 2.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) :: tmp
    if (nachar <= (-8.5d+47)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (2.0d0 + (mu / kbt)))
    else if (nachar <= 5d+59) then
        tmp = (ndchar / (1.0d0 + exp((((edonor + vef) - ec) / kbt)))) + (nachar / 2.0d0)
    else
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -8.5000000000000008e47

   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 62.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 mu around inf 47.4%

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

   6. Taylor expanded in mu around 0 44.6%

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

   if -8.5000000000000008e47 < NaChar < 4.9999999999999997e59

   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 67.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}}}} \]

   5. Taylor expanded in Ev around 0 50.8%

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

   6. Taylor expanded in mu around 0 46.2%

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

      1. +-commutative 46.2%

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

   8. Simplified 46.2%

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

   if 4.9999999999999997e59 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.6%

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

   5. Taylor expanded in EAccept around inf 47.8%

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

4. Final simplification 46.2%

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

Alternative 24: 37.5% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 8.5e-284)
   (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar (+ 2.0 (/ Ev KbT))))
   (if (<= EAccept 1.2e+70)
     (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (/ NdChar 2.0))
     (+ (/ NdChar 2.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 tmp;
	if (EAccept <= 8.5e-284) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (2.0 + (Ev / KbT)));
	} else if (EAccept <= 1.2e+70) {
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = (NdChar / 2.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) :: tmp
    if (eaccept <= 8.5d-284) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (2.0d0 + (ev / kbt)))
    else if (eaccept <= 1.2d+70) then
        tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / 2.0d0)
    else
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EAccept, 8.5e-284], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(2.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.2e+70], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / 2.0), $MachinePrecision] + 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 < 8.4999999999999995e-284

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

   5. Taylor expanded in mu around inf 47.5%

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

   6. Taylor expanded in Ev around 0 37.0%

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

   if 8.4999999999999995e-284 < EAccept < 1.19999999999999993e70

   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 59.7%

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

   5. Taylor expanded in mu around inf 49.9%

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

      1. associate-*r/ 49.9%

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

      2. mul-1-neg 49.9%

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

   7. Simplified 49.9%

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

   if 1.19999999999999993e70 < 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}{1 + \color{blue}{1}} + \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}{1 + 1} + \frac{NaChar}{1 + e^{\color{blue}{\frac{EAccept}{KbT}}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 40.2%

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

Alternative 25: 33.7% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -4.2e-123)
   (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0))
   (if (<= KbT -3e-238)
     (+
      (/ NaChar (+ (/ Ev KbT) (+ 2.0 (* 0.5 (/ (* Ev Ev) (* KbT KbT))))))
      (/
       NdChar
       (- (+ (/ mu KbT) (+ 2.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ Ec KbT))))
     (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -4.1999999999999998e-123

   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 63.5%

      \[\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 mu around inf 49.8%

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

   6. Taylor expanded in Ev around 0 45.5%

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

   if -4.1999999999999998e-123 < KbT < -3e-238

   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 57.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 KbT around inf 28.2%

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

   6. Taylor expanded in Ev around 0 31.5%

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

      1. unpow2 31.5%

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

      2. unpow2 31.5%

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

   8. Simplified 31.5%

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

   if -3e-238 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 67.0%

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

   5. Taylor expanded in KbT around inf 33.1%

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

   6. Taylor expanded in KbT around inf 33.1%

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

4. Final simplification 37.0%

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

Alternative 26: 37.2% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;mu \leq -14.5:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;mu \leq 1.55 \cdot 10^{+207}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= mu -14.5)
   (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (/ NdChar 2.0))
   (if (<= mu 1.55e+207)
     (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))
     (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if mu < -14.5

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 42.8%

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

   5. Taylor expanded in mu around inf 39.1%

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

      1. associate-*r/ 39.1%

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

      2. mul-1-neg 39.1%

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

   7. Simplified 39.1%

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

   if -14.5 < mu < 1.5500000000000001e207

   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 70.2%

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

   5. Taylor expanded in KbT around inf 40.8%

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

   6. Taylor expanded in KbT around inf 38.3%

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

   if 1.5500000000000001e207 < 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 Ev around inf 47.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 mu around inf 42.0%

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

   6. Taylor expanded in Ev around 0 36.2%

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

4. Final simplification 38.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -14.5:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;mu \leq 1.55 \cdot 10^{+207}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]

Alternative 27: 36.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -2.6 \cdot 10^{+68}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -2.5999999999999998e68

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 77.2%

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

   5. Taylor expanded in KbT around inf 40.8%

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

   6. Taylor expanded in KbT around inf 36.1%

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

   if -2.5999999999999998e68 < 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 EDonor around inf 73.0%

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

   5. Taylor expanded in KbT around inf 36.7%

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

4. Final simplification 36.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -2.6 \cdot 10^{+68}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \]

Alternative 28: 35.0% accurate, 2.1× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 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 Ev around inf 64.8%

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

5. Taylor expanded in KbT around inf 34.1%

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

6. Taylor expanded in KbT around inf 32.8%

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

7. Final simplification 32.8%

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

Alternative 29: 26.6% accurate, 5.9× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Vef <= -5e+56) {
		tmp = (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT)))))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	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 <= (-5d+56)) then
        tmp = (nachar / ((ev / kbt) + (2.0d0 + (0.5d0 * ((ev * ev) / (kbt * kbt)))))) + (ndchar / (((mu / kbt) + (2.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))
    else
        tmp = 0.5d0 * (ndchar + nachar)
    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 <= -5e+56) {
		tmp = (NaChar / ((Ev / KbT) + (2.0 + (0.5 * ((Ev * Ev) / (KbT * KbT)))))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -5.00000000000000024e56

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 54.4%

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

   5. Taylor expanded in KbT around inf 29.3%

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

   6. Taylor expanded in Ev around 0 29.9%

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

      1. unpow2 29.9%

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

      2. unpow2 29.9%

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

   8. Simplified 29.9%

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

   if -5.00000000000000024e56 < 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}{1 + \color{blue}{1}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in mu around inf 38.4%

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

      1. associate-*r/ 38.4%

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

      2. mul-1-neg 38.4%

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

   7. Simplified 38.4%

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

   8. Taylor expanded in mu around 0 27.2%

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

      1. mul-1-neg 27.2%

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

      2. unsub-neg 27.2%

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

   10. Simplified 27.2%

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

   11. Taylor expanded in mu around 0 28.6%

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

       1. distribute-lft-out 28.6%

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

   13. Simplified 28.6%

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

4. Final simplification 28.9%

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

Alternative 30: 26.7% accurate, 7.9× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Vef <= -5.5e+93) {
		tmp = (NaChar / (2.0 + (Ev / KbT))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	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.5d+93)) then
        tmp = (nachar / (2.0d0 + (ev / kbt))) + (ndchar / (((mu / kbt) + (2.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))
    else
        tmp = 0.5d0 * (ndchar + nachar)
    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.5e+93) {
		tmp = (NaChar / (2.0 + (Ev / KbT))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -5.5000000000000003e93

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 54.5%

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

   5. Taylor expanded in KbT around inf 28.6%

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

   6. Taylor expanded in Ev around 0 26.4%

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

   if -5.5000000000000003e93 < 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 49.6%

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

   5. Taylor expanded in mu around inf 37.5%

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

      1. associate-*r/ 37.5%

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

      2. mul-1-neg 37.5%

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

   7. Simplified 37.5%

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

   8. Taylor expanded in mu around 0 26.8%

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

      1. mul-1-neg 26.8%

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

      2. unsub-neg 26.8%

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

   10. Simplified 26.8%

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

   11. Taylor expanded in mu around 0 28.0%

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

       1. distribute-lft-out 28.0%

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

   13. Simplified 28.0%

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

4. Final simplification 27.7%

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

Alternative 31: 27.0% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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}{1 + \color{blue}{1}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

5. Taylor expanded in mu around inf 34.4%

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

   1. associate-*r/ 34.4%

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

   2. mul-1-neg 34.4%

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

7. Simplified 34.4%

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

8. Taylor expanded in mu around 0 24.8%

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

   1. mul-1-neg 24.8%

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

   2. unsub-neg 24.8%

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

10. Simplified 24.8%

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

11. Taylor expanded in mu around 0 25.9%

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

    1. distribute-lft-out 25.9%

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

13. Simplified 25.9%

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

14. Final simplification 25.9%

    \[\leadsto 0.5 \cdot \left(NdChar + NaChar\right) \]

Alternative 32: 18.0% accurate, 76.3× speedup

Math

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

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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}{1 + \color{blue}{1}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} \]

5. Taylor expanded in mu around inf 34.4%

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

   1. associate-*r/ 34.4%

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

   2. mul-1-neg 34.4%

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

7. Simplified 34.4%

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

8. Taylor expanded in mu around 0 24.8%

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

   1. mul-1-neg 24.8%

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

   2. unsub-neg 24.8%

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

10. Simplified 24.8%

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

11. Taylor expanded in NdChar around inf 17.2%

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

12. Final simplification 17.2%

    \[\leadsto NdChar \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))))))