Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 28.6s

Alternatives: 30

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

   1. *-un-lft-identity 100.0%

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

   2. exp-prod 100.0%

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

   3. +-commutative 100.0%

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

   4. associate-+l+ 100.0%

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

6. Applied egg-rr 100.0%

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

7. Final simplification 100.0%

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

Alternative 2: 66.9% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}} + \frac{NdChar}{1 + Ec \cdot \left(\frac{1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)}{Ec} + \frac{-1}{KbT}\right)}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{if}\;mu \leq -5.8 \cdot 10^{+240}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq -1.5 \cdot 10^{-119}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;mu \leq -2.6 \cdot 10^{-168}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;mu \leq 1.05 \cdot 10^{-306}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;mu \leq 4.3 \cdot 10^{+52}:\\ \;\;\;\;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
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT))))
          (/
           NdChar
           (+
            1.0
            (*
             Ec
             (+
              (/ (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT)))) Ec)
              (/ -1.0 KbT)))))))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (- (/ mu KbT)))))))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))))
   (if (<= mu -5.8e+240)
     t_1
     (if (<= mu -1.5e-119)
       t_2
       (if (<= mu -2.6e-168)
         t_0
         (if (<= mu 1.05e-306) t_2 (if (<= mu 4.3e+52) 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 = (NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + (Ec * (((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) / Ec) + (-1.0 / KbT)))));
	double t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	double t_2 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	double tmp;
	if (mu <= -5.8e+240) {
		tmp = t_1;
	} else if (mu <= -1.5e-119) {
		tmp = t_2;
	} else if (mu <= -2.6e-168) {
		tmp = t_0;
	} else if (mu <= 1.05e-306) {
		tmp = t_2;
	} else if (mu <= 4.3e+52) {
		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) :: t_2
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp(((vef + (ev - (mu - eaccept))) / kbt)))) + (ndchar / (1.0d0 + (ec * (((1.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) / ec) + ((-1.0d0) / kbt)))))
    t_1 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp(-(mu / kbt))))
    t_2 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    if (mu <= (-5.8d+240)) then
        tmp = t_1
    else if (mu <= (-1.5d-119)) then
        tmp = t_2
    else if (mu <= (-2.6d-168)) then
        tmp = t_0
    else if (mu <= 1.05d-306) then
        tmp = t_2
    else if (mu <= 4.3d+52) 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 = (NaChar / (1.0 + Math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + (Ec * (((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) / Ec) + (-1.0 / KbT)))));
	double t_1 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
	double t_2 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	double tmp;
	if (mu <= -5.8e+240) {
		tmp = t_1;
	} else if (mu <= -1.5e-119) {
		tmp = t_2;
	} else if (mu <= -2.6e-168) {
		tmp = t_0;
	} else if (mu <= 1.05e-306) {
		tmp = t_2;
	} else if (mu <= 4.3e+52) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + (Ec * (((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) / Ec) + (-1.0 / KbT)))))
	t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp(-(mu / KbT))))
	t_2 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	tmp = 0
	if mu <= -5.8e+240:
		tmp = t_1
	elif mu <= -1.5e-119:
		tmp = t_2
	elif mu <= -2.6e-168:
		tmp = t_0
	elif mu <= 1.05e-306:
		tmp = t_2
	elif mu <= 4.3e+52:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev - Float64(mu - EAccept))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Ec * Float64(Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) / Ec) + Float64(-1.0 / KbT))))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))))
	tmp = 0.0
	if (mu <= -5.8e+240)
		tmp = t_1;
	elseif (mu <= -1.5e-119)
		tmp = t_2;
	elseif (mu <= -2.6e-168)
		tmp = t_0;
	elseif (mu <= 1.05e-306)
		tmp = t_2;
	elseif (mu <= 4.3e+52)
		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 = (NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + (Ec * (((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) / Ec) + (-1.0 / KbT)))));
	t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	t_2 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	tmp = 0.0;
	if (mu <= -5.8e+240)
		tmp = t_1;
	elseif (mu <= -1.5e-119)
		tmp = t_2;
	elseif (mu <= -2.6e-168)
		tmp = t_0;
	elseif (mu <= 1.05e-306)
		tmp = t_2;
	elseif (mu <= 4.3e+52)
		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[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(Ec * N[(N[(N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Ec), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -5.8e+240], t$95$1, If[LessEqual[mu, -1.5e-119], t$95$2, If[LessEqual[mu, -2.6e-168], t$95$0, If[LessEqual[mu, 1.05e-306], t$95$2, If[LessEqual[mu, 4.3e+52], t$95$0, t$95$1]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -5.79999999999999997e240 or 4.3e52 < mu

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in mu around inf 89.9%

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

   6. Taylor expanded in mu around inf 83.2%

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

      1. associate-*r/ 83.2%

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

      2. mul-1-neg 83.2%

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

   8. Simplified 83.2%

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

   if -5.79999999999999997e240 < mu < -1.5000000000000001e-119 or -2.6000000000000001e-168 < mu < 1.0500000000000001e-306

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EDonor around 0 68.9%

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

      1. +-commutative 64.3%

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

   8. Simplified 68.9%

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

   if -1.5000000000000001e-119 < mu < -2.6000000000000001e-168 or 1.0500000000000001e-306 < mu < 4.3e52

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ec around -inf 74.7%

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

      1. mul-1-neg 74.7%

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

      2. *-commutative 74.7%

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

      3. distribute-rgt-neg-in 74.7%

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

      4. +-commutative 74.7%

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

      5. mul-1-neg 74.7%

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

      6. unsub-neg 74.7%

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

   8. Simplified 74.7%

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

4. Final simplification 75.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -5.8 \cdot 10^{+240}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.5 \cdot 10^{-119}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq -2.6 \cdot 10^{-168}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}} + \frac{NdChar}{1 + Ec \cdot \left(\frac{1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)}{Ec} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 1.05 \cdot 10^{-306}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 4.3 \cdot 10^{+52}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}} + \frac{NdChar}{1 + Ec \cdot \left(\frac{1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)}{Ec} + \frac{-1}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 73.0% accurate, 0.9× 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}\;Ev \leq -6.2 \cdot 10^{+29}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -7.2 \cdot 10^{-173}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Ev \leq 2.75 \cdot 10^{-308}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;Ev \leq 1.35 \cdot 10^{-147}:\\ \;\;\;\;t\_1\\ \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)))))
        (t_1 (+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))))
   (if (<= Ev -6.2e+29)
     (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (if (<= Ev -7.2e-173)
       t_1
       (if (<= Ev 2.75e-308)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
         (if (<= Ev 1.35e-147)
           t_1
           (+ 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 t_1 = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	double tmp;
	if (Ev <= -6.2e+29) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (Ev <= -7.2e-173) {
		tmp = t_1;
	} else if (Ev <= 2.75e-308) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (Ev <= 1.35e-147) {
		tmp = t_1;
	} 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) :: 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 (ev <= (-6.2d+29)) then
        tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (ev <= (-7.2d-173)) then
        tmp = t_1
    else if (ev <= 2.75d-308) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev - (mu - eaccept))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    else if (ev <= 1.35d-147) then
        tmp = t_1
    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 t_1 = t_0 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
	double tmp;
	if (Ev <= -6.2e+29) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (Ev <= -7.2e-173) {
		tmp = t_1;
	} else if (Ev <= 2.75e-308) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else if (Ev <= 1.35e-147) {
		tmp = t_1;
	} 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)))
	t_1 = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT))))
	tmp = 0
	if Ev <= -6.2e+29:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif Ev <= -7.2e-173:
		tmp = t_1
	elif Ev <= 2.75e-308:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif Ev <= 1.35e-147:
		tmp = t_1
	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))))
	t_1 = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	tmp = 0.0
	if (Ev <= -6.2e+29)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (Ev <= -7.2e-173)
		tmp = t_1;
	elseif (Ev <= 2.75e-308)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev - Float64(mu - EAccept))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (Ev <= 1.35e-147)
		tmp = t_1;
	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)));
	t_1 = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	tmp = 0.0;
	if (Ev <= -6.2e+29)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (Ev <= -7.2e-173)
		tmp = t_1;
	elseif (Ev <= 2.75e-308)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (Ev <= 1.35e-147)
		tmp = t_1;
	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]}, 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[Ev, -6.2e+29], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -7.2e-173], t$95$1, If[LessEqual[Ev, 2.75e-308], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 1.35e-147], t$95$1, N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if Ev < -6.1999999999999998e29

   1. Initial program 100.0%

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

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

   if -6.1999999999999998e29 < Ev < -7.19999999999999943e-173 or 2.75e-308 < Ev < 1.35e-147

   1. Initial program 100.0%

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

   1. Initial program 100.0%

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

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

   if 1.35e-147 < Ev

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in EAccept around inf 71.7%

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

