Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 21.1s

Alternatives: 21

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

Alternative 2: 76.9% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))))
   (if (<= Vef -3.7e+101)
     t_1
     (if (<= Vef -2020000.0)
       (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
       (if (<= Vef 6e+98)
         (+ t_0 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	double tmp;
	if (Vef <= -3.7e+101) {
		tmp = t_1;
	} else if (Vef <= -2020000.0) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	} else if (Vef <= 6e+98) {
		tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT))))
	tmp = 0
	if Vef <= -3.7e+101:
		tmp = t_1
	elif Vef <= -2020000.0:
		tmp = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)))
	elif Vef <= 6e+98:
		tmp = t_0 + (NaChar / (1.0 + math.exp((-mu / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	tmp = 0.0
	if (Vef <= -3.7e+101)
		tmp = t_1;
	elseif (Vef <= -2020000.0)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))));
	elseif (Vef <= 6e+98)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	tmp = 0.0;
	if (Vef <= -3.7e+101)
		tmp = t_1;
	elseif (Vef <= -2020000.0)
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	elseif (Vef <= 6e+98)
		tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Vef < -3.6999999999999997e101 or 6.0000000000000003e98 < 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 Vef around inf 90.7%

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

   if -3.6999999999999997e101 < Vef < -2.02e6

   1. Initial program 100.0%

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

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

   if -2.02e6 < Vef < 6.0000000000000003e98

   1. Initial program 100.0%

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

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

      1. associate-*r/ 79.7%

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

      2. mul-1-neg 79.7%

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

   7. Simplified 79.7%

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

4. Final simplification 84.2%

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

Alternative 3: 70.0% accurate, 1.0× speedup

Math

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -6.4000000000000001e-99 or 1.25e-20 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 75.4%

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

   if -6.4000000000000001e-99 < NdChar < 1.64999999999999997e-223

   1. Initial program 100.0%

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

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

   if 1.64999999999999997e-223 < NdChar < 1.25e-20

   1. Initial program 100.0%

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

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

4. Final simplification 78.7%

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

Alternative 4: 72.4% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < -5.19999999999999998e-126

   1. Initial program 100.0%

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

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

   if -5.19999999999999998e-126 < EAccept < 6.99999999999999949e147

   1. Initial program 100.0%

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

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

   if 6.99999999999999949e147 < 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 EAccept around inf 100.0%

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

4. Final simplification 73.9%

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

Alternative 5: 43.8% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -3.75 \cdot 10^{+102}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -1720000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Vef \leq -1.55 \cdot 10^{-227}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 7.5 \cdot 10^{-208}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq 9 \cdot 10^{-115}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 4.2 \cdot 10^{+33}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -3.75e+102)
     t_1
     (if (<= Vef -1720000.0)
       (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
       (if (<= Vef -1.55e-227)
         t_0
         (if (<= Vef 7.5e-208)
           (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
           (if (<= Vef 9e-115)
             t_0
             (if (<= Vef 4.2e+33)
               (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
               t_1))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((mu / KbT)));
	double t_1 = NdChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -3.75e+102) {
		tmp = t_1;
	} else if (Vef <= -1720000.0) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else if (Vef <= -1.55e-227) {
		tmp = t_0;
	} else if (Vef <= 7.5e-208) {
		tmp = NaChar / (1.0 + exp((-mu / KbT)));
	} else if (Vef <= 9e-115) {
		tmp = t_0;
	} else if (Vef <= 4.2e+33) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((mu / kbt)))
    t_1 = ndchar / (1.0d0 + exp((vef / kbt)))
    if (vef <= (-3.75d+102)) then
        tmp = t_1
    else if (vef <= (-1720000.0d0)) then
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    else if (vef <= (-1.55d-227)) then
        tmp = t_0
    else if (vef <= 7.5d-208) then
        tmp = nachar / (1.0d0 + exp((-mu / kbt)))
    else if (vef <= 9d-115) then
        tmp = t_0
    else if (vef <= 4.2d+33) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (Vef <= -3.75e+102) {
		tmp = t_1;
	} else if (Vef <= -1720000.0) {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	} else if (Vef <= -1.55e-227) {
		tmp = t_0;
	} else if (Vef <= 7.5e-208) {
		tmp = NaChar / (1.0 + Math.exp((-mu / KbT)));
	} else if (Vef <= 9e-115) {
		tmp = t_0;
	} else if (Vef <= 4.2e+33) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((mu / KbT)))
	t_1 = NdChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if Vef <= -3.75e+102:
		tmp = t_1
	elif Vef <= -1720000.0:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	elif Vef <= -1.55e-227:
		tmp = t_0
	elif Vef <= 7.5e-208:
		tmp = NaChar / (1.0 + math.exp((-mu / KbT)))
	elif Vef <= 9e-115:
		tmp = t_0
	elif Vef <= 4.2e+33:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -3.75e+102)
		tmp = t_1;
	elseif (Vef <= -1720000.0)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	elseif (Vef <= -1.55e-227)
		tmp = t_0;
	elseif (Vef <= 7.5e-208)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))));
	elseif (Vef <= 9e-115)
		tmp = t_0;
	elseif (Vef <= 4.2e+33)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((mu / KbT)));
	t_1 = NdChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -3.75e+102)
		tmp = t_1;
	elseif (Vef <= -1720000.0)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	elseif (Vef <= -1.55e-227)
		tmp = t_0;
	elseif (Vef <= 7.5e-208)
		tmp = NaChar / (1.0 + exp((-mu / KbT)));
	elseif (Vef <= 9e-115)
		tmp = t_0;
	elseif (Vef <= 4.2e+33)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.75e+102], t$95$1, If[LessEqual[Vef, -1720000.0], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -1.55e-227], t$95$0, If[LessEqual[Vef, 7.5e-208], N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 9e-115], t$95$0, If[LessEqual[Vef, 4.2e+33], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if Vef < -3.75e102 or 4.2000000000000001e33 < 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 mu around inf 65.9%

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

      1. associate-*r/ 65.9%

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

      2. mul-1-neg 65.9%

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

   7. Simplified 65.9%

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

   8. Taylor expanded in NdChar around inf 75.3%

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

   10. Simplified 75.3%

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

   11. Taylor expanded in Vef around inf 60.8%

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

   if -3.75e102 < Vef < -1.72e6

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 61.8%

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

   if -1.72e6 < Vef < -1.5499999999999999e-227 or 7.4999999999999999e-208 < Vef < 9.00000000000000046e-115

   1. Initial program 100.0%

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

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

      1. associate-*r/ 80.7%

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

      2. mul-1-neg 80.7%

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

   7. Simplified 80.7%

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

   8. Taylor expanded in NdChar around inf 71.9%

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

   10. Simplified 71.9%

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

   11. Taylor expanded in mu around inf 55.1%

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

   if -1.5499999999999999e-227 < Vef < 7.4999999999999999e-208

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 80.7%

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

      1. associate-*r/ 80.7%

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

      2. mul-1-neg 80.7%

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

   7. Simplified 80.7%

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

   8. Taylor expanded in NdChar around 0 50.4%

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

      1. mul-1-neg 50.4%

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

      2. distribute-frac-neg 50.4%

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

   10. Simplified 50.4%

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

   if 9.00000000000000046e-115 < Vef < 4.2000000000000001e33

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EAccept around inf 52.4%

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

Alternative 6: 44.1% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -2.3 \cdot 10^{+102}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;Vef \leq -400000000:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -3.8 \cdot 10^{-226}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 3.7 \cdot 10^{-210}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq 1.9 \cdot 10^{-106}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 1.45 \cdot 10^{+33}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -2.3e+102)
     t_2
     (if (<= Vef -400000000.0)
       t_1
       (if (<= Vef -3.8e-226)
         t_0
         (if (<= Vef 3.7e-210)
           t_1
           (if (<= Vef 1.9e-106)
             t_0
             (if (<= Vef 1.45e+33)
               (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
               t_2))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((EDonor / KbT)));
	double t_1 = NaChar / (1.0 + exp((Ev / KbT)));
	double t_2 = NdChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -2.3e+102) {
		tmp = t_2;
	} else if (Vef <= -400000000.0) {
		tmp = t_1;
	} else if (Vef <= -3.8e-226) {
		tmp = t_0;
	} else if (Vef <= 3.7e-210) {
		tmp = t_1;
	} else if (Vef <= 1.9e-106) {
		tmp = t_0;
	} else if (Vef <= 1.45e+33) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((edonor / kbt)))
    t_1 = nachar / (1.0d0 + exp((ev / kbt)))
    t_2 = ndchar / (1.0d0 + exp((vef / kbt)))
    if (vef <= (-2.3d+102)) then
        tmp = t_2
    else if (vef <= (-400000000.0d0)) then
        tmp = t_1
    else if (vef <= (-3.8d-226)) then
        tmp = t_0
    else if (vef <= 3.7d-210) then
        tmp = t_1
    else if (vef <= 1.9d-106) then
        tmp = t_0
    else if (vef <= 1.45d+33) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((Ev / KbT)));
	double t_2 = NdChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (Vef <= -2.3e+102) {
		tmp = t_2;
	} else if (Vef <= -400000000.0) {
		tmp = t_1;
	} else if (Vef <= -3.8e-226) {
		tmp = t_0;
	} else if (Vef <= 3.7e-210) {
		tmp = t_1;
	} else if (Vef <= 1.9e-106) {
		tmp = t_0;
	} else if (Vef <= 1.45e+33) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((EDonor / KbT)))
	t_1 = NaChar / (1.0 + math.exp((Ev / KbT)))
	t_2 = NdChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if Vef <= -2.3e+102:
		tmp = t_2
	elif Vef <= -400000000.0:
		tmp = t_1
	elif Vef <= -3.8e-226:
		tmp = t_0
	elif Vef <= 3.7e-210:
		tmp = t_1
	elif Vef <= 1.9e-106:
		tmp = t_0
	elif Vef <= 1.45e+33:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -2.3e+102)
		tmp = t_2;
	elseif (Vef <= -400000000.0)
		tmp = t_1;
	elseif (Vef <= -3.8e-226)
		tmp = t_0;
	elseif (Vef <= 3.7e-210)
		tmp = t_1;
	elseif (Vef <= 1.9e-106)
		tmp = t_0;
	elseif (Vef <= 1.45e+33)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((EDonor / KbT)));
	t_1 = NaChar / (1.0 + exp((Ev / KbT)));
	t_2 = NdChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -2.3e+102)
		tmp = t_2;
	elseif (Vef <= -400000000.0)
		tmp = t_1;
	elseif (Vef <= -3.8e-226)
		tmp = t_0;
	elseif (Vef <= 3.7e-210)
		tmp = t_1;
	elseif (Vef <= 1.9e-106)
		tmp = t_0;
	elseif (Vef <= 1.45e+33)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -2.3e+102], t$95$2, If[LessEqual[Vef, -400000000.0], t$95$1, If[LessEqual[Vef, -3.8e-226], t$95$0, If[LessEqual[Vef, 3.7e-210], t$95$1, If[LessEqual[Vef, 1.9e-106], t$95$0, If[LessEqual[Vef, 1.45e+33], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -2.2999999999999999e102 or 1.45000000000000012e33 < 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 mu around inf 65.9%

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

      1. associate-*r/ 65.9%

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

      2. mul-1-neg 65.9%

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

   7. Simplified 65.9%

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

   8. Taylor expanded in NdChar around inf 75.3%

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

   10. Simplified 75.3%

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

   11. Taylor expanded in Vef around inf 60.8%

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

   if -2.2999999999999999e102 < Vef < -4e8 or -3.79999999999999981e-226 < Vef < 3.7000000000000003e-210

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

   if -4e8 < Vef < -3.79999999999999981e-226 or 3.7000000000000003e-210 < Vef < 1.9e-106

   1. Initial program 100.0%

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

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

   6. Taylor expanded in NdChar around inf 51.8%

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

   if 1.9e-106 < Vef < 1.45000000000000012e33

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EAccept around inf 52.4%

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

Alternative 7: 43.1% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -7.5 \cdot 10^{+106}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq -1260000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.7 \cdot 10^{-116}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq 2.2 \cdot 10^{+34}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{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 (/ Vef KbT))))))
   (if (<= Vef -7.5e+106)
     t_0
     (if (<= Vef -1260000.0)
       (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
       (if (<= Vef 1.7e-116)
         (/ NdChar (+ 1.0 (exp (/ mu KbT))))
         (if (<= Vef 2.2e+34)
           (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
           t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -7.5e+106) {
		tmp = t_0;
	} else if (Vef <= -1260000.0) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else if (Vef <= 1.7e-116) {
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	} else if (Vef <= 2.2e+34) {
		tmp = NaChar / (1.0 + exp((EAccept / 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((vef / kbt)))
    if (vef <= (-7.5d+106)) then
        tmp = t_0
    else if (vef <= (-1260000.0d0)) then
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    else if (vef <= 1.7d-116) then
        tmp = ndchar / (1.0d0 + exp((mu / kbt)))
    else if (vef <= 2.2d+34) then
        tmp = nachar / (1.0d0 + exp((eaccept / 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((Vef / KbT)));
	double tmp;
	if (Vef <= -7.5e+106) {
		tmp = t_0;
	} else if (Vef <= -1260000.0) {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	} else if (Vef <= 1.7e-116) {
		tmp = NdChar / (1.0 + Math.exp((mu / KbT)));
	} else if (Vef <= 2.2e+34) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / 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((Vef / KbT)))
	tmp = 0
	if Vef <= -7.5e+106:
		tmp = t_0
	elif Vef <= -1260000.0:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	elif Vef <= 1.7e-116:
		tmp = NdChar / (1.0 + math.exp((mu / KbT)))
	elif Vef <= 2.2e+34:
		tmp = NaChar / (1.0 + math.exp((EAccept / 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(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -7.5e+106)
		tmp = t_0;
	elseif (Vef <= -1260000.0)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	elseif (Vef <= 1.7e-116)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))));
	elseif (Vef <= 2.2e+34)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / 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((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -7.5e+106)
		tmp = t_0;
	elseif (Vef <= -1260000.0)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	elseif (Vef <= 1.7e-116)
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	elseif (Vef <= 2.2e+34)
		tmp = NaChar / (1.0 + exp((EAccept / 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[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -7.5e+106], t$95$0, If[LessEqual[Vef, -1260000.0], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.7e-116], N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2.2e+34], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -7.50000000000000058e106 or 2.2000000000000002e34 < 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 mu around inf 65.9%

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

      1. associate-*r/ 65.9%

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

      2. mul-1-neg 65.9%

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

   7. Simplified 65.9%

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

   8. Taylor expanded in NdChar around inf 75.3%

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

   10. Simplified 75.3%

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

   11. Taylor expanded in Vef around inf 60.8%

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

   if -7.50000000000000058e106 < Vef < -1.26e6

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 61.8%

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

   if -1.26e6 < Vef < 1.69999999999999996e-116

   1. Initial program 100.0%

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

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

      1. associate-*r/ 80.7%

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

      2. mul-1-neg 80.7%

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

   7. Simplified 80.7%

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

   8. Taylor expanded in NdChar around inf 61.3%

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

   10. Simplified 61.3%

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

   11. Taylor expanded in mu around inf 45.9%

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

   if 1.69999999999999996e-116 < Vef < 2.2000000000000002e34

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EAccept around inf 52.4%

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

Alternative 8: 43.6% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -5.4 \cdot 10^{-14}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -1.1 \cdot 10^{-224}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 3.1 \cdot 10^{-209}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.85 \cdot 10^{-115}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -5.4e-14)
     t_1
     (if (<= Vef -1.1e-224)
       t_0
       (if (<= Vef 3.1e-209)
         (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
         (if (<= Vef 1.85e-115) t_0 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((EDonor / KbT)));
	double t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -5.4e-14) {
		tmp = t_1;
	} else if (Vef <= -1.1e-224) {
		tmp = t_0;
	} else if (Vef <= 3.1e-209) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else if (Vef <= 1.85e-115) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((edonor / kbt)))
    t_1 = nachar / (1.0d0 + exp((vef / kbt)))
    if (vef <= (-5.4d-14)) then
        tmp = t_1
    else if (vef <= (-1.1d-224)) then
        tmp = t_0
    else if (vef <= 3.1d-209) then
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    else if (vef <= 1.85d-115) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (Vef <= -5.4e-14) {
		tmp = t_1;
	} else if (Vef <= -1.1e-224) {
		tmp = t_0;
	} else if (Vef <= 3.1e-209) {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	} else if (Vef <= 1.85e-115) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((EDonor / KbT)))
	t_1 = NaChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if Vef <= -5.4e-14:
		tmp = t_1
	elif Vef <= -1.1e-224:
		tmp = t_0
	elif Vef <= 3.1e-209:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	elif Vef <= 1.85e-115:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -5.4e-14)
		tmp = t_1;
	elseif (Vef <= -1.1e-224)
		tmp = t_0;
	elseif (Vef <= 3.1e-209)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	elseif (Vef <= 1.85e-115)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((EDonor / KbT)));
	t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -5.4e-14)
		tmp = t_1;
	elseif (Vef <= -1.1e-224)
		tmp = t_0;
	elseif (Vef <= 3.1e-209)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	elseif (Vef <= 1.85e-115)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -5.4e-14], t$95$1, If[LessEqual[Vef, -1.1e-224], t$95$0, If[LessEqual[Vef, 3.1e-209], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.85e-115], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -5.3999999999999997e-14 or 1.85e-115 < 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 63.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 50.5%

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

   if -5.3999999999999997e-14 < Vef < -1.1e-224 or 3.1e-209 < Vef < 1.85e-115

   1. Initial program 100.0%

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

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

   6. Taylor expanded in NdChar around inf 52.5%

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

   if -1.1e-224 < Vef < 3.1e-209

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 45.7%

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

Alternative 9: 62.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.8 \cdot 10^{+144}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 7.4 \cdot 10^{+168}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.85 \cdot 10^{+252}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.8e+144)
   (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 0.5))
   (if (<= KbT 7.4e+168)
     (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
     (if (<= KbT 1.85e+252)
       (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
       (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (/ NdChar 2.0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1.8e+144) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
	} else if (KbT <= 7.4e+168) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	} else if (KbT <= 1.85e+252) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else {
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -1.7999999999999999e144

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 76.2%

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

      1. *-commutative 76.2%

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

   8. Simplified 76.2%

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

   if -1.7999999999999999e144 < KbT < 7.40000000000000018e168

   1. Initial program 100.0%

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

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

   if 7.40000000000000018e168 < KbT < 1.8499999999999999e252

   1. Initial program 100.0%

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

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

      1. associate-*r/ 57.0%

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

      2. mul-1-neg 57.0%

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

   7. Simplified 57.0%

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

   8. Taylor expanded in NdChar around inf 84.8%

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

   10. Simplified 84.8%

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

   11. Taylor expanded in Vef around inf 76.2%

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

   if 1.8499999999999999e252 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 100.0%

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

      1. associate-*r/ 100.0%

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

      2. mul-1-neg 100.0%

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

   7. Simplified 100.0%

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

   8. Taylor expanded in KbT around inf 87.5%

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

4. Final simplification 68.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.8 \cdot 10^{+144}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 7.4 \cdot 10^{+168}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.85 \cdot 10^{+252}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 68.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -1.1 \cdot 10^{-98} \lor \neg \left(NdChar \leq 720000000000\right):\\ \;\;\;\;\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 (or (<= NdChar -1.1e-98) (not (<= NdChar 720000000000.0)))
   (/ 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 ((NdChar <= -1.1e-98) || !(NdChar <= 720000000000.0)) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - 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 ((ndchar <= (-1.1d-98)) .or. (.not. (ndchar <= 720000000000.0d0))) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else
        tmp = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - 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 ((NdChar <= -1.1e-98) || !(NdChar <= 720000000000.0)) {
		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 (NdChar <= -1.1e-98) or not (NdChar <= 720000000000.0):
		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 ((NdChar <= -1.1e-98) || !(NdChar <= 720000000000.0))
		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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.1e-98], N[Not[LessEqual[NdChar, 720000000000.0]], $MachinePrecision]], 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 2 regimes

2. if NdChar < -1.09999999999999998e-98 or 7.2e11 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 76.6%

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

   if -1.09999999999999998e-98 < NdChar < 7.2e11

   1. Initial program 100.0%

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

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

4. Final simplification 76.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -1.1 \cdot 10^{-98} \lor \neg \left(NdChar \leq 720000000000\right):\\ \;\;\;\;\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 11: 42.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -9 \cdot 10^{+142}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{\left(\left(\frac{EAccept}{KbT} + 2\right) + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;KbT \leq 1.3 \cdot 10^{-65}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.05 \cdot 10^{+161}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -9e+142) {
		tmp = (NdChar / 2.0) + (NaChar / ((((EAccept / KbT) + 2.0) + ((Vef / KbT) + (Ev / KbT))) - (mu / KbT)));
	} else if (KbT <= 1.3e-65) {
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	} else if (KbT <= 2.05e+161) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -8.9999999999999998e142

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 69.8%

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

      1. associate-+r+ 69.8%

         \[\leadsto \frac{NdChar}{2} + \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 69.8%

         \[\leadsto \frac{NdChar}{2} + \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 69.8%

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

   if -8.9999999999999998e142 < KbT < 1.30000000000000005e-65

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 62.3%

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

   6. Taylor expanded in Vef around inf 38.0%

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

   if 1.30000000000000005e-65 < KbT < 2.0500000000000001e161

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 43.1%

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

   if 2.0500000000000001e161 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 58.4%

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

      1. distribute-lft-out 58.4%

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

   7. Simplified 58.4%

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

4. Final simplification 46.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -9 \cdot 10^{+142}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{\left(\left(\frac{EAccept}{KbT} + 2\right) + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;KbT \leq 1.3 \cdot 10^{-65}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.05 \cdot 10^{+161}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 50.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -6.5 \cdot 10^{-68}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 2.8 \cdot 10^{+15}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{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 (<= NdChar -6.5e-68)
   (/ NdChar (+ 1.0 (exp (/ mu KbT))))
   (if (<= NdChar 2.8e+15)
     (/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) 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 (NdChar <= -6.5e-68) {
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	} else if (NdChar <= 2.8e+15) {
		tmp = NaChar / (1.0 + exp((((Vef + EAccept) - mu) / 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 (ndchar <= (-6.5d-68)) then
        tmp = ndchar / (1.0d0 + exp((mu / kbt)))
    else if (ndchar <= 2.8d+15) then
        tmp = nachar / (1.0d0 + exp((((vef + eaccept) - mu) / 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 (NdChar <= -6.5e-68) {
		tmp = NdChar / (1.0 + Math.exp((mu / KbT)));
	} else if (NdChar <= 2.8e+15) {
		tmp = NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / 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 NdChar <= -6.5e-68:
		tmp = NdChar / (1.0 + math.exp((mu / KbT)))
	elif NdChar <= 2.8e+15:
		tmp = NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / 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 (NdChar <= -6.5e-68)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))));
	elseif (NdChar <= 2.8e+15)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT))));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NdChar <= -6.5e-68)
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	elseif (NdChar <= 2.8e+15)
		tmp = NaChar / (1.0 + exp((((Vef + EAccept) - mu) / 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[LessEqual[NdChar, -6.5e-68], N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.8e+15], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -6.4999999999999997e-68

   1. Initial program 100.0%

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

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

      1. associate-*r/ 75.9%

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

      2. mul-1-neg 75.9%

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

   7. Simplified 75.9%

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

   8. Taylor expanded in NdChar around inf 74.0%

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

   10. Simplified 74.0%

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

   11. Taylor expanded in mu around inf 51.5%

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

   if -6.4999999999999997e-68 < NdChar < 2.8e15

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around 0 65.6%

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

   if 2.8e15 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 75.4%

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

      1. associate-*r/ 75.4%

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

      2. mul-1-neg 75.4%

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

   7. Simplified 75.4%

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

   8. Taylor expanded in NdChar around inf 79.3%

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

   10. Simplified 79.3%

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

   11. Taylor expanded in Ec around inf 63.6%

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

       1. associate-*r/ 63.6%

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

       2. mul-1-neg 63.6%

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

   13. Simplified 63.6%

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

4. Final simplification 60.8%

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

Alternative 13: 42.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -1.15 \cdot 10^{-98}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 1500000000:\\ \;\;\;\;\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 (<= NdChar -1.15e-98)
   (/ NdChar (+ 1.0 (exp (/ mu KbT))))
   (if (<= NdChar 1500000000.0)
     (/ 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 (NdChar <= -1.15e-98) {
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	} else if (NdChar <= 1500000000.0) {
		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 (ndchar <= (-1.15d-98)) then
        tmp = ndchar / (1.0d0 + exp((mu / kbt)))
    else if (ndchar <= 1500000000.0d0) 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 (NdChar <= -1.15e-98) {
		tmp = NdChar / (1.0 + Math.exp((mu / KbT)));
	} else if (NdChar <= 1500000000.0) {
		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 NdChar <= -1.15e-98:
		tmp = NdChar / (1.0 + math.exp((mu / KbT)))
	elif NdChar <= 1500000000.0:
		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 (NdChar <= -1.15e-98)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))));
	elseif (NdChar <= 1500000000.0)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NdChar <= -1.15e-98)
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	elseif (NdChar <= 1500000000.0)
		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[LessEqual[NdChar, -1.15e-98], N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1500000000.0], 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 3 regimes

2. if NdChar < -1.15e-98

   1. Initial program 100.0%

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

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

      1. associate-*r/ 76.5%

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

      2. mul-1-neg 76.5%

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

   7. Simplified 76.5%

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

   8. Taylor expanded in NdChar around inf 74.8%

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

   10. Simplified 74.8%

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

   11. Taylor expanded in mu around inf 49.7%

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

   if -1.15e-98 < NdChar < 1.5e9

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Vef around inf 50.8%

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

   if 1.5e9 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 75.4%

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

      1. associate-*r/ 75.4%

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

      2. mul-1-neg 75.4%

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

   7. Simplified 75.4%

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

   8. Taylor expanded in NdChar around inf 79.3%

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

   10. Simplified 79.3%

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

   11. Taylor expanded in Ec around inf 63.6%

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

       1. associate-*r/ 63.6%

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

       2. mul-1-neg 63.6%

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

   13. Simplified 63.6%

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

Alternative 14: 41.2% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -8.79999999999999947e142

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 69.8%

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

      1. associate-+r+ 69.8%

         \[\leadsto \frac{NdChar}{2} + \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 69.8%

         \[\leadsto \frac{NdChar}{2} + \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 69.8%

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

   if -8.79999999999999947e142 < KbT < 4.5999999999999999e161

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 32.5%

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

   if 4.5999999999999999e161 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 58.4%

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

      1. distribute-lft-out 58.4%

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

   7. Simplified 58.4%

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

4. Final simplification 41.7%

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

Alternative 15: 40.2% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.25e+143)
   (+
    (/ NdChar 2.0)
    (/
     NaChar
     (- (+ (+ (/ EAccept KbT) 2.0) (+ (/ Vef KbT) (/ Ev KbT))) (/ mu KbT))))
   (if (<= KbT 6.2e+62)
     (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
     (* 0.5 (+ NdChar NaChar)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.25000000000000003e143

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 69.8%

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

      1. associate-+r+ 69.8%

         \[\leadsto \frac{NdChar}{2} + \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 69.8%

         \[\leadsto \frac{NdChar}{2} + \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 69.8%

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

   if -1.25000000000000003e143 < KbT < 6.20000000000000029e62

   1. Initial program 100.0%

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

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

   if 6.20000000000000029e62 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 44.5%

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

      1. distribute-lft-out 44.5%

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

   7. Simplified 44.5%

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

4. Final simplification 40.8%

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

Alternative 16: 29.1% accurate, 6.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{if}\;KbT \leq -1.05 \cdot 10^{-65}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 4.8 \cdot 10^{-239}:\\ \;\;\;\;\frac{NaChar}{2 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;KbT \leq 1.75 \cdot 10^{-13}:\\ \;\;\;\;\frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \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 (* 0.5 (+ NdChar NaChar))))
   (if (<= KbT -1.05e-65)
     t_0
     (if (<= KbT 4.8e-239)
       (/ NaChar (+ 2.0 (/ Ev KbT)))
       (if (<= KbT 1.75e-13)
         (/
          NaChar
          (-
           (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT))))
           (/ 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 <= -1.05e-65) {
		tmp = t_0;
	} else if (KbT <= 4.8e-239) {
		tmp = NaChar / (2.0 + (Ev / KbT));
	} else if (KbT <= 1.75e-13) {
		tmp = NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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 <= (-1.05d-65)) then
        tmp = t_0
    else if (kbt <= 4.8d-239) then
        tmp = nachar / (2.0d0 + (ev / kbt))
    else if (kbt <= 1.75d-13) then
        tmp = nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (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 <= -1.05e-65) {
		tmp = t_0;
	} else if (KbT <= 4.8e-239) {
		tmp = NaChar / (2.0 + (Ev / KbT));
	} else if (KbT <= 1.75e-13) {
		tmp = NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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 <= -1.05e-65:
		tmp = t_0
	elif KbT <= 4.8e-239:
		tmp = NaChar / (2.0 + (Ev / KbT))
	elif KbT <= 1.75e-13:
		tmp = NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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 <= -1.05e-65)
		tmp = t_0;
	elseif (KbT <= 4.8e-239)
		tmp = Float64(NaChar / Float64(2.0 + Float64(Ev / KbT)));
	elseif (KbT <= 1.75e-13)
		tmp = Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - Float64(mu / KbT)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 0.5 * (NdChar + NaChar);
	tmp = 0.0;
	if (KbT <= -1.05e-65)
		tmp = t_0;
	elseif (KbT <= 4.8e-239)
		tmp = NaChar / (2.0 + (Ev / KbT));
	elseif (KbT <= 1.75e-13)
		tmp = NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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, -1.05e-65], t$95$0, If[LessEqual[KbT, 4.8e-239], N[(NaChar / N[(2.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.75e-13], N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.05000000000000001e-65 or 1.7500000000000001e-13 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 40.9%

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

      1. distribute-lft-out 40.9%

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

   7. Simplified 40.9%

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

   if -1.05000000000000001e-65 < KbT < 4.79999999999999985e-239

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 38.1%

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

   7. Taylor expanded in Ev around 0 18.9%

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

   if 4.79999999999999985e-239 < KbT < 1.7500000000000001e-13

   1. Initial program 100.0%

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

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

4. Final simplification 33.3%

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

Alternative 17: 29.7% accurate, 7.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -5.4 \cdot 10^{-34} \lor \neg \left(KbT \leq 6.2 \cdot 10^{-14}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -5.4e-34) (not (<= KbT 6.2e-14)))
   (* 0.5 (+ NdChar NaChar))
   (/
    NdChar
    (- (+ 2.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT)))) (/ Ec KbT)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -5.4e-34) || !(KbT <= 6.2e-14)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT));
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -5.4e-34) || !(KbT <= 6.2e-14)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -5.40000000000000034e-34 or 6.20000000000000009e-14 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 43.2%

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

      1. distribute-lft-out 43.2%

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

   7. Simplified 43.2%

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

   if -5.40000000000000034e-34 < KbT < 6.20000000000000009e-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 mu around inf 67.8%

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

      1. associate-*r/ 67.8%

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

      2. mul-1-neg 67.8%

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

   7. Simplified 67.8%

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

   8. Taylor expanded in NdChar around inf 66.0%

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

   10. Simplified 66.0%

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

   11. Taylor expanded in KbT around inf 21.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}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 33.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -5.4 \cdot 10^{-34} \lor \neg \left(KbT \leq 6.2 \cdot 10^{-14}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 28.2% accurate, 13.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.5 \cdot 10^{-62} \lor \neg \left(KbT \leq 8 \cdot 10^{-6}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2 + \frac{Ev}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -2.5e-62) (not (<= KbT 8e-6)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (+ 2.0 (/ Ev KbT)))))

C

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

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -2.5e-62) || !(KbT <= 8e-6)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (2.0 + (Ev / KbT));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -2.5e-62], N[Not[LessEqual[KbT, 8e-6]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(2.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -2.5000000000000001e-62 or 7.99999999999999964e-6 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 41.3%

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

      1. distribute-lft-out 41.3%

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

   7. Simplified 41.3%

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

   if -2.5000000000000001e-62 < KbT < 7.99999999999999964e-6

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 67.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 35.3%

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

   7. Taylor expanded in Ev around 0 16.9%

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

4. Final simplification 31.0%

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

Alternative 19: 22.3% accurate, 17.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -2.2 \cdot 10^{-105} \lor \neg \left(NdChar \leq 7.6 \cdot 10^{-60}\right):\\ \;\;\;\;NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -2.2e-105) (not (<= NdChar 7.6e-60)))
   (* NdChar 0.5)
   (/ NaChar 2.0)))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -2.2e-105) || !(NdChar <= 7.6e-60)) {
		tmp = NdChar * 0.5;
	} else {
		tmp = NaChar / 2.0;
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -2.2e-105) || !(NdChar <= 7.6e-60)) {
		tmp = NdChar * 0.5;
	} else {
		tmp = NaChar / 2.0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NdChar <= -2.2e-105) or not (NdChar <= 7.6e-60):
		tmp = NdChar * 0.5
	else:
		tmp = NaChar / 2.0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -2.2e-105) || !(NdChar <= 7.6e-60))
		tmp = Float64(NdChar * 0.5);
	else
		tmp = Float64(NaChar / 2.0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -2.2e-105) || ~((NdChar <= 7.6e-60)))
		tmp = NdChar * 0.5;
	else
		tmp = NaChar / 2.0;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -2.20000000000000004e-105 or 7.59999999999999989e-60 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 26.5%

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

      1. distribute-lft-out 26.5%

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

   7. Simplified 26.5%

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

   8. Taylor expanded in NaChar around 0 24.2%

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

      1. *-commutative 24.2%

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

   10. Simplified 24.2%

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

   if -2.20000000000000004e-105 < NdChar < 7.59999999999999989e-60

   1. Initial program 100.0%

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

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

4. Final simplification 25.9%

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

Alternative 20: 26.9% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 28.4%

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

   1. distribute-lft-out 28.4%

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

7. Simplified 28.4%

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

8. Final simplification 28.4%

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

Alternative 21: 17.6% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 28.4%

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

   1. distribute-lft-out 28.4%

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

7. Simplified 28.4%

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

8. Taylor expanded in NaChar around 0 20.2%

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

   1. *-commutative 20.2%

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

10. Simplified 20.2%

    \[\leadsto \color{blue}{NdChar \cdot 0.5} \]
11. Add Preprocessing

Reproduce

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