Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 24.8s

Alternatives: 26

Speedup: 1.0×

• could not determine a ground truth

  1. branch3991 = 8.46145305643147e-18
  2. NdChar = 3.033974340637407e-5
  3. Ec = -4.1414500399489535e+158
  4. Vef = -2.225165832030395e+240
  5. EDonor = 5.213833162281389e+223
  6. mu = -3.273545062548231e-263
  7. KbT = -1.1007790304320035e-160
  8. NaChar = -6.461055095216305e-5
  9. Ev = 8.433093249572048e-135
  10. EAccept = 9.078449645698761e-90

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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. Add Preprocessing

5. Final simplification 99.9%

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

Alternative 2: 71.2% accurate, 1.0× speedup

Math

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

FPCore

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

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 <= -75000.0) {
		tmp = NaChar / (1.0 + (1.0 + Math.expm1(((EAccept + (Vef + (Ev - mu))) / KbT))));
	} else if (NaChar <= 1.7e-101) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -75000

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 70.4%

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

      1. expm1-log1p-u 70.4%

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

      2. log1p-define 70.4%

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

      3. expm1-undefine 70.4%

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

      4. add-exp-log 70.4%

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

      5. associate--l+ 70.4%

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

      6. +-commutative 70.4%

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

   7. Applied egg-rr 70.4%

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

      1. associate--l+ 70.4%

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

      2. expm1-undefine 70.4%

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

      3. +-commutative 70.4%

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

      4. associate--l+ 70.4%

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

   9. Simplified 70.4%

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

   if -75000 < NaChar < 1.69999999999999995e-101

   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. Add Preprocessing

   5. Taylor expanded in NdChar around inf 83.6%

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

   if 1.69999999999999995e-101 < 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. Add Preprocessing

   5. Taylor expanded in Vef around inf 72.5%

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

4. Final simplification 77.2%

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

Alternative 3: 41.2% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -1.9 \cdot 10^{+31}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;mu \leq -9.5 \cdot 10^{-137}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 0.0006:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 3.3 \cdot 10^{+159}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\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))))))
   (if (<= mu -1.9e+31)
     t_0
     (if (<= mu -9.5e-137)
       (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
       (if (<= mu 0.0006)
         (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
         (if (<= mu 3.3e+159) (/ NaChar (+ 1.0 (exp (/ 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)));
	double tmp;
	if (mu <= -1.9e+31) {
		tmp = t_0;
	} else if (mu <= -9.5e-137) {
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	} else if (mu <= 0.0006) {
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	} else if (mu <= 3.3e+159) {
		tmp = NaChar / (1.0 + exp((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) :: tmp
    t_0 = ndchar / (1.0d0 + exp((mu / kbt)))
    if (mu <= (-1.9d+31)) then
        tmp = t_0
    else if (mu <= (-9.5d-137)) then
        tmp = nachar / (1.0d0 + exp((vef / kbt)))
    else if (mu <= 0.0006d0) then
        tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
    else if (mu <= 3.3d+159) then
        tmp = nachar / (1.0d0 + exp((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)));
	double tmp;
	if (mu <= -1.9e+31) {
		tmp = t_0;
	} else if (mu <= -9.5e-137) {
		tmp = NaChar / (1.0 + Math.exp((Vef / KbT)));
	} else if (mu <= 0.0006) {
		tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	} else if (mu <= 3.3e+159) {
		tmp = NaChar / (1.0 + Math.exp((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)))
	tmp = 0
	if mu <= -1.9e+31:
		tmp = t_0
	elif mu <= -9.5e-137:
		tmp = NaChar / (1.0 + math.exp((Vef / KbT)))
	elif mu <= 0.0006:
		tmp = NdChar / (1.0 + math.exp((EDonor / KbT)))
	elif mu <= 3.3e+159:
		tmp = NaChar / (1.0 + math.exp((mu / -KbT)))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	tmp = 0.0
	if (mu <= -1.9e+31)
		tmp = t_0;
	elseif (mu <= -9.5e-137)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	elseif (mu <= 0.0006)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))));
	elseif (mu <= 3.3e+159)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(mu / Float64(-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)));
	tmp = 0.0;
	if (mu <= -1.9e+31)
		tmp = t_0;
	elseif (mu <= -9.5e-137)
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	elseif (mu <= 0.0006)
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	elseif (mu <= 3.3e+159)
		tmp = NaChar / (1.0 + exp((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[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.9e+31], t$95$0, If[LessEqual[mu, -9.5e-137], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 0.0006], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3.3e+159], N[(NaChar / N[(1.0 + N[Exp[N[(mu / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]

Derivation

1. Split input into 4 regimes

2. if mu < -1.9000000000000001e31 or 3.2999999999999999e159 < mu

   1. Initial program 99.8%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\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.8%

      \[\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. Add Preprocessing

   5. Taylor expanded in NdChar around inf 64.8%

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

   6. Taylor expanded in mu around inf 51.0%

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

   if -1.9000000000000001e31 < mu < -9.5000000000000007e-137

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 67.0%

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

   6. Taylor expanded in Vef around inf 55.4%

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

   if -9.5000000000000007e-137 < mu < 5.99999999999999947e-4

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around inf 78.7%

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

   6. Taylor expanded in EDonor around inf 54.4%

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

   if 5.99999999999999947e-4 < mu < 3.2999999999999999e159

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 77.2%

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

   6. Taylor expanded in mu around inf 62.2%

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

      1. mul-1-neg 62.2%

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

   8. Simplified 62.2%

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

4. Final simplification 54.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1.9 \cdot 10^{+31}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -9.5 \cdot 10^{-137}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 0.0006:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 3.3 \cdot 10^{+159}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 68.3% accurate, 1.9× speedup

Math

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

FPCore

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -3.8e5 or 2.20000000000000004e-113 < 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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 69.4%

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

   if -3.8e5 < NaChar < 2.20000000000000004e-113

   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. Add Preprocessing

   5. Taylor expanded in NdChar around inf 84.2%

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

4. Final simplification 76.2%

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

Alternative 5: 65.1% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -230000.0) (not (<= NaChar 1.45e-120)))
   (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
   (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.3e5 or 1.45e-120 < 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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 69.2%

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

   if -2.3e5 < NaChar < 1.45e-120

   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. Add Preprocessing

   5. Taylor expanded in NdChar around inf 84.7%

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

   6. Taylor expanded in EDonor around 0 73.3%

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

4. Final simplification 71.0%

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

Alternative 6: 44.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -4.2 \cdot 10^{-63}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq -1.2 \cdot 10^{-162}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 2.3 \cdot 10^{-14}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-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 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -4.2e-63)
     t_0
     (if (<= Vef -1.2e-162)
       (- (/ NaChar 2.0) (/ NdChar (- -1.0 (exp (/ EDonor KbT)))))
       (if (<= Vef 2.3e-14) (/ NdChar (+ 1.0 (exp (/ Ec (- KbT))))) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -4.2e-63) {
		tmp = t_0;
	} else if (Vef <= -1.2e-162) {
		tmp = (NaChar / 2.0) - (NdChar / (-1.0 - exp((EDonor / KbT))));
	} else if (Vef <= 2.3e-14) {
		tmp = NdChar / (1.0 + exp((Ec / -KbT)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((vef / kbt)))
    if (vef <= (-4.2d-63)) then
        tmp = t_0
    else if (vef <= (-1.2d-162)) then
        tmp = (nachar / 2.0d0) - (ndchar / ((-1.0d0) - exp((edonor / kbt))))
    else if (vef <= 2.3d-14) then
        tmp = ndchar / (1.0d0 + exp((ec / -kbt)))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (Vef <= -4.2e-63) {
		tmp = t_0;
	} else if (Vef <= -1.2e-162) {
		tmp = (NaChar / 2.0) - (NdChar / (-1.0 - Math.exp((EDonor / KbT))));
	} else if (Vef <= 2.3e-14) {
		tmp = NdChar / (1.0 + Math.exp((Ec / -KbT)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -4.2e-63)
		tmp = t_0;
	elseif (Vef <= -1.2e-162)
		tmp = Float64(Float64(NaChar / 2.0) - Float64(NdChar / Float64(-1.0 - exp(Float64(EDonor / KbT)))));
	elseif (Vef <= 2.3e-14)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-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 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -4.2e-63)
		tmp = t_0;
	elseif (Vef <= -1.2e-162)
		tmp = (NaChar / 2.0) - (NdChar / (-1.0 - exp((EDonor / KbT))));
	elseif (Vef <= 2.3e-14)
		tmp = NdChar / (1.0 + exp((Ec / -KbT)));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -4.2e-63], t$95$0, If[LessEqual[Vef, -1.2e-162], N[(N[(NaChar / 2.0), $MachinePrecision] - N[(NdChar / N[(-1.0 - N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2.3e-14], N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -4.2e-63 or 2.29999999999999998e-14 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 64.9%

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

   6. Taylor expanded in Vef around inf 52.1%

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

   if -4.2e-63 < Vef < -1.2000000000000001e-162

   1. Initial program 100.0%

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

   5. Taylor expanded in KbT around inf 74.7%

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

   6. Taylor expanded in EDonor around inf 65.8%

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

   if -1.2000000000000001e-162 < Vef < 2.29999999999999998e-14

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around inf 72.9%

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

   6. Taylor expanded in Ec around inf 54.3%

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

      1. mul-1-neg 54.3%

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

   8. Simplified 54.3%

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

4. Final simplification 54.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -4.2 \cdot 10^{-63}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq -1.2 \cdot 10^{-162}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 2.3 \cdot 10^{-14}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 68.3% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -260000.0)
   (/ NaChar (+ 1.0 (+ 1.0 (expm1 (/ (+ EAccept (+ Vef (- Ev mu))) KbT)))))
   (if (<= NaChar 4e-113)
     (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
     (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))))

C

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

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 <= -260000.0) {
		tmp = NaChar / (1.0 + (1.0 + Math.expm1(((EAccept + (Vef + (Ev - mu))) / KbT))));
	} else if (NaChar <= 4e-113) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.6e5

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 70.4%

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

      1. expm1-log1p-u 70.4%

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

      2. log1p-define 70.4%

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

      3. expm1-undefine 70.4%

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

      4. add-exp-log 70.4%

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

      5. associate--l+ 70.4%

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

      6. +-commutative 70.4%

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

   7. Applied egg-rr 70.4%

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

      1. associate--l+ 70.4%

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

      2. expm1-undefine 70.4%

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

      3. +-commutative 70.4%

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

      4. associate--l+ 70.4%

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

   9. Simplified 70.4%

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

   if -2.6e5 < NaChar < 3.99999999999999991e-113

   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. Add Preprocessing

   5. Taylor expanded in NdChar around inf 84.2%

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

   if 3.99999999999999991e-113 < 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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 68.8%

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

4. Final simplification 76.2%

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

Alternative 8: 55.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EDonor \leq -4.8 \cdot 10^{+83} \lor \neg \left(EDonor \leq 4.5 \cdot 10^{+117}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= EDonor -4.8e+83) (not (<= EDonor 4.5e+117)))
   (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
   (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[EDonor, -4.8e+83], N[Not[LessEqual[EDonor, 4.5e+117]], $MachinePrecision]], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if EDonor < -4.79999999999999982e83 or 4.5e117 < EDonor

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around inf 69.8%

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

   6. Taylor expanded in EDonor around inf 58.7%

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

   if -4.79999999999999982e83 < EDonor < 4.5e117

   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. Add Preprocessing

   5. Taylor expanded in NdChar around inf 66.7%

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

   6. Taylor expanded in EDonor around 0 65.6%

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

4. Final simplification 63.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EDonor \leq -4.8 \cdot 10^{+83} \lor \neg \left(EDonor \leq 4.5 \cdot 10^{+117}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 44.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -9.6 \cdot 10^{+33} \lor \neg \left(Vef \leq 2.75 \cdot 10^{-14}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -9.6e+33) (not (<= Vef 2.75e-14)))
   (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
   (/ NdChar (+ 1.0 (exp (/ Ec (- KbT)))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -9.5999999999999999e33 or 2.74999999999999996e-14 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 65.9%

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

   6. Taylor expanded in Vef around inf 54.4%

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

   if -9.5999999999999999e33 < Vef < 2.74999999999999996e-14

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around inf 70.0%

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

   6. Taylor expanded in Ec around inf 50.6%

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

      1. mul-1-neg 50.6%

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

   8. Simplified 50.6%

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

4. Final simplification 52.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -9.6 \cdot 10^{+33} \lor \neg \left(Vef \leq 2.75 \cdot 10^{-14}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 44.1% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -5.1 \cdot 10^{-73} \lor \neg \left(Vef \leq 8.5 \cdot 10^{-18}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\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 -5.1e-73) (not (<= Vef 8.5e-18)))
   (/ NaChar (+ 1.0 (exp (/ Vef 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 <= -5.1e-73) || !(Vef <= 8.5e-18)) {
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	} else {
		tmp = 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 <= (-5.1d-73)) .or. (.not. (vef <= 8.5d-18))) then
        tmp = nachar / (1.0d0 + exp((vef / kbt)))
    else
        tmp = 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 <= -5.1e-73) || !(Vef <= 8.5e-18)) {
		tmp = NaChar / (1.0 + Math.exp((Vef / KbT)));
	} else {
		tmp = 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 <= -5.1e-73) or not (Vef <= 8.5e-18):
		tmp = NaChar / (1.0 + math.exp((Vef / KbT)))
	else:
		tmp = 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 <= -5.1e-73) || !(Vef <= 8.5e-18))
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	else
		tmp = 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 <= -5.1e-73) || ~((Vef <= 8.5e-18)))
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	else
		tmp = 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, -5.1e-73], N[Not[LessEqual[Vef, 8.5e-18]], $MachinePrecision]], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -5.1e-73 or 8.4999999999999995e-18 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 64.8%

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

   6. Taylor expanded in Vef around inf 51.9%

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

   if -5.1e-73 < Vef < 8.4999999999999995e-18

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around inf 72.7%

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

   6. Taylor expanded in EDonor around inf 50.5%

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

4. Final simplification 51.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -5.1 \cdot 10^{-73} \lor \neg \left(Vef \leq 8.5 \cdot 10^{-18}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 44.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -3.6 \cdot 10^{+61} \lor \neg \left(Vef \leq 3.2 \cdot 10^{+30}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -3.6e+61) (not (<= Vef 3.2e+30)))
   (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
   (/ NaChar (+ 1.0 (exp (/ 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 ((Vef <= -3.6e+61) || !(Vef <= 3.2e+30)) {
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	} else {
		tmp = NaChar / (1.0 + exp((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 ((vef <= (-3.6d+61)) .or. (.not. (vef <= 3.2d+30))) then
        tmp = nachar / (1.0d0 + exp((vef / kbt)))
    else
        tmp = nachar / (1.0d0 + exp((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 ((Vef <= -3.6e+61) || !(Vef <= 3.2e+30)) {
		tmp = NaChar / (1.0 + Math.exp((Vef / KbT)));
	} else {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -3.6e+61], N[Not[LessEqual[Vef, 3.2e+30]], $MachinePrecision]], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -3.6000000000000001e61 or 3.19999999999999973e30 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 64.4%

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

   6. Taylor expanded in Vef around inf 52.5%

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

   if -3.6000000000000001e61 < Vef < 3.19999999999999973e30

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 49.4%

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

   6. Taylor expanded in Ev around inf 37.1%

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

4. Final simplification 43.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -3.6 \cdot 10^{+61} \lor \neg \left(Vef \leq 3.2 \cdot 10^{+30}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 38.0% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 1.75 \cdot 10^{+75}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\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 1.75e+75)
   (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
   (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (EAccept <= 1.75e+75) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else {
		tmp = 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 <= 1.75d+75) then
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    else
        tmp = 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 <= 1.75e+75) {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	} else {
		tmp = 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 <= 1.75e+75:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	else:
		tmp = 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 <= 1.75e+75)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	else
		tmp = 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 <= 1.75e+75)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	else
		tmp = 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, 1.75e+75], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if EAccept < 1.7499999999999999e75

   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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 56.7%

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

   6. Taylor expanded in Ev around inf 36.2%

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

   if 1.7499999999999999e75 < 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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 51.5%

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

   6. Taylor expanded in EAccept around inf 38.2%

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

Alternative 13: 33.4% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -2.19999999999999996e44

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around inf 76.2%

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

   6. Taylor expanded in KbT around inf 35.9%

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

      1. associate-+r+ 35.9%

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

   8. Simplified 35.9%

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

   if -2.19999999999999996e44 < Ev

   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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 57.3%

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

   6. Taylor expanded in EAccept around inf 38.7%

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

4. Final simplification 38.1%

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

Alternative 14: 30.2% accurate, 6.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (/ Vef KbT) (/ mu KbT))))
   (if (<= KbT -5.8e+100)
     (-
      (/ NaChar 2.0)
      (/ NdChar (- (/ Ec KbT) (+ 2.0 (+ (/ EDonor KbT) t_0)))))
     (if (<= KbT -4e-144)
       (/ NdChar (- (+ (+ (/ EDonor KbT) 2.0) t_0) (/ Ec KbT)))
       (if (<= KbT 5e+153)
         (/
          NaChar
          (/ (- (* Vef (+ 1.0 (+ (/ EAccept Vef) (/ Ev Vef)))) mu) KbT))
         (-
          (* NdChar 0.5)
          (/
           NaChar
           (-
            (/ mu KbT)
            (+ (+ (/ Vef KbT) (/ Ev KbT)) (+ 2.0 (/ EAccept KbT)))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (Vef / KbT) + (mu / KbT);
	double tmp;
	if (KbT <= -5.8e+100) {
		tmp = (NaChar / 2.0) - (NdChar / ((Ec / KbT) - (2.0 + ((EDonor / KbT) + t_0))));
	} else if (KbT <= -4e-144) {
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + t_0) - (Ec / KbT));
	} else if (KbT <= 5e+153) {
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	} else {
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (((Vef / KbT) + (Ev / KbT)) + (2.0 + (EAccept / KbT)))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (vef / kbt) + (mu / kbt)
    if (kbt <= (-5.8d+100)) then
        tmp = (nachar / 2.0d0) - (ndchar / ((ec / kbt) - (2.0d0 + ((edonor / kbt) + t_0))))
    else if (kbt <= (-4d-144)) then
        tmp = ndchar / ((((edonor / kbt) + 2.0d0) + t_0) - (ec / kbt))
    else if (kbt <= 5d+153) then
        tmp = nachar / (((vef * (1.0d0 + ((eaccept / vef) + (ev / vef)))) - mu) / kbt)
    else
        tmp = (ndchar * 0.5d0) - (nachar / ((mu / kbt) - (((vef / kbt) + (ev / kbt)) + (2.0d0 + (eaccept / kbt)))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (Vef / KbT) + (mu / KbT);
	double tmp;
	if (KbT <= -5.8e+100) {
		tmp = (NaChar / 2.0) - (NdChar / ((Ec / KbT) - (2.0 + ((EDonor / KbT) + t_0))));
	} else if (KbT <= -4e-144) {
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + t_0) - (Ec / KbT));
	} else if (KbT <= 5e+153) {
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	} else {
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (((Vef / KbT) + (Ev / KbT)) + (2.0 + (EAccept / KbT)))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (Vef / KbT) + (mu / KbT)
	tmp = 0
	if KbT <= -5.8e+100:
		tmp = (NaChar / 2.0) - (NdChar / ((Ec / KbT) - (2.0 + ((EDonor / KbT) + t_0))))
	elif KbT <= -4e-144:
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + t_0) - (Ec / KbT))
	elif KbT <= 5e+153:
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT)
	else:
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (((Vef / KbT) + (Ev / KbT)) + (2.0 + (EAccept / KbT)))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(Vef / KbT) + Float64(mu / KbT))
	tmp = 0.0
	if (KbT <= -5.8e+100)
		tmp = Float64(Float64(NaChar / 2.0) - Float64(NdChar / Float64(Float64(Ec / KbT) - Float64(2.0 + Float64(Float64(EDonor / KbT) + t_0)))));
	elseif (KbT <= -4e-144)
		tmp = Float64(NdChar / Float64(Float64(Float64(Float64(EDonor / KbT) + 2.0) + t_0) - Float64(Ec / KbT)));
	elseif (KbT <= 5e+153)
		tmp = Float64(NaChar / Float64(Float64(Float64(Vef * Float64(1.0 + Float64(Float64(EAccept / Vef) + Float64(Ev / Vef)))) - mu) / KbT));
	else
		tmp = Float64(Float64(NdChar * 0.5) - Float64(NaChar / Float64(Float64(mu / KbT) - Float64(Float64(Float64(Vef / KbT) + Float64(Ev / KbT)) + Float64(2.0 + Float64(EAccept / KbT))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (Vef / KbT) + (mu / KbT);
	tmp = 0.0;
	if (KbT <= -5.8e+100)
		tmp = (NaChar / 2.0) - (NdChar / ((Ec / KbT) - (2.0 + ((EDonor / KbT) + t_0))));
	elseif (KbT <= -4e-144)
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + t_0) - (Ec / KbT));
	elseif (KbT <= 5e+153)
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	else
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (((Vef / KbT) + (Ev / KbT)) + (2.0 + (EAccept / KbT)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -5.8e+100], N[(N[(NaChar / 2.0), $MachinePrecision] - N[(NdChar / N[(N[(Ec / KbT), $MachinePrecision] - N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -4e-144], N[(NdChar / N[(N[(N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision] + t$95$0), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 5e+153], N[(NaChar / N[(N[(N[(Vef * N[(1.0 + N[(N[(EAccept / Vef), $MachinePrecision] + N[(Ev / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] - N[(NaChar / N[(N[(mu / KbT), $MachinePrecision] - N[(N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision] + N[(2.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -5.8000000000000001e100

   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. Add Preprocessing

   5. Taylor expanded in KbT around inf 67.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 KbT around inf 57.1%

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

   if -5.8000000000000001e100 < KbT < -3.9999999999999998e-144

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 84.2%

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

   6. Taylor expanded in KbT around inf 29.1%

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

      1. associate-+r+ 29.1%

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

   8. Simplified 29.1%

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

   if -3.9999999999999998e-144 < KbT < 5.00000000000000018e153

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 57.8%

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

   6. Taylor expanded in KbT around inf 17.6%

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

      1. associate-+r+ 17.6%

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

   8. Simplified 17.6%

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

   9. Taylor expanded in Vef around inf 20.6%

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

       1. associate-*r/ 20.6%

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

       2. metadata-eval 20.6%

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

   11. Simplified 20.6%

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

   12. Taylor expanded in KbT around 0 23.3%

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

   if 5.00000000000000018e153 < KbT

   1. Initial program 99.7%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\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.7%

      \[\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. Add Preprocessing

   5. Taylor expanded in KbT around inf 73.7%

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

   6. Taylor expanded in KbT around inf 63.6%

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

      1. associate-+r+ 63.6%

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

      2. +-commutative 63.6%

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

   8. Simplified 63.6%

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

4. Final simplification 36.5%

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

Alternative 15: 30.2% accurate, 6.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -3.6e+100)
   (* 0.5 (+ NdChar NaChar))
   (if (<= KbT -6.5e-144)
     (/
      NdChar
      (- (+ (+ (/ EDonor KbT) 2.0) (+ (/ Vef KbT) (/ mu KbT))) (/ Ec KbT)))
     (if (<= KbT 5e+153)
       (/ NaChar (/ (- (* Vef (+ 1.0 (+ (/ EAccept Vef) (/ Ev Vef)))) mu) KbT))
       (-
        (* NdChar 0.5)
        (/
         NaChar
         (-
          (/ mu KbT)
          (+ (+ (/ Vef KbT) (/ Ev KbT)) (+ 2.0 (/ EAccept KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -3.6e+100) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (KbT <= -6.5e-144) {
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + ((Vef / KbT) + (mu / KbT))) - (Ec / KbT));
	} else if (KbT <= 5e+153) {
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	} else {
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (((Vef / KbT) + (Ev / KbT)) + (2.0 + (EAccept / KbT)))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (kbt <= (-3.6d+100)) then
        tmp = 0.5d0 * (ndchar + nachar)
    else if (kbt <= (-6.5d-144)) then
        tmp = ndchar / ((((edonor / kbt) + 2.0d0) + ((vef / kbt) + (mu / kbt))) - (ec / kbt))
    else if (kbt <= 5d+153) then
        tmp = nachar / (((vef * (1.0d0 + ((eaccept / vef) + (ev / vef)))) - mu) / kbt)
    else
        tmp = (ndchar * 0.5d0) - (nachar / ((mu / kbt) - (((vef / kbt) + (ev / kbt)) + (2.0d0 + (eaccept / kbt)))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -3.6e+100) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (KbT <= -6.5e-144) {
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + ((Vef / KbT) + (mu / KbT))) - (Ec / KbT));
	} else if (KbT <= 5e+153) {
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	} else {
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (((Vef / KbT) + (Ev / KbT)) + (2.0 + (EAccept / KbT)))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -3.6e+100:
		tmp = 0.5 * (NdChar + NaChar)
	elif KbT <= -6.5e-144:
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + ((Vef / KbT) + (mu / KbT))) - (Ec / KbT))
	elif KbT <= 5e+153:
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT)
	else:
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (((Vef / KbT) + (Ev / KbT)) + (2.0 + (EAccept / KbT)))))
	return tmp

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -3.6e+100)
		tmp = 0.5 * (NdChar + NaChar);
	elseif (KbT <= -6.5e-144)
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + ((Vef / KbT) + (mu / KbT))) - (Ec / KbT));
	elseif (KbT <= 5e+153)
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	else
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (((Vef / KbT) + (Ev / KbT)) + (2.0 + (EAccept / KbT)))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -3.6e100

   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. Add Preprocessing

   5. Taylor expanded in KbT around inf 56.0%

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

      1. distribute-lft-out 56.0%

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

   7. Simplified 56.0%

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

   if -3.6e100 < KbT < -6.49999999999999968e-144

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 84.2%

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

   6. Taylor expanded in KbT around inf 29.1%

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

      1. associate-+r+ 29.1%

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

   8. Simplified 29.1%

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

   if -6.49999999999999968e-144 < KbT < 5.00000000000000018e153

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 57.8%

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

   6. Taylor expanded in KbT around inf 17.6%

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

      1. associate-+r+ 17.6%

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

   8. Simplified 17.6%

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

   9. Taylor expanded in Vef around inf 20.6%

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

       1. associate-*r/ 20.6%

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

       2. metadata-eval 20.6%

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

   11. Simplified 20.6%

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

   12. Taylor expanded in KbT around 0 23.3%

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

   if 5.00000000000000018e153 < KbT

   1. Initial program 99.7%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\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.7%

      \[\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. Add Preprocessing

   5. Taylor expanded in KbT around inf 73.7%

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

   6. Taylor expanded in KbT around inf 63.6%

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

      1. associate-+r+ 63.6%

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

      2. +-commutative 63.6%

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

   8. Simplified 63.6%

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

4. Final simplification 36.2%

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

Alternative 16: 31.0% accurate, 6.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (/ Vef KbT) (/ Ev KbT))))
   (if (<= KbT -1.35e+110)
     (-
      (/ NaChar 2.0)
      (/
       NdChar
       (- (/ Ec KbT) (+ 2.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT)))))))
     (if (<= KbT 5e+153)
       (/
        NaChar
        (- (* EAccept (+ (/ (+ 2.0 t_0) EAccept) (/ 1.0 KbT))) (/ mu KbT)))
       (-
        (* NdChar 0.5)
        (/ NaChar (- (/ mu KbT) (+ t_0 (+ 2.0 (/ EAccept KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (Vef / KbT) + (Ev / KbT);
	double tmp;
	if (KbT <= -1.35e+110) {
		tmp = (NaChar / 2.0) - (NdChar / ((Ec / KbT) - (2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))))));
	} else if (KbT <= 5e+153) {
		tmp = NaChar / ((EAccept * (((2.0 + t_0) / EAccept) + (1.0 / KbT))) - (mu / KbT));
	} else {
		tmp = (NdChar * 0.5) - (NaChar / ((mu / KbT) - (t_0 + (2.0 + (EAccept / KbT)))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.35000000000000005e110

   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. Add Preprocessing

   5. Taylor expanded in KbT around inf 67.9%

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

   6. Taylor expanded in KbT around inf 57.3%

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

   if -1.35000000000000005e110 < KbT < 5.00000000000000018e153

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 55.3%

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

   6. Taylor expanded in KbT around inf 18.7%

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

      1. associate-+r+ 18.7%

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

   8. Simplified 18.7%

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

   9. Taylor expanded in EAccept around -inf 22.2%

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

   if 5.00000000000000018e153 < KbT

   1. Initial program 99.7%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\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.7%

      \[\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. Add Preprocessing

   5. Taylor expanded in KbT around inf 73.7%

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

   6. Taylor expanded in KbT around inf 63.6%

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

      1. associate-+r+ 63.6%

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

      2. +-commutative 63.6%

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

   8. Simplified 63.6%

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

4. Final simplification 34.4%

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

Alternative 17: 27.3% accurate, 6.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ec -3.2e-63)
   (/
    NaChar
    (*
     Vef
     (+
      (/ 1.0 KbT)
      (+ (/ 2.0 Vef) (+ (/ (/ EAccept KbT) Vef) (/ Ev (* Vef KbT)))))))
   (if (<= Ec 4.8e+172)
     (* 0.5 (+ NdChar NaChar))
     (/
      NaChar
      (-
       (- (+ 2.0 (/ EAccept KbT)) (* Ev (- (/ -1.0 KbT) (/ (/ Vef Ev) KbT))))
       (/ mu KbT))))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Ec <= -3.2e-63:
		tmp = NaChar / (Vef * ((1.0 / KbT) + ((2.0 / Vef) + (((EAccept / KbT) / Vef) + (Ev / (Vef * KbT))))))
	elif Ec <= 4.8e+172:
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / (((2.0 + (EAccept / KbT)) - (Ev * ((-1.0 / KbT) - ((Vef / Ev) / KbT)))) - (mu / KbT))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ec < -3.19999999999999989e-63

   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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 64.8%

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

   6. Taylor expanded in KbT around inf 33.4%

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

      1. associate-+r+ 33.4%

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

   8. Simplified 33.4%

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

   9. Taylor expanded in Vef around inf 38.5%

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

       1. associate-*r/ 38.5%

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

       2. metadata-eval 38.5%

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

   11. Simplified 38.5%

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

   12. Taylor expanded in mu around 0 38.8%

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

       1. associate-+r+ 38.8%

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

       2. +-commutative 38.8%

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

       3. associate-*r/ 38.8%

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

       4. metadata-eval 38.8%

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

       5. associate-+l+ 38.8%

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

       6. associate-/r* 38.9%

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

       7. *-commutative 38.9%

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

   14. Simplified 38.9%

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

   if -3.19999999999999989e-63 < Ec < 4.8000000000000001e172

   1. Initial program 100.0%

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

   5. Taylor expanded in KbT around inf 31.0%

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

      1. distribute-lft-out 31.0%

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

   7. Simplified 31.0%

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

   if 4.8000000000000001e172 < Ec

   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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 69.8%

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

   6. Taylor expanded in KbT around inf 41.5%

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

      1. associate-+r+ 41.5%

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

   8. Simplified 41.5%

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

   9. Taylor expanded in Ev around inf 47.0%

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

       1. associate-/r* 49.9%

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

   11. Simplified 49.9%

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

4. Final simplification 34.8%

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

Alternative 18: 30.3% accurate, 7.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{if}\;KbT \leq -5.2 \cdot 10^{+103}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq -6.5 \cdot 10^{-144}:\\ \;\;\;\;\frac{NdChar}{\left(\left(\frac{EDonor}{KbT} + 2\right) + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq 5 \cdot 10^{+153}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef \cdot \left(1 + \left(\frac{EAccept}{Vef} + \frac{Ev}{Vef}\right)\right) - 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 (* 0.5 (+ NdChar NaChar))))
   (if (<= KbT -5.2e+103)
     t_0
     (if (<= KbT -6.5e-144)
       (/
        NdChar
        (- (+ (+ (/ EDonor KbT) 2.0) (+ (/ Vef KbT) (/ mu KbT))) (/ Ec KbT)))
       (if (<= KbT 5e+153)
         (/
          NaChar
          (/ (- (* Vef (+ 1.0 (+ (/ EAccept Vef) (/ Ev Vef)))) 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 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -5.2e+103) {
		tmp = t_0;
	} else if (KbT <= -6.5e-144) {
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + ((Vef / KbT) + (mu / KbT))) - (Ec / KbT));
	} else if (KbT <= 5e+153) {
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - 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) :: tmp
    t_0 = 0.5d0 * (ndchar + nachar)
    if (kbt <= (-5.2d+103)) then
        tmp = t_0
    else if (kbt <= (-6.5d-144)) then
        tmp = ndchar / ((((edonor / kbt) + 2.0d0) + ((vef / kbt) + (mu / kbt))) - (ec / kbt))
    else if (kbt <= 5d+153) then
        tmp = nachar / (((vef * (1.0d0 + ((eaccept / vef) + (ev / vef)))) - 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 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -5.2e+103) {
		tmp = t_0;
	} else if (KbT <= -6.5e-144) {
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + ((Vef / KbT) + (mu / KbT))) - (Ec / KbT));
	} else if (KbT <= 5e+153) {
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 0.5 * (NdChar + NaChar)
	tmp = 0
	if KbT <= -5.2e+103:
		tmp = t_0
	elif KbT <= -6.5e-144:
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + ((Vef / KbT) + (mu / KbT))) - (Ec / KbT))
	elif KbT <= 5e+153:
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT)
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(0.5 * Float64(NdChar + NaChar))
	tmp = 0.0
	if (KbT <= -5.2e+103)
		tmp = t_0;
	elseif (KbT <= -6.5e-144)
		tmp = Float64(NdChar / Float64(Float64(Float64(Float64(EDonor / KbT) + 2.0) + Float64(Float64(Vef / KbT) + Float64(mu / KbT))) - Float64(Ec / KbT)));
	elseif (KbT <= 5e+153)
		tmp = Float64(NaChar / Float64(Float64(Float64(Vef * Float64(1.0 + Float64(Float64(EAccept / Vef) + Float64(Ev / Vef)))) - 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 = 0.5 * (NdChar + NaChar);
	tmp = 0.0;
	if (KbT <= -5.2e+103)
		tmp = t_0;
	elseif (KbT <= -6.5e-144)
		tmp = NdChar / ((((EDonor / KbT) + 2.0) + ((Vef / KbT) + (mu / KbT))) - (Ec / KbT));
	elseif (KbT <= 5e+153)
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - 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[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -5.2e+103], t$95$0, If[LessEqual[KbT, -6.5e-144], N[(NdChar / N[(N[(N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 5e+153], N[(NaChar / N[(N[(N[(Vef * N[(1.0 + N[(N[(EAccept / Vef), $MachinePrecision] + N[(Ev / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -5.2000000000000003e103 or 5.00000000000000018e153 < KbT

   1. Initial program 99.8%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\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.8%

      \[\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. Add Preprocessing

   5. Taylor expanded in KbT around inf 59.0%

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

      1. distribute-lft-out 59.0%

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

   7. Simplified 59.0%

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

   if -5.2000000000000003e103 < KbT < -6.49999999999999968e-144

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 84.2%

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

   6. Taylor expanded in KbT around inf 29.1%

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

      1. associate-+r+ 29.1%

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

   8. Simplified 29.1%

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

   if -6.49999999999999968e-144 < KbT < 5.00000000000000018e153

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 57.8%

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

   6. Taylor expanded in KbT around inf 17.6%

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

      1. associate-+r+ 17.6%

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

   8. Simplified 17.6%

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

   9. Taylor expanded in Vef around inf 20.6%

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

       1. associate-*r/ 20.6%

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

       2. metadata-eval 20.6%

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

   11. Simplified 20.6%

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

   12. Taylor expanded in KbT around 0 23.3%

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

4. Final simplification 36.2%

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

Alternative 19: 30.8% accurate, 8.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -3.8 \cdot 10^{-40} \lor \neg \left(KbT \leq 5 \cdot 10^{+153}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef \cdot \left(1 + \left(\frac{EAccept}{Vef} + \frac{Ev}{Vef}\right)\right) - mu}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -3.8e-40) (not (<= KbT 5e+153)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (/ (- (* Vef (+ 1.0 (+ (/ EAccept Vef) (/ Ev Vef)))) mu) KbT))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -3.8e-40) || !(KbT <= 5e+153)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -3.8e-40) || !(KbT <= 5e+153)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -3.8e-40) or not (KbT <= 5e+153):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -3.8e-40) || !(KbT <= 5e+153))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar / Float64(Float64(Float64(Vef * Float64(1.0 + Float64(Float64(EAccept / Vef) + Float64(Ev / Vef)))) - mu) / KbT));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -3.8e-40) || ~((KbT <= 5e+153)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar / (((Vef * (1.0 + ((EAccept / Vef) + (Ev / Vef)))) - mu) / KbT);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -3.8e-40], N[Not[LessEqual[KbT, 5e+153]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[(N[(Vef * N[(1.0 + N[(N[(EAccept / Vef), $MachinePrecision] + N[(Ev / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -3.7999999999999999e-40 or 5.00000000000000018e153 < 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. Add Preprocessing

   5. Taylor expanded in KbT around inf 49.3%

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

      1. distribute-lft-out 49.3%

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

   7. Simplified 49.3%

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

   if -3.7999999999999999e-40 < KbT < 5.00000000000000018e153

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 55.8%

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

   6. Taylor expanded in KbT around inf 17.0%

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

      1. associate-+r+ 17.0%

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

   8. Simplified 17.0%

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

   9. Taylor expanded in Vef around inf 19.6%

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

       1. associate-*r/ 19.6%

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

       2. metadata-eval 19.6%

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

   11. Simplified 19.6%

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

   12. Taylor expanded in KbT around 0 22.0%

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

4. Final simplification 33.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.8 \cdot 10^{-40} \lor \neg \left(KbT \leq 5 \cdot 10^{+153}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef \cdot \left(1 + \left(\frac{EAccept}{Vef} + \frac{Ev}{Vef}\right)\right) - mu}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 20: 29.7% accurate, 10.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -7.6 \cdot 10^{-154} \lor \neg \left(KbT \leq 2.3 \cdot 10^{-178}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{Vef \cdot \frac{1}{KbT} - \frac{mu}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -7.6e-154) (not (<= KbT 2.3e-178)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (- (* Vef (/ 1.0 KbT)) (/ mu KbT)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -7.6e-154) || !(KbT <= 2.3e-178)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / ((Vef * (1.0 / KbT)) - (mu / KbT));
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -7.6e-154) || !(KbT <= 2.3e-178)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / ((Vef * (1.0 / KbT)) - (mu / KbT));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -7.6e-154) or not (KbT <= 2.3e-178):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / ((Vef * (1.0 / KbT)) - (mu / KbT))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -7.6e-154) || !(KbT <= 2.3e-178))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar / Float64(Float64(Vef * Float64(1.0 / KbT)) - Float64(mu / KbT)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -7.6e-154) || ~((KbT <= 2.3e-178)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar / ((Vef * (1.0 / KbT)) - (mu / KbT));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -7.6e-154], N[Not[LessEqual[KbT, 2.3e-178]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[(Vef * N[(1.0 / KbT), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -7.60000000000000019e-154 or 2.29999999999999994e-178 < 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. Add Preprocessing

   5. Taylor expanded in KbT around inf 33.3%

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

      1. distribute-lft-out 33.3%

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

   7. Simplified 33.3%

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

   if -7.60000000000000019e-154 < KbT < 2.29999999999999994e-178

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 61.1%

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

   6. Taylor expanded in KbT around inf 23.2%

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

      1. associate-+r+ 23.2%

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

   8. Simplified 23.2%

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

   9. Taylor expanded in Vef around inf 27.4%

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

       1. associate-*r/ 27.4%

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

       2. metadata-eval 27.4%

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

   11. Simplified 27.4%

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

   12. Taylor expanded in Vef around inf 29.9%

       \[\leadsto \frac{NaChar}{Vef \cdot \color{blue}{\frac{1}{KbT}} - \frac{mu}{KbT}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 32.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -7.6 \cdot 10^{-154} \lor \neg \left(KbT \leq 2.3 \cdot 10^{-178}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{Vef \cdot \frac{1}{KbT} - \frac{mu}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 21: 28.9% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.1 \cdot 10^{-152} \lor \neg \left(KbT \leq 3.8 \cdot 10^{-186}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT}}\\ \end{array} \end{array} \]

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -1.1e-152) or not (KbT <= 3.8e-186):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / (Ev / KbT)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -1.1e-152) || !(KbT <= 3.8e-186))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar / 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 ((KbT <= -1.1e-152) || ~((KbT <= 3.8e-186)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar / (Ev / KbT);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -1.1e-152], N[Not[LessEqual[KbT, 3.8e-186]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -1.09999999999999992e-152 or 3.79999999999999974e-186 < 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. Add Preprocessing

   5. Taylor expanded in KbT around inf 33.5%

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

      1. distribute-lft-out 33.5%

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

   7. Simplified 33.5%

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

   if -1.09999999999999992e-152 < KbT < 3.79999999999999974e-186

   1. Initial program 100.0%

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

   5. Taylor expanded in NdChar around 0 61.7%

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

   6. Taylor expanded in KbT around inf 24.4%

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

      1. associate-+r+ 24.4%

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

   8. Simplified 24.4%

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

   9. Taylor expanded in Ev around inf 28.0%

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

4. Final simplification 32.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.1 \cdot 10^{-152} \lor \neg \left(KbT \leq 3.8 \cdot 10^{-186}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 22: 28.8% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -5 \cdot 10^{+222} \lor \neg \left(Vef \leq 6.4 \cdot 10^{+247}\right):\\ \;\;\;\;KbT \cdot \frac{NaChar}{Vef}\\ \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 (or (<= Vef -5e+222) (not (<= Vef 6.4e+247)))
   (* KbT (/ NaChar Vef))
   (* 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+222) || !(Vef <= 6.4e+247)) {
		tmp = KbT * (NaChar / Vef);
	} 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+222)) .or. (.not. (vef <= 6.4d+247))) then
        tmp = kbt * (nachar / vef)
    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+222) || !(Vef <= 6.4e+247)) {
		tmp = KbT * (NaChar / Vef);
	} 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+222) or not (Vef <= 6.4e+247):
		tmp = KbT * (NaChar / Vef)
	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+222) || !(Vef <= 6.4e+247))
		tmp = Float64(KbT * Float64(NaChar / Vef));
	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+222) || ~((Vef <= 6.4e+247)))
		tmp = KbT * (NaChar / Vef);
	else
		tmp = 0.5 * (NdChar + NaChar);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -5e+222], N[Not[LessEqual[Vef, 6.4e+247]], $MachinePrecision]], N[(KbT * N[(NaChar / Vef), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -5.00000000000000023e222 or 6.40000000000000044e247 < 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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 75.9%

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

   6. Taylor expanded in KbT around inf 31.3%

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

      1. associate-+r+ 31.3%

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

   8. Simplified 31.3%

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

   9. Taylor expanded in Vef around inf 40.2%

      \[\leadsto \color{blue}{\frac{KbT \cdot NaChar}{Vef}} \]
   10. Step-by-step derivation

       1. associate-/l* 41.9%

          \[\leadsto \color{blue}{KbT \cdot \frac{NaChar}{Vef}} \]

   11. Simplified 41.9%

       \[\leadsto \color{blue}{KbT \cdot \frac{NaChar}{Vef}} \]

   if -5.00000000000000023e222 < Vef < 6.40000000000000044e247

   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. Add Preprocessing

   5. Taylor expanded in KbT around inf 29.9%

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

      1. distribute-lft-out 29.9%

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

   7. Simplified 29.9%

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

4. Final simplification 31.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -5 \cdot 10^{+222} \lor \neg \left(Vef \leq 6.4 \cdot 10^{+247}\right):\\ \;\;\;\;KbT \cdot \frac{NaChar}{Vef}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 23: 28.1% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -6 \cdot 10^{-157} \lor \neg \left(KbT \leq 9.5 \cdot 10^{-180}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;KbT \cdot \frac{NaChar}{EAccept}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -6e-157) (not (<= KbT 9.5e-180)))
   (* 0.5 (+ NdChar NaChar))
   (* KbT (/ NaChar EAccept))))

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 <= -6e-157) || !(KbT <= 9.5e-180)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = KbT * (NaChar / EAccept);
	}
	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 <= (-6d-157)) .or. (.not. (kbt <= 9.5d-180))) then
        tmp = 0.5d0 * (ndchar + nachar)
    else
        tmp = kbt * (nachar / eaccept)
    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 <= -6e-157) || !(KbT <= 9.5e-180)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = KbT * (NaChar / EAccept);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -6e-157) or not (KbT <= 9.5e-180):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = KbT * (NaChar / EAccept)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -6e-157) || !(KbT <= 9.5e-180))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(KbT * Float64(NaChar / EAccept));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -6e-157) || ~((KbT <= 9.5e-180)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = KbT * (NaChar / EAccept);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -6e-157], N[Not[LessEqual[KbT, 9.5e-180]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(KbT * N[(NaChar / EAccept), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -6e-157 or 9.49999999999999934e-180 < 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. Add Preprocessing

   5. Taylor expanded in KbT around inf 33.3%

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

      1. distribute-lft-out 33.3%

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

   7. Simplified 33.3%

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

   if -6e-157 < KbT < 9.49999999999999934e-180

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 61.1%

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

   6. Taylor expanded in KbT around inf 23.2%

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

      1. associate-+r+ 23.2%

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

   8. Simplified 23.2%

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

   9. Taylor expanded in EAccept around inf 25.5%

      \[\leadsto \color{blue}{\frac{KbT \cdot NaChar}{EAccept}} \]
   10. Step-by-step derivation

       1. associate-/l* 23.7%

          \[\leadsto \color{blue}{KbT \cdot \frac{NaChar}{EAccept}} \]

   11. Simplified 23.7%

       \[\leadsto \color{blue}{KbT \cdot \frac{NaChar}{EAccept}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 31.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -6 \cdot 10^{-157} \lor \neg \left(KbT \leq 9.5 \cdot 10^{-180}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;KbT \cdot \frac{NaChar}{EAccept}\\ \end{array} \]
5. Add Preprocessing

Alternative 24: 22.9% accurate, 17.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -360000 \lor \neg \left(NaChar \leq 7.8 \cdot 10^{+65}\right):\\ \;\;\;\;\frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -360000.0) || !(NaChar <= 7.8e+65)) {
		tmp = NaChar / 2.0;
	} else {
		tmp = 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 ((nachar <= (-360000.0d0)) .or. (.not. (nachar <= 7.8d+65))) then
        tmp = nachar / 2.0d0
    else
        tmp = 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 ((NaChar <= -360000.0) || !(NaChar <= 7.8e+65)) {
		tmp = NaChar / 2.0;
	} else {
		tmp = NdChar * 0.5;
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -3.6e5 or 7.7999999999999996e65 < 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. Add Preprocessing

   5. Taylor expanded in NdChar around 0 71.2%

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

   6. Taylor expanded in KbT around inf 31.4%

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

   if -3.6e5 < NaChar < 7.7999999999999996e65

   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. Add Preprocessing

   5. Taylor expanded in KbT around inf 25.0%

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

      1. distribute-lft-out 25.0%

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

   7. Simplified 25.0%

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

   8. Taylor expanded in NaChar around 0 25.5%

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

4. Final simplification 27.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -360000 \lor \neg \left(NaChar \leq 7.8 \cdot 10^{+65}\right):\\ \;\;\;\;\frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 25: 27.4% 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 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. Add Preprocessing

5. Taylor expanded in KbT around inf 27.3%

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

   1. distribute-lft-out 27.3%

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

7. Simplified 27.3%

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

8. Final simplification 27.3%

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

Alternative 26: 18.2% 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 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. Add Preprocessing

5. Taylor expanded in KbT around inf 27.3%

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

   1. distribute-lft-out 27.3%

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

7. Simplified 27.3%

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

8. Taylor expanded in NaChar around 0 19.9%

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

9. Final simplification 19.9%

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

Reproduce

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