4. Final simplification 77.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -6.2 \cdot 10^{+29}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -7.2 \cdot 10^{-173}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Ev \leq 2.75 \cdot 10^{-308}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;Ev \leq 1.35 \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 4: 76.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}}\\ t_1 := t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_2 := t\_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -3.2 \cdot 10^{+115}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;mu \leq -7.2 \cdot 10^{-295}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq 1.45 \cdot 10^{-177}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{+50}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
        (t_2 (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -3.2e+115)
     t_2
     (if (<= mu -7.2e-295)
       t_1
       (if (<= mu 1.45e-177)
         (+
          (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
         (if (<= mu 1.6e+50) t_1 t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -3.2e+115) {
		tmp = t_2;
	} else if (mu <= -7.2e-295) {
		tmp = t_1;
	} else if (mu <= 1.45e-177) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	} else if (mu <= 1.6e+50) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (ev - (mu - eaccept))) / kbt)))
    t_1 = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    t_2 = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-3.2d+115)) then
        tmp = t_2
    else if (mu <= (-7.2d-295)) then
        tmp = t_1
    else if (mu <= 1.45d-177) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    else if (mu <= 1.6d+50) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -3.2e+115) {
		tmp = t_2;
	} else if (mu <= -7.2e-295) {
		tmp = t_1;
	} else if (mu <= 1.45e-177) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	} else if (mu <= 1.6e+50) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))
	t_1 = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	t_2 = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -3.2e+115:
		tmp = t_2
	elif mu <= -7.2e-295:
		tmp = t_1
	elif mu <= 1.45e-177:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	elif mu <= 1.6e+50:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev - Float64(mu - EAccept))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	t_2 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -3.2e+115)
		tmp = t_2;
	elseif (mu <= -7.2e-295)
		tmp = t_1;
	elseif (mu <= 1.45e-177)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))));
	elseif (mu <= 1.6e+50)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)));
	t_1 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	t_2 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -3.2e+115)
		tmp = t_2;
	elseif (mu <= -7.2e-295)
		tmp = t_1;
	elseif (mu <= 1.45e-177)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	elseif (mu <= 1.6e+50)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -3.2e+115], t$95$2, If[LessEqual[mu, -7.2e-295], t$95$1, If[LessEqual[mu, 1.45e-177], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.6e+50], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -3.2e115 or 1.59999999999999991e50 < mu

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in mu around inf 87.4%

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

   if -3.2e115 < mu < -7.2000000000000003e-295 or 1.44999999999999999e-177 < mu < 1.59999999999999991e50

   1. Initial program 100.0%

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

   if -7.2000000000000003e-295 < mu < 1.44999999999999999e-177

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EDonor around 0 68.2%

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

      1. +-commutative 68.2%

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

   8. Simplified 68.2%

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

4. Final simplification 80.4%

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

Alternative 5: 71.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;mu \leq -1.65 \cdot 10^{+230}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;mu \leq -2 \cdot 10^{-295}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq 8.5 \cdot 10^{-178}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.35 \cdot 10^{+52}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (- (/ mu KbT)))))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= mu -1.65e+230)
     t_0
     (if (<= mu -2e-295)
       t_1
       (if (<= mu 8.5e-178)
         (+
          (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
         (if (<= mu 1.35e+52) t_1 t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (mu <= -1.65e+230) {
		tmp = t_0;
	} else if (mu <= -2e-295) {
		tmp = t_1;
	} else if (mu <= 8.5e-178) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	} else if (mu <= 1.35e+52) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp(-(mu / kbt))))
    t_1 = (nachar / (1.0d0 + exp(((vef + (ev - (mu - eaccept))) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    if (mu <= (-1.65d+230)) then
        tmp = t_0
    else if (mu <= (-2d-295)) then
        tmp = t_1
    else if (mu <= 8.5d-178) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    else if (mu <= 1.35d+52) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (mu <= -1.65e+230) {
		tmp = t_0;
	} else if (mu <= -2e-295) {
		tmp = t_1;
	} else if (mu <= 8.5e-178) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	} else if (mu <= 1.35e+52) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp(-(mu / KbT))))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if mu <= -1.65e+230:
		tmp = t_0
	elif mu <= -2e-295:
		tmp = t_1
	elif mu <= 8.5e-178:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	elif mu <= 1.35e+52:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev - Float64(mu - EAccept))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (mu <= -1.65e+230)
		tmp = t_0;
	elseif (mu <= -2e-295)
		tmp = t_1;
	elseif (mu <= 8.5e-178)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))));
	elseif (mu <= 1.35e+52)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (mu <= -1.65e+230)
		tmp = t_0;
	elseif (mu <= -2e-295)
		tmp = t_1;
	elseif (mu <= 8.5e-178)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	elseif (mu <= 1.35e+52)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.65e+230], t$95$0, If[LessEqual[mu, -2e-295], t$95$1, If[LessEqual[mu, 8.5e-178], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.35e+52], t$95$1, t$95$0]]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -1.65000000000000007e230 or 1.35e52 < mu

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in mu around inf 90.2%

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

   6. Taylor expanded in mu around inf 83.7%

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

      1. associate-*r/ 83.7%

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

      2. mul-1-neg 83.7%

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

   8. Simplified 83.7%

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

   if -1.65000000000000007e230 < mu < -2.00000000000000012e-295 or 8.5000000000000001e-178 < mu < 1.35e52

   1. Initial program 100.0%

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

   if -2.00000000000000012e-295 < mu < 8.5000000000000001e-178

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 76.7%

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

   6. Taylor expanded in EDonor around 0 68.2%

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

      1. +-commutative 68.2%

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

   8. Simplified 68.2%

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

4. Final simplification 77.8%

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

Alternative 6: 72.5% 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}\;Ev \leq -1.15 \cdot 10^{+91}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -4.1 \cdot 10^{-126}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Ev \leq -4.5 \cdot 10^{-160}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \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 (<= Ev -1.15e+91)
     (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (if (<= Ev -4.1e-126)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT))))
        (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
       (if (<= Ev -4.5e-160)
         (+
          t_0
          (/
           NaChar
           (+
            1.0
            (-
             (+ 1.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
             (/ mu KbT)))))
         (+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -1.15e+91) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (Ev <= -4.1e-126) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (Ev <= -4.5e-160) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	} else {
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if Ev < -1.14999999999999996e91

   1. Initial program 100.0%

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

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

   if -1.14999999999999996e91 < Ev < -4.0999999999999997e-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 76.8%

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

   if -4.0999999999999997e-126 < Ev < -4.50000000000000026e-160

   1. Initial program 100.0%

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

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

      1. +-commutative 88.9%

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

   7. Simplified 88.9%

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

   if -4.50000000000000026e-160 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 74.8%

      \[\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 4 regimes into one program.

4. Final simplification 77.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -1.15 \cdot 10^{+91}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -4.1 \cdot 10^{-126}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Ev \leq -4.5 \cdot 10^{-160}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \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 7: 64.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_0\\ \mathbf{if}\;EAccept \leq 3.5 \cdot 10^{-208}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;EAccept \leq 3.1 \cdot 10^{-34}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 7.5 \cdot 10^{+139}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
        (t_1 (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)))
   (if (<= EAccept 3.5e-208)
     t_1
     (if (<= EAccept 3.1e-34)
       (+
        (/ NdChar (+ 1.0 (exp (/ mu KbT))))
        (/ NaChar (+ 1.0 (exp (- (/ mu KbT))))))
       (if (<= EAccept 7.5e+139)
         t_1
         (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	double tmp;
	if (EAccept <= 3.5e-208) {
		tmp = t_1;
	} else if (EAccept <= 3.1e-34) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	} else if (EAccept <= 7.5e+139) {
		tmp = t_1;
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))
    t_1 = (nachar / (1.0d0 + exp((ev / kbt)))) + t_0
    if (eaccept <= 3.5d-208) then
        tmp = t_1
    else if (eaccept <= 3.1d-34) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp(-(mu / kbt))))
    else if (eaccept <= 7.5d+139) then
        tmp = t_1
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_0;
	double tmp;
	if (EAccept <= 3.5e-208) {
		tmp = t_1;
	} else if (EAccept <= 3.1e-34) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
	} else if (EAccept <= 7.5e+139) {
		tmp = t_1;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_0
	tmp = 0
	if EAccept <= 3.5e-208:
		tmp = t_1
	elif EAccept <= 3.1e-34:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp(-(mu / KbT))))
	elif EAccept <= 7.5e+139:
		tmp = t_1
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_0)
	tmp = 0.0
	if (EAccept <= 3.5e-208)
		tmp = t_1;
	elseif (EAccept <= 3.1e-34)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))));
	elseif (EAccept <= 7.5e+139)
		tmp = t_1;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	t_1 = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	tmp = 0.0;
	if (EAccept <= 3.5e-208)
		tmp = t_1;
	elseif (EAccept <= 3.1e-34)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	elseif (EAccept <= 7.5e+139)
		tmp = t_1;
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, If[LessEqual[EAccept, 3.5e-208], t$95$1, If[LessEqual[EAccept, 3.1e-34], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 7.5e+139], t$95$1, N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if EAccept < 3.49999999999999991e-208 or 3.0999999999999998e-34 < EAccept < 7.49999999999999992e139

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EDonor around 0 66.0%

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

      1. +-commutative 66.0%

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

   8. Simplified 66.0%

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

   if 3.49999999999999991e-208 < EAccept < 3.0999999999999998e-34

   1. Initial program 100.0%

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

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

   6. Taylor expanded in mu around inf 55.8%

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

      1. associate-*r/ 55.8%

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

      2. mul-1-neg 55.8%

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

   8. Simplified 55.8%

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

   if 7.49999999999999992e139 < 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 86.1%

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

   6. Taylor expanded in EDonor around 0 74.8%

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

      1. +-commutative 48.5%

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

   8. Simplified 74.8%

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

4. Final simplification 65.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 3.5 \cdot 10^{-208}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 3.1 \cdot 10^{-34}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 7.5 \cdot 10^{+139}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Final simplification 100.0%

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

Alternative 9: 63.2% accurate, 1.5× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT))))))
   (if (<= NaChar -4.3e+133)
     (-
      t_0
      (/
       NdChar
       (+
        -1.0
        (+
         (/ Ec KbT)
         (+
          -1.0
          (- (* mu (- (/ -1.0 KbT) (/ Vef (* mu KbT)))) (/ EDonor KbT)))))))
     (if (<= NaChar 2.1e-100)
       (+
        (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
        (/
         NaChar
         (+
          1.0
          (-
           (+ 1.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
           (/ mu KbT)))))
       (+
        t_0
        (/
         NdChar
         (+
          1.0
          (*
           Ec
           (+
            (/ (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT)))) Ec)
            (/ -1.0 KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)));
	double tmp;
	if (NaChar <= -4.3e+133) {
		tmp = t_0 - (NdChar / (-1.0 + ((Ec / KbT) + (-1.0 + ((mu * ((-1.0 / KbT) - (Vef / (mu * KbT)))) - (EDonor / KbT))))));
	} else if (NaChar <= 2.1e-100) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	} else {
		tmp = t_0 + (NdChar / (1.0 + (Ec * (((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) / Ec) + (-1.0 / KbT)))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)))
	tmp = 0
	if NaChar <= -4.3e+133:
		tmp = t_0 - (NdChar / (-1.0 + ((Ec / KbT) + (-1.0 + ((mu * ((-1.0 / KbT) - (Vef / (mu * KbT)))) - (EDonor / KbT))))))
	elif NaChar <= 2.1e-100:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))))
	else:
		tmp = t_0 + (NdChar / (1.0 + (Ec * (((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) / Ec) + (-1.0 / KbT)))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev - Float64(mu - EAccept))) / KbT))))
	tmp = 0.0
	if (NaChar <= -4.3e+133)
		tmp = Float64(t_0 - Float64(NdChar / Float64(-1.0 + Float64(Float64(Ec / KbT) + Float64(-1.0 + Float64(Float64(mu * Float64(Float64(-1.0 / KbT) - Float64(Vef / Float64(mu * KbT)))) - Float64(EDonor / KbT)))))));
	elseif (NaChar <= 2.1e-100)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT)))));
	else
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(Ec * Float64(Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) / Ec) + Float64(-1.0 / KbT))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)));
	tmp = 0.0;
	if (NaChar <= -4.3e+133)
		tmp = t_0 - (NdChar / (-1.0 + ((Ec / KbT) + (-1.0 + ((mu * ((-1.0 / KbT) - (Vef / (mu * KbT)))) - (EDonor / KbT))))));
	elseif (NaChar <= 2.1e-100)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	else
		tmp = t_0 + (NdChar / (1.0 + (Ec * (((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) / Ec) + (-1.0 / KbT)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -4.3e+133], N[(t$95$0 - N[(NdChar / N[(-1.0 + N[(N[(Ec / KbT), $MachinePrecision] + N[(-1.0 + N[(N[(mu * N[(N[(-1.0 / KbT), $MachinePrecision] - N[(Vef / N[(mu * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.1e-100], 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[(N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(Ec * N[(N[(N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Ec), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -4.29999999999999994e133

   1. Initial program 100.0%

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

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

   6. Taylor expanded in mu around inf 70.4%

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

   if -4.29999999999999994e133 < NaChar < 2.10000000000000009e-100

   1. Initial program 100.0%

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

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

      1. +-commutative 65.2%

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

   7. Simplified 65.2%

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

   if 2.10000000000000009e-100 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 67.1%

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

   6. Taylor expanded in Ec around -inf 74.6%

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

      1. mul-1-neg 74.6%

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

      2. *-commutative 74.6%

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

      3. distribute-rgt-neg-in 74.6%

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

      4. +-commutative 74.6%

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

      5. mul-1-neg 74.6%

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

      6. unsub-neg 74.6%

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

   8. Simplified 74.6%

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

4. Final simplification 69.0%

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

Alternative 10: 61.8% accurate, 1.6× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)));
	double tmp;
	if (NaChar <= -8.8e+133) {
		tmp = t_0 - (NdChar / (-1.0 + ((Ec / KbT) + (-1.0 + ((mu * ((-1.0 / KbT) - (Vef / (mu * KbT)))) - (EDonor / KbT))))));
	} else if (NaChar <= 5e-101) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	} else {
		tmp = t_0 + (NdChar / (1.0 - ((Ec / KbT) - (1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)));
	tmp = 0.0;
	if (NaChar <= -8.8e+133)
		tmp = t_0 - (NdChar / (-1.0 + ((Ec / KbT) + (-1.0 + ((mu * ((-1.0 / KbT) - (Vef / (mu * KbT)))) - (EDonor / KbT))))));
	elseif (NaChar <= 5e-101)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	else
		tmp = t_0 + (NdChar / (1.0 - ((Ec / KbT) - (1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -8.8e+133], N[(t$95$0 - N[(NdChar / N[(-1.0 + N[(N[(Ec / KbT), $MachinePrecision] + N[(-1.0 + N[(N[(mu * N[(N[(-1.0 / KbT), $MachinePrecision] - N[(Vef / N[(mu * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 5e-101], 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[(N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 - N[(N[(Ec / KbT), $MachinePrecision] - N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -8.8e133

   1. Initial program 100.0%

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

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

   6. Taylor expanded in mu around inf 70.4%

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

   if -8.8e133 < NaChar < 5.0000000000000001e-101

   1. Initial program 100.0%

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

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

      1. +-commutative 65.2%

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

   7. Simplified 65.2%

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

   if 5.0000000000000001e-101 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 67.1%

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

4. Final simplification 66.6%

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

Alternative 11: 61.2% accurate, 1.6× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -2.5e+128], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.2e-103], 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[(N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 - N[(N[(Ec / KbT), $MachinePrecision] - N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.5e128

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 67.2%

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

   if -2.5e128 < NaChar < 2.1999999999999999e-103

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

      1. +-commutative 65.4%

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

   7. Simplified 65.4%

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

   if 2.1999999999999999e-103 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 67.1%

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

4. Final simplification 66.3%

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

Alternative 12: 60.5% accurate, 1.6× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT))))))
   (if (<= NaChar -2.7e+128)
     (+ t_0 (* NdChar 0.5))
     (if (<= NaChar 1e-98)
       (+
        (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
        (/
         NaChar
         (+
          1.0
          (-
           (+ 1.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
           (/ mu KbT)))))
       (+ t_0 (/ NdChar (- 1.0 (- -1.0 (/ mu KbT)))))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (Ev - (mu - EAccept))) / KbT)));
	tmp = 0.0;
	if (NaChar <= -2.7e+128)
		tmp = t_0 + (NdChar * 0.5);
	elseif (NaChar <= 1e-98)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	else
		tmp = t_0 + (NdChar / (1.0 - (-1.0 - (mu / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -2.7e+128], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1e-98], 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[(N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 - N[(-1.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.70000000000000001e128

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 67.2%

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

   if -2.70000000000000001e128 < NaChar < 9.99999999999999939e-99

   1. Initial program 100.0%

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

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

      1. +-commutative 65.4%

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

   7. Simplified 65.4%

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

   if 9.99999999999999939e-99 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 74.4%

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

   6. Taylor expanded in mu around 0 63.8%

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

      1. +-commutative 63.8%

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

   8. Simplified 63.8%

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

4. Final simplification 65.2%

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

Alternative 13: 40.4% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{\frac{Ev}{KbT} + 2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{if}\;NaChar \leq -2.5 \cdot 10^{+128}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NaChar \leq -9.5 \cdot 10^{+52}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NaChar \leq -3.3 \cdot 10^{-112}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;NaChar \leq 310000000:\\ \;\;\;\;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
         (-
          (/ NaChar (+ (/ Ev KbT) 2.0))
          (/ NdChar (- -1.0 (exp (/ EDonor KbT))))))
        (t_1 (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))))
   (if (<= NaChar -2.5e+128)
     t_1
     (if (<= NaChar -9.5e+52)
       t_0
       (if (<= NaChar -3.3e-112)
         (- (/ NaChar 2.0) (/ NdChar (- -1.0 (exp (/ Ec (- KbT))))))
         (if (<= NaChar 310000000.0) 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 = (NaChar / ((Ev / KbT) + 2.0)) - (NdChar / (-1.0 - exp((EDonor / KbT))));
	double t_1 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	double tmp;
	if (NaChar <= -2.5e+128) {
		tmp = t_1;
	} else if (NaChar <= -9.5e+52) {
		tmp = t_0;
	} else if (NaChar <= -3.3e-112) {
		tmp = (NaChar / 2.0) - (NdChar / (-1.0 - exp((Ec / -KbT))));
	} else if (NaChar <= 310000000.0) {
		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 = (nachar / ((ev / kbt) + 2.0d0)) - (ndchar / ((-1.0d0) - exp((edonor / kbt))))
    t_1 = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 2.0d0)
    if (nachar <= (-2.5d+128)) then
        tmp = t_1
    else if (nachar <= (-9.5d+52)) then
        tmp = t_0
    else if (nachar <= (-3.3d-112)) then
        tmp = (nachar / 2.0d0) - (ndchar / ((-1.0d0) - exp((ec / -kbt))))
    else if (nachar <= 310000000.0d0) 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 = (NaChar / ((Ev / KbT) + 2.0)) - (NdChar / (-1.0 - Math.exp((EDonor / KbT))));
	double t_1 = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
	double tmp;
	if (NaChar <= -2.5e+128) {
		tmp = t_1;
	} else if (NaChar <= -9.5e+52) {
		tmp = t_0;
	} else if (NaChar <= -3.3e-112) {
		tmp = (NaChar / 2.0) - (NdChar / (-1.0 - Math.exp((Ec / -KbT))));
	} else if (NaChar <= 310000000.0) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / ((Ev / KbT) + 2.0)) - (NdChar / (-1.0 - math.exp((EDonor / KbT))))
	t_1 = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	tmp = 0
	if NaChar <= -2.5e+128:
		tmp = t_1
	elif NaChar <= -9.5e+52:
		tmp = t_0
	elif NaChar <= -3.3e-112:
		tmp = (NaChar / 2.0) - (NdChar / (-1.0 - math.exp((Ec / -KbT))))
	elif NaChar <= 310000000.0:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)) - Float64(NdChar / Float64(-1.0 - exp(Float64(EDonor / KbT)))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0))
	tmp = 0.0
	if (NaChar <= -2.5e+128)
		tmp = t_1;
	elseif (NaChar <= -9.5e+52)
		tmp = t_0;
	elseif (NaChar <= -3.3e-112)
		tmp = Float64(Float64(NaChar / 2.0) - Float64(NdChar / Float64(-1.0 - exp(Float64(Ec / Float64(-KbT))))));
	elseif (NaChar <= 310000000.0)
		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 = (NaChar / ((Ev / KbT) + 2.0)) - (NdChar / (-1.0 - exp((EDonor / KbT))));
	t_1 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	tmp = 0.0;
	if (NaChar <= -2.5e+128)
		tmp = t_1;
	elseif (NaChar <= -9.5e+52)
		tmp = t_0;
	elseif (NaChar <= -3.3e-112)
		tmp = (NaChar / 2.0) - (NdChar / (-1.0 - exp((Ec / -KbT))));
	elseif (NaChar <= 310000000.0)
		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[(N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(NdChar / N[(-1.0 - N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -2.5e+128], t$95$1, If[LessEqual[NaChar, -9.5e+52], t$95$0, If[LessEqual[NaChar, -3.3e-112], N[(N[(NaChar / 2.0), $MachinePrecision] - N[(NdChar / N[(-1.0 - N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 310000000.0], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.5e128 or 3.1e8 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 63.8%

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

   6. Taylor expanded in EDonor around inf 53.7%

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

   7. Taylor expanded in EDonor around 0 43.5%

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

   if -2.5e128 < NaChar < -9.49999999999999994e52 or -3.3000000000000001e-112 < NaChar < 3.1e8

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in Ev around inf 72.2%

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

   6. Taylor expanded in EDonor around inf 51.5%

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

   7. Taylor expanded in Ev around 0 43.0%

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

   if -9.49999999999999994e52 < NaChar < -3.3000000000000001e-112

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ec around inf 54.7%

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

      1. associate-*r/ 54.7%

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

      2. mul-1-neg 54.7%

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

   8. Simplified 54.7%

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

4. Final simplification 44.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.5 \cdot 10^{+128}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;NaChar \leq -9.5 \cdot 10^{+52}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + 2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -3.3 \cdot 10^{-112}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;NaChar \leq 310000000:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + 2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 60.6% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT))))))
   (if (<= NaChar -3.4e+128)
     (+ t_0 (* NdChar 0.5))
     (if (<= NaChar 7.8e-94)
       (+
        (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
        (/ NaChar (+ (/ Ev KbT) 2.0)))
       (+ t_0 (/ NdChar (- 1.0 (- -1.0 (/ mu KbT)))))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - N[(mu - EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -3.4e+128], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 7.8e-94], 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[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 - N[(-1.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -3.3999999999999999e128

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 67.2%

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

   if -3.3999999999999999e128 < NaChar < 7.8000000000000004e-94

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around 0 60.1%

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

   if 7.8000000000000004e-94 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 73.4%

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

   6. Taylor expanded in mu around 0 63.6%

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

      1. +-commutative 63.6%

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

   8. Simplified 63.6%

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

4. Final simplification 62.4%

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

Alternative 15: 59.9% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.5e128 or 15500 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 65.2%

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

   6. Taylor expanded in KbT around inf 63.8%

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

   if -2.5e128 < NaChar < 15500

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around 0 60.6%

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

4. Final simplification 61.9%

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

Alternative 16: 56.3% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -6.4e53 or 3.5e7 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.6%

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

   6. Taylor expanded in KbT around inf 60.5%

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

   if -6.4e53 < NaChar < 3.5e7

   1. Initial program 100.0%

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

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

4. Final simplification 59.8%

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

Alternative 17: 53.1% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.6500000000000001e53 or 4e5 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.6%

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

   6. Taylor expanded in KbT around inf 60.5%

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

   if -2.6500000000000001e53 < NaChar < 4e5

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EDonor around 0 54.2%

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

      1. +-commutative 67.1%

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

   8. Simplified 54.2%

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

4. Final simplification 57.2%

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

Alternative 18: 50.5% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -2.6e-102) (not (<= NaChar 7.5e-100)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT))))
    (* NdChar 0.5))
   (- (/ NaChar (+ (/ Ev KbT) 2.0)) (/ NdChar (- -1.0 (exp (/ EDonor KbT)))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.59999999999999986e-102 or 7.50000000000000015e-100 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 61.9%

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

   6. Taylor expanded in KbT around inf 58.7%

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

   if -2.59999999999999986e-102 < NaChar < 7.50000000000000015e-100

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in Ev around inf 74.9%

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

   6. Taylor expanded in EDonor around inf 49.7%

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

   7. Taylor expanded in Ev around 0 43.5%

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

4. Final simplification 53.3%

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

Alternative 19: 36.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := KbT \cdot \frac{NdChar}{Vef}\\ \mathbf{if}\;Vef \leq -3.8 \cdot 10^{+100}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_0\\ \mathbf{elif}\;Vef \leq 3.8 \cdot 10^{+247}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + t\_0\\ \end{array} \end{array} \]

FPCore

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(KbT * N[(NdChar / Vef), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.8e+100], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[Vef, 3.8e+247], N[(N[(NaChar / 2.0), $MachinePrecision] - N[(NdChar / N[(-1.0 - N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -3.79999999999999963e100

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Vef around inf 42.6%

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

      1. associate-/l* 51.8%

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

   8. Simplified 51.8%

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

   9. Taylor expanded in Ev around inf 35.4%

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

   if -3.79999999999999963e100 < Vef < 3.80000000000000022e247

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 39.6%

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

   if 3.80000000000000022e247 < 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 KbT around inf 34.9%

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

   6. Taylor expanded in Vef around inf 44.3%

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

      1. associate-/l* 68.0%

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

   8. Simplified 68.0%

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

   9. Taylor expanded in Vef around inf 68.0%

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

4. Final simplification 40.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -3.8 \cdot 10^{+100}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + KbT \cdot \frac{NdChar}{Vef}\\ \mathbf{elif}\;Vef \leq 3.8 \cdot 10^{+247}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + KbT \cdot \frac{NdChar}{Vef}\\ \end{array} \]
5. Add Preprocessing

Alternative 20: 34.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := KbT \cdot \frac{NdChar}{Vef}\\ \mathbf{if}\;Vef \leq -6.2 \cdot 10^{+97}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_0\\ \mathbf{elif}\;Vef \leq 1.15 \cdot 10^{+248}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* KbT (/ NdChar Vef))))
   (if (<= Vef -6.2e+97)
     (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)
     (if (<= Vef 1.15e+248)
       (- (/ NaChar 2.0) (/ NdChar (- -1.0 (exp (/ EDonor KbT)))))
       (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) t_0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(KbT * N[(NdChar / Vef), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -6.2e+97], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[Vef, 1.15e+248], N[(N[(NaChar / 2.0), $MachinePrecision] - N[(NdChar / N[(-1.0 - N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -6.19999999999999962e97

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Vef around inf 42.6%

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

      1. associate-/l* 51.8%

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

   8. Simplified 51.8%

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

   9. Taylor expanded in Ev around inf 35.4%

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

   if -6.19999999999999962e97 < Vef < 1.1500000000000001e248

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 39.6%

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

   if 1.1500000000000001e248 < 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 KbT around inf 34.9%

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

   6. Taylor expanded in Vef around inf 44.3%

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

      1. associate-/l* 68.0%

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

   8. Simplified 68.0%

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

   9. Taylor expanded in EAccept around inf 30.4%

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

4. Final simplification 38.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -6.2 \cdot 10^{+97}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + KbT \cdot \frac{NdChar}{Vef}\\ \mathbf{elif}\;Vef \leq 1.15 \cdot 10^{+248}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + KbT \cdot \frac{NdChar}{Vef}\\ \end{array} \]
5. Add Preprocessing

Alternative 21: 39.2% accurate, 1.9× speedup

Math

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

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -1.9e+36) or not (NaChar <= 780000.0):
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	else:
		tmp = (NaChar / 2.0) - (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 ((NaChar <= -1.9e+36) || !(NaChar <= 780000.0))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0));
	else
		tmp = Float64(Float64(NaChar / 2.0) - Float64(NdChar / Float64(-1.0 - exp(Float64(Ec / Float64(-KbT))))));
	end
	return tmp
end

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.90000000000000012e36 or 7.8e5 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 64.0%

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

   6. Taylor expanded in EDonor around inf 54.1%

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

   7. Taylor expanded in EDonor around 0 41.4%

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

   if -1.90000000000000012e36 < NaChar < 7.8e5

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ec around inf 42.7%

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

      1. associate-*r/ 42.7%

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

      2. mul-1-neg 42.7%

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

   8. Simplified 42.7%

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

4. Final simplification 42.1%

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

Alternative 22: 38.8% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.7e-127) (not (<= NaChar 225000.0)))
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
   (- (/ NaChar 2.0) (/ NdChar (- -1.0 (exp (/ EDonor KbT)))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.6999999999999999e-127 or 225000 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev 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}{\frac{Ev}{KbT}}}} \]

   6. Taylor expanded in EDonor around inf 53.6%

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

   7. Taylor expanded in EDonor around 0 41.9%

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

   if -1.6999999999999999e-127 < NaChar < 225000

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in EDonor around inf 63.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 KbT around inf 42.7%

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

4. Final simplification 42.3%

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

Alternative 23: 40.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;mu \leq -4.9 \cdot 10^{+176} \lor \neg \left(mu \leq 3.2 \cdot 10^{+126}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} - \frac{NdChar}{-1 - e^{\frac{EDonor}{KbT}}}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[mu, -4.9e+176], N[Not[LessEqual[mu, 3.2e+126]], $MachinePrecision]], N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] - N[(NdChar / N[(-1.0 - N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if mu < -4.9e176 or 3.1999999999999998e126 < mu

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in mu around inf 88.1%

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

   6. Taylor expanded in KbT around inf 36.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \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+ 36.8%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \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 36.8%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \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 36.8%

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

   9. Taylor expanded in mu around inf 40.0%

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

       1. associate-*r/ 40.0%

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

       2. associate-*r* 40.0%

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

       3. neg-mul-1 40.0%

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

   11. Simplified 40.0%

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

   12. Taylor expanded in NdChar around inf 46.5%

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

   if -4.9e176 < mu < 3.1999999999999998e126

   1. Initial program 100.0%

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

   6. Taylor expanded in KbT around inf 38.6%

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

4. Final simplification 40.9%

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

Alternative 24: 39.4% accurate, 2.0× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -5.1999999999999996e68

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 70.7%

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

   6. Taylor expanded in KbT around inf 50.6%

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

   7. Taylor expanded in mu around inf 50.7%

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

      1. clear-num 50.7%

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

      2. inv-pow 50.7%

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

   9. Applied egg-rr 50.7%

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

       1. unpow-1 50.7%

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

       2. associate-/l* 51.1%

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

   11. Simplified 51.1%

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

   if -5.1999999999999996e68 < KbT < 1.9499999999999999e65

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 25.1%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \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+ 25.1%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \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 25.1%

         \[\leadsto \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \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 25.1%

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

   9. Taylor expanded in mu around inf 25.9%

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

       1. associate-*r/ 25.9%

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

       2. associate-*r* 25.9%

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

       3. neg-mul-1 25.9%

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

   11. Simplified 25.9%

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

   12. Taylor expanded in NdChar around inf 31.0%

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

   if 1.9499999999999999e65 < 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 67.7%

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

   6. Taylor expanded in KbT around inf 46.6%

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

   7. Taylor expanded in Vef around 0 46.9%

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

4. Final simplification 38.0%

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

Alternative 25: 28.7% accurate, 6.4× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -8.2e+55)
   (+
    (/ NaChar 2.0)
    (/
     NdChar
     (+
      1.0
      (-
       (-
        1.0
        (- (* mu (+ (/ -1.0 KbT) (/ -1.0 (* KbT (/ mu Vef))))) (/ EDonor KbT)))
       (/ Ec KbT)))))
   (if (<= KbT 4.5e+151)
     (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (/ EDonor KbT))))
     (+ (* 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 (KbT <= -8.2e+55) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + ((1.0 - ((mu * ((-1.0 / KbT) + (-1.0 / (KbT * (mu / Vef))))) - (EDonor / KbT))) - (Ec / KbT))));
	} else if (KbT <= 4.5e+151) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (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 (kbt <= (-8.2d+55)) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + ((1.0d0 - ((mu * (((-1.0d0) / kbt) + ((-1.0d0) / (kbt * (mu / vef))))) - (edonor / kbt))) - (ec / kbt))))
    else if (kbt <= 4.5d+151) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + (edonor / kbt)))
    else
        tmp = (ndchar * 0.5d0) + (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 (KbT <= -8.2e+55) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + ((1.0 - ((mu * ((-1.0 / KbT) + (-1.0 / (KbT * (mu / Vef))))) - (EDonor / KbT))) - (Ec / KbT))));
	} else if (KbT <= 4.5e+151) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -8.2e+55)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 - Float64(Float64(mu * Float64(Float64(-1.0 / KbT) + Float64(-1.0 / Float64(KbT * Float64(mu / Vef))))) - Float64(EDonor / KbT))) - Float64(Ec / KbT)))));
	elseif (KbT <= 4.5e+151)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT))));
	else
		tmp = Float64(Float64(NdChar * 0.5) + 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 (KbT <= -8.2e+55)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + ((1.0 - ((mu * ((-1.0 / KbT) + (-1.0 / (KbT * (mu / Vef))))) - (EDonor / KbT))) - (Ec / KbT))));
	elseif (KbT <= 4.5e+151)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	else
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -8.19999999999999962e55

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 72.4%

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

   6. Taylor expanded in KbT around inf 50.2%

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

   7. Taylor expanded in mu around inf 50.2%

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

      1. clear-num 50.2%

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

      2. inv-pow 50.2%

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

   9. Applied egg-rr 50.2%

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

       1. unpow-1 50.2%

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

       2. associate-/l* 50.6%

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

   11. Simplified 50.6%

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

   if -8.19999999999999962e55 < KbT < 4.4999999999999999e151

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 9.6%

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

   7. Taylor expanded in mu around inf 8.9%

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

   8. Taylor expanded in EDonor around inf 17.2%

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

   if 4.4999999999999999e151 < 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 70.6%

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

   6. Taylor expanded in KbT around inf 59.6%

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

   7. Taylor expanded in KbT around inf 60.1%

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

4. Final simplification 29.8%

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

Alternative 26: 29.1% accurate, 6.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -7.8 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 - \left(\frac{Ec}{KbT} + \left(-1 + \left(Vef \cdot \left(\frac{-1}{KbT} - \frac{mu}{Vef \cdot KbT}\right) - \frac{EDonor}{KbT}\right)\right)\right)}\\ \mathbf{elif}\;KbT \leq 6.2 \cdot 10^{+149}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -7.8e+55)
   (+
    (/ NaChar 2.0)
    (/
     NdChar
     (-
      1.0
      (+
       (/ Ec KbT)
       (+
        -1.0
        (- (* Vef (- (/ -1.0 KbT) (/ mu (* Vef KbT)))) (/ EDonor KbT)))))))
   (if (<= KbT 6.2e+149)
     (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (/ EDonor KbT))))
     (+ (* 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 (KbT <= -7.8e+55) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 - ((Ec / KbT) + (-1.0 + ((Vef * ((-1.0 / KbT) - (mu / (Vef * KbT)))) - (EDonor / KbT))))));
	} else if (KbT <= 6.2e+149) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (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 (kbt <= (-7.8d+55)) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 - ((ec / kbt) + ((-1.0d0) + ((vef * (((-1.0d0) / kbt) - (mu / (vef * kbt)))) - (edonor / kbt))))))
    else if (kbt <= 6.2d+149) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + (edonor / kbt)))
    else
        tmp = (ndchar * 0.5d0) + (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 (KbT <= -7.8e+55) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 - ((Ec / KbT) + (-1.0 + ((Vef * ((-1.0 / KbT) - (mu / (Vef * KbT)))) - (EDonor / KbT))))));
	} else if (KbT <= 6.2e+149) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -7.8e+55:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 - ((Ec / KbT) + (-1.0 + ((Vef * ((-1.0 / KbT) - (mu / (Vef * KbT)))) - (EDonor / KbT))))))
	elif KbT <= 6.2e+149:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)))
	else:
		tmp = (NdChar * 0.5) + (NaChar / 2.0)
	return tmp

Julia

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -7.80000000000000054e55

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 72.4%

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

   6. Taylor expanded in KbT around inf 50.2%

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

   7. Taylor expanded in Vef around inf 50.3%

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

      1. *-commutative 50.3%

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

   9. Simplified 50.3%

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

   if -7.80000000000000054e55 < KbT < 6.19999999999999974e149

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 9.6%

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

   7. Taylor expanded in mu around inf 8.9%

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

   8. Taylor expanded in EDonor around inf 17.2%

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

   if 6.19999999999999974e149 < 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 70.6%

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

   6. Taylor expanded in KbT around inf 59.6%

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

   7. Taylor expanded in KbT around inf 60.1%

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

4. Final simplification 29.7%

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

Alternative 27: 29.1% accurate, 7.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -8 \cdot 10^{+55}:\\ \;\;\;\;\frac{NdChar}{1 - \left(\frac{Ec}{KbT} - \left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right)\right)} + \frac{NaChar}{2}\\ \mathbf{elif}\;KbT \leq 1.75 \cdot 10^{+147}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -8e+55)
   (+
    (/
     NdChar
     (-
      1.0
      (- (/ Ec KbT) (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT)))))))
    (/ NaChar 2.0))
   (if (<= KbT 1.75e+147)
     (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (/ EDonor KbT))))
     (+ (* 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 (KbT <= -8e+55) {
		tmp = (NdChar / (1.0 - ((Ec / KbT) - (1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))))))) + (NaChar / 2.0);
	} else if (KbT <= 1.75e+147) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (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 (kbt <= (-8d+55)) then
        tmp = (ndchar / (1.0d0 - ((ec / kbt) - (1.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt))))))) + (nachar / 2.0d0)
    else if (kbt <= 1.75d+147) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + (edonor / kbt)))
    else
        tmp = (ndchar * 0.5d0) + (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 (KbT <= -8e+55) {
		tmp = (NdChar / (1.0 - ((Ec / KbT) - (1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))))))) + (NaChar / 2.0);
	} else if (KbT <= 1.75e+147) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -8e+55:
		tmp = (NdChar / (1.0 - ((Ec / KbT) - (1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))))))) + (NaChar / 2.0)
	elif KbT <= 1.75e+147:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)))
	else:
		tmp = (NdChar * 0.5) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -8e+55)
		tmp = Float64(Float64(NdChar / Float64(1.0 - Float64(Float64(Ec / KbT) - Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT))))))) + Float64(NaChar / 2.0));
	elseif (KbT <= 1.75e+147)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT))));
	else
		tmp = Float64(Float64(NdChar * 0.5) + 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 (KbT <= -8e+55)
		tmp = (NdChar / (1.0 - ((Ec / KbT) - (1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))))))) + (NaChar / 2.0);
	elseif (KbT <= 1.75e+147)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	else
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -8.00000000000000008e55

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 72.4%

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

   6. Taylor expanded in KbT around inf 50.2%

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

   if -8.00000000000000008e55 < KbT < 1.74999999999999987e147

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 9.6%

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

   7. Taylor expanded in mu around inf 8.9%

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

   8. Taylor expanded in EDonor around inf 17.2%

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

   if 1.74999999999999987e147 < 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 70.6%

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

   6. Taylor expanded in KbT around inf 59.6%

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

   7. Taylor expanded in KbT around inf 60.1%

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

4. Final simplification 29.7%

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

Alternative 28: 29.1% accurate, 9.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(2 + \left(\frac{mu}{KbT} + \frac{EDonor}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;KbT \leq 2.6 \cdot 10^{+150}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -9.2e+55)
   (+
    (/ NaChar 2.0)
    (/ NdChar (- (+ 2.0 (+ (/ mu KbT) (/ EDonor KbT))) (/ Ec KbT))))
   (if (<= KbT 2.6e+150)
     (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (/ EDonor KbT))))
     (+ (* 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 (KbT <= -9.2e+55) {
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((mu / KbT) + (EDonor / KbT))) - (Ec / KbT)));
	} else if (KbT <= 2.6e+150) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (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 (kbt <= (-9.2d+55)) then
        tmp = (nachar / 2.0d0) + (ndchar / ((2.0d0 + ((mu / kbt) + (edonor / kbt))) - (ec / kbt)))
    else if (kbt <= 2.6d+150) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + (edonor / kbt)))
    else
        tmp = (ndchar * 0.5d0) + (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 (KbT <= -9.2e+55) {
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((mu / KbT) + (EDonor / KbT))) - (Ec / KbT)));
	} else if (KbT <= 2.6e+150) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -9.2e+55:
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((mu / KbT) + (EDonor / KbT))) - (Ec / KbT)))
	elif KbT <= 2.6e+150:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)))
	else:
		tmp = (NdChar * 0.5) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -9.2e+55)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(mu / KbT) + Float64(EDonor / KbT))) - Float64(Ec / KbT))));
	elseif (KbT <= 2.6e+150)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT))));
	else
		tmp = Float64(Float64(NdChar * 0.5) + 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 (KbT <= -9.2e+55)
		tmp = (NaChar / 2.0) + (NdChar / ((2.0 + ((mu / KbT) + (EDonor / KbT))) - (Ec / KbT)));
	elseif (KbT <= 2.6e+150)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	else
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -9.2e+55], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(mu / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.6e+150], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -9.1999999999999995e55

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 72.4%

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

   6. Taylor expanded in KbT around inf 50.2%

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

   7. Taylor expanded in Vef around 0 50.0%

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

   if -9.1999999999999995e55 < KbT < 2.60000000000000006e150

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 9.6%

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

   7. Taylor expanded in mu around inf 8.9%

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

   8. Taylor expanded in EDonor around inf 17.2%

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

   if 2.60000000000000006e150 < 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 70.6%

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

   6. Taylor expanded in KbT around inf 59.6%

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

   7. Taylor expanded in KbT around inf 60.1%

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

4. Final simplification 29.7%

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

Alternative 29: 29.0% accurate, 9.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right) + 2}\\ \mathbf{elif}\;KbT \leq 9.8 \cdot 10^{+148}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -9.2e+55)
   (+
    (/ NaChar 2.0)
    (/ NdChar (+ (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))) 2.0)))
   (if (<= KbT 9.8e+148)
     (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (/ EDonor KbT))))
     (+ (* 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 (KbT <= -9.2e+55) {
		tmp = (NaChar / 2.0) + (NdChar / (((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))) + 2.0));
	} else if (KbT <= 9.8e+148) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (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 (kbt <= (-9.2d+55)) then
        tmp = (nachar / 2.0d0) + (ndchar / (((edonor / kbt) + ((vef / kbt) + (mu / kbt))) + 2.0d0))
    else if (kbt <= 9.8d+148) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + (edonor / kbt)))
    else
        tmp = (ndchar * 0.5d0) + (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 (KbT <= -9.2e+55) {
		tmp = (NaChar / 2.0) + (NdChar / (((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))) + 2.0));
	} else if (KbT <= 9.8e+148) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	} else {
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -9.2e+55:
		tmp = (NaChar / 2.0) + (NdChar / (((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))) + 2.0))
	elif KbT <= 9.8e+148:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)))
	else:
		tmp = (NdChar * 0.5) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -9.2e+55)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT))) + 2.0)));
	elseif (KbT <= 9.8e+148)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT))));
	else
		tmp = Float64(Float64(NdChar * 0.5) + 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 (KbT <= -9.2e+55)
		tmp = (NaChar / 2.0) + (NdChar / (((EDonor / KbT) + ((Vef / KbT) + (mu / KbT))) + 2.0));
	elseif (KbT <= 9.8e+148)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (EDonor / KbT)));
	else
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -9.2e+55], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 9.8e+148], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -9.1999999999999995e55

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 72.4%

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

   6. Taylor expanded in KbT around inf 50.2%

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

   7. Taylor expanded in Ec around 0 49.1%

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

   if -9.1999999999999995e55 < KbT < 9.8e148

   1. Initial program 100.0%

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

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

   6. Taylor expanded in KbT around inf 9.6%

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

   7. Taylor expanded in mu around inf 8.9%

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

   8. Taylor expanded in EDonor around inf 17.2%

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

   if 9.8e148 < 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 70.6%

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

   6. Taylor expanded in KbT around inf 59.6%

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

   7. Taylor expanded in KbT around inf 60.1%

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

4. Final simplification 29.5%

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

Alternative 30: 27.7% accurate, 32.7× speedup

Math

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

FPCore

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

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

6. Taylor expanded in KbT around inf 24.6%

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

7. Taylor expanded in KbT around inf 26.2%

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

8. Final simplification 26.2%

   \[\leadsto NdChar \cdot 0.5 + \frac{NaChar}{2} \]
9. Add Preprocessing

Reproduce

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