Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 31.6s

Alternatives: 26

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = 3.0311801719613823e-268
  2. Ec = 1.0288371026527455e-223
  3. Vef = -1.8727276283398357e+242
  4. EDonor = -2.714806254427104e-56
  5. mu = 2.0697511657012978e-53
  6. KbT = 1.5045676628969758e+147
  7. NaChar = -1.5199665011947185e-267
  8. Ev = -8.028517775009747e-243
  9. EAccept = -2.988830409866538e+262

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
  (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev 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(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - 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(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - 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(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT))));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

3. Simplified 99.9%

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

4. Final simplification 99.9%

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

Alternative 2: 64.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ t_2 := t_1 + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{if}\;mu \leq -6.9 \cdot 10^{+190}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq -1.4 \cdot 10^{-5}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 1.68 \cdot 10^{-217}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 7.2 \cdot 10^{-134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 0.00019:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 4.8 \cdot 10^{+106}:\\ \;\;\;\;t_2\\ \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 (/ EAccept KbT)))))
        (t_2 (+ t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))))
   (if (<= mu -6.9e+190)
     t_0
     (if (<= mu -1.4e-5)
       t_2
       (if (<= mu 1.68e-217)
         (+ t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (if (<= mu 7.2e-134)
           (+
            (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
            (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
           (if (<= mu 0.00019)
             (+
              (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
              (/ NaChar (- (+ 2.0 (+ (/ Ev KbT) (/ Vef KbT))) (/ mu KbT))))
             (if (<= mu 4.8e+106) t_2 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((EAccept / KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	double tmp;
	if (mu <= -6.9e+190) {
		tmp = t_0;
	} else if (mu <= -1.4e-5) {
		tmp = t_2;
	} else if (mu <= 1.68e-217) {
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= 7.2e-134) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (mu <= 0.00019) {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)));
	} else if (mu <= 4.8e+106) {
		tmp = t_2;
	} 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) :: t_2
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_1 = nachar / (1.0d0 + exp((eaccept / kbt)))
    t_2 = t_1 + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    if (mu <= (-6.9d+190)) then
        tmp = t_0
    else if (mu <= (-1.4d-5)) then
        tmp = t_2
    else if (mu <= 1.68d-217) then
        tmp = t_1 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= 7.2d-134) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (mu <= 0.00019d0) then
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / ((2.0d0 + ((ev / kbt) + (vef / kbt))) - (mu / kbt)))
    else if (mu <= 4.8d+106) then
        tmp = t_2
    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((EAccept / KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	double tmp;
	if (mu <= -6.9e+190) {
		tmp = t_0;
	} else if (mu <= -1.4e-5) {
		tmp = t_2;
	} else if (mu <= 1.68e-217) {
		tmp = t_1 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= 7.2e-134) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (mu <= 0.00019) {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)));
	} else if (mu <= 4.8e+106) {
		tmp = t_2;
	} 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((EAccept / KbT)))
	t_2 = t_1 + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	tmp = 0
	if mu <= -6.9e+190:
		tmp = t_0
	elif mu <= -1.4e-5:
		tmp = t_2
	elif mu <= 1.68e-217:
		tmp = t_1 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 7.2e-134:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif mu <= 0.00019:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)))
	elif mu <= 4.8e+106:
		tmp = t_2
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))
	t_2 = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))))
	tmp = 0.0
	if (mu <= -6.9e+190)
		tmp = t_0;
	elseif (mu <= -1.4e-5)
		tmp = t_2;
	elseif (mu <= 1.68e-217)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 7.2e-134)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (mu <= 0.00019)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(Ev / KbT) + Float64(Vef / KbT))) - Float64(mu / KbT))));
	elseif (mu <= 4.8e+106)
		tmp = t_2;
	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((EAccept / KbT)));
	t_2 = t_1 + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	tmp = 0.0;
	if (mu <= -6.9e+190)
		tmp = t_0;
	elseif (mu <= -1.4e-5)
		tmp = t_2;
	elseif (mu <= 1.68e-217)
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 7.2e-134)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (mu <= 0.00019)
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)));
	elseif (mu <= 4.8e+106)
		tmp = t_2;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -6.9e+190], t$95$0, If[LessEqual[mu, -1.4e-5], t$95$2, If[LessEqual[mu, 1.68e-217], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 7.2e-134], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 0.00019], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(2.0 + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 4.8e+106], t$95$2, t$95$0]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if mu < -6.9e190 or 4.8000000000000001e106 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 87.2%

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

   5. 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}}}} \]
   6. Step-by-step derivation

      1. associate-*r/ 39.2%

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

      2. mul-1-neg 39.2%

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

   7. Simplified 83.2%

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

   if -6.9e190 < mu < -1.39999999999999998e-5 or 1.9000000000000001e-4 < mu < 4.8000000000000001e106

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 75.8%

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

   5. Taylor expanded in EDonor around 0 70.1%

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

   if -1.39999999999999998e-5 < mu < 1.67999999999999995e-217

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

   4. Taylor expanded in EAccept around inf 79.9%

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

   5. Taylor expanded in EDonor around inf 68.1%

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

   if 1.67999999999999995e-217 < mu < 7.1999999999999998e-134

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

   4. Taylor expanded in Vef around inf 95.1%

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

   5. Taylor expanded in Ec around inf 84.5%

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

      1. associate-*r/ 25.4%

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

      2. mul-1-neg 25.4%

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

   7. Simplified 84.5%

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

   if 7.1999999999999998e-134 < mu < 1.9000000000000001e-4

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

   4. Taylor expanded in KbT around inf 74.6%

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

   5. Taylor expanded in EAccept around 0 75.5%

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

4. Final simplification 74.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -6.9 \cdot 10^{+190}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.4 \cdot 10^{-5}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.68 \cdot 10^{-217}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 7.2 \cdot 10^{-134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 0.00019:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 4.8 \cdot 10^{+106}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \end{array} \]

Alternative 3: 67.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;Vef \leq -4.8 \cdot 10^{+271}:\\ \;\;\;\;t_0 + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;Vef \leq -3.8 \cdot 10^{+212}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq -5.4 \cdot 10^{-10}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq 4.3 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{KbT}{\frac{Vef}{NaChar}}\\ \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 (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= Vef -4.8e+271)
     (+ t_0 (/ NaChar (+ (/ Vef KbT) 2.0)))
     (if (<= Vef -3.8e+212)
       (+
        (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
        (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
       (if (<= Vef -5.4e-10)
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
         (if (<= Vef 4.3e+135)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
            (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
           (+ t_0 (/ KbT (/ Vef NaChar)))))))))

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 + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (Vef <= -4.8e+271) {
		tmp = t_0 + (NaChar / ((Vef / KbT) + 2.0));
	} else if (Vef <= -3.8e+212) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (Vef <= -5.4e-10) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	} else if (Vef <= 4.3e+135) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else {
		tmp = t_0 + (KbT / (Vef / NaChar));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    if (vef <= (-4.8d+271)) then
        tmp = t_0 + (nachar / ((vef / kbt) + 2.0d0))
    else if (vef <= (-3.8d+212)) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (vef <= (-5.4d-10)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    else if (vef <= 4.3d+135) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    else
        tmp = t_0 + (kbt / (vef / nachar))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (Vef <= -4.8e+271) {
		tmp = t_0 + (NaChar / ((Vef / KbT) + 2.0));
	} else if (Vef <= -3.8e+212) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (Vef <= -5.4e-10) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	} else if (Vef <= 4.3e+135) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else {
		tmp = t_0 + (KbT / (Vef / NaChar));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if Vef <= -4.8e+271:
		tmp = t_0 + (NaChar / ((Vef / KbT) + 2.0))
	elif Vef <= -3.8e+212:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif Vef <= -5.4e-10:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	elif Vef <= 4.3e+135:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	else:
		tmp = t_0 + (KbT / (Vef / NaChar))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (Vef <= -4.8e+271)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(Vef / KbT) + 2.0)));
	elseif (Vef <= -3.8e+212)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (Vef <= -5.4e-10)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))));
	elseif (Vef <= 4.3e+135)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	else
		tmp = Float64(t_0 + Float64(KbT / Float64(Vef / NaChar)));
	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 + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (Vef <= -4.8e+271)
		tmp = t_0 + (NaChar / ((Vef / KbT) + 2.0));
	elseif (Vef <= -3.8e+212)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (Vef <= -5.4e-10)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	elseif (Vef <= 4.3e+135)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	else
		tmp = t_0 + (KbT / (Vef / NaChar));
	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[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -4.8e+271], N[(t$95$0 + N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -3.8e+212], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -5.4e-10], 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[Vef, 4.3e+135], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(KbT / N[(Vef / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 5 regimes

2. if Vef < -4.80000000000000022e271

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 100.0%

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

   5. Taylor expanded in Vef around 0 86.4%

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

   if -4.80000000000000022e271 < Vef < -3.79999999999999988e212

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in Vef around inf 99.8%

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

   5. Taylor expanded in Ec around inf 86.5%

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

      1. associate-*r/ 13.0%

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

      2. mul-1-neg 13.0%

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

   7. Simplified 86.5%

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

   if -3.79999999999999988e212 < Vef < -5.4e-10

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 74.8%

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

   5. Taylor expanded in EDonor around 0 66.0%

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

   if -5.4e-10 < Vef < 4.29999999999999972e135

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

   4. Taylor expanded in mu around inf 77.3%

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

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

   4. Taylor expanded in KbT around inf 62.6%

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

   5. Taylor expanded in Vef around inf 65.9%

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

      1. associate-/l* 72.3%

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

   7. Simplified 72.3%

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

4. Final simplification 75.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -4.8 \cdot 10^{+271}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;Vef \leq -3.8 \cdot 10^{+212}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq -5.4 \cdot 10^{-10}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq 4.3 \cdot 10^{+135}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{Vef}{NaChar}}\\ \end{array} \]

Alternative 4: 62.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_3 := t_2 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{if}\;mu \leq -4.8 \cdot 10^{+107}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;mu \leq -3.75 \cdot 10^{+24}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t_2\\ \mathbf{elif}\;mu \leq -1.25 \cdot 10^{-165}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -3.1 \cdot 10^{-198}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 4.6 \cdot 10^{-226}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq 1.85 \cdot 10^{+143}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \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 (+ EDonor (- Vef Ec))) KbT))))
          (/ NaChar (- (+ 2.0 (+ (/ Ev KbT) (/ Vef KbT))) (/ mu KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
        (t_3 (+ t_2 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))))
   (if (<= mu -4.8e+107)
     t_3
     (if (<= mu -3.75e+24)
       (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_2)
       (if (<= mu -1.25e-165)
         t_1
         (if (<= mu -3.1e-198)
           t_0
           (if (<= mu 4.6e-226) t_1 (if (<= mu 1.85e+143) t_0 t_3))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)));
	double t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double t_2 = NdChar / (1.0 + exp((mu / KbT)));
	double t_3 = t_2 + (NaChar / (1.0 + exp((-mu / KbT))));
	double tmp;
	if (mu <= -4.8e+107) {
		tmp = t_3;
	} else if (mu <= -3.75e+24) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_2;
	} else if (mu <= -1.25e-165) {
		tmp = t_1;
	} else if (mu <= -3.1e-198) {
		tmp = t_0;
	} else if (mu <= 4.6e-226) {
		tmp = t_1;
	} else if (mu <= 1.85e+143) {
		tmp = t_0;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / ((2.0d0 + ((ev / kbt) + (vef / kbt))) - (mu / kbt)))
    t_1 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    t_2 = ndchar / (1.0d0 + exp((mu / kbt)))
    t_3 = t_2 + (nachar / (1.0d0 + exp((-mu / kbt))))
    if (mu <= (-4.8d+107)) then
        tmp = t_3
    else if (mu <= (-3.75d+24)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_2
    else if (mu <= (-1.25d-165)) then
        tmp = t_1
    else if (mu <= (-3.1d-198)) then
        tmp = t_0
    else if (mu <= 4.6d-226) then
        tmp = t_1
    else if (mu <= 1.85d+143) then
        tmp = t_0
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double t_2 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double t_3 = t_2 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double tmp;
	if (mu <= -4.8e+107) {
		tmp = t_3;
	} else if (mu <= -3.75e+24) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_2;
	} else if (mu <= -1.25e-165) {
		tmp = t_1;
	} else if (mu <= -3.1e-198) {
		tmp = t_0;
	} else if (mu <= 4.6e-226) {
		tmp = t_1;
	} else if (mu <= 1.85e+143) {
		tmp = t_0;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)))
	t_1 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	t_2 = NdChar / (1.0 + math.exp((mu / KbT)))
	t_3 = t_2 + (NaChar / (1.0 + math.exp((-mu / KbT))))
	tmp = 0
	if mu <= -4.8e+107:
		tmp = t_3
	elif mu <= -3.75e+24:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_2
	elif mu <= -1.25e-165:
		tmp = t_1
	elif mu <= -3.1e-198:
		tmp = t_0
	elif mu <= 4.6e-226:
		tmp = t_1
	elif mu <= 1.85e+143:
		tmp = t_0
	else:
		tmp = t_3
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(Ev / KbT) + Float64(Vef / KbT))) - Float64(mu / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	t_3 = Float64(t_2 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	tmp = 0.0
	if (mu <= -4.8e+107)
		tmp = t_3;
	elseif (mu <= -3.75e+24)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_2);
	elseif (mu <= -1.25e-165)
		tmp = t_1;
	elseif (mu <= -3.1e-198)
		tmp = t_0;
	elseif (mu <= 4.6e-226)
		tmp = t_1;
	elseif (mu <= 1.85e+143)
		tmp = t_0;
	else
		tmp = t_3;
	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 + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)));
	t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	t_2 = NdChar / (1.0 + exp((mu / KbT)));
	t_3 = t_2 + (NaChar / (1.0 + exp((-mu / KbT))));
	tmp = 0.0;
	if (mu <= -4.8e+107)
		tmp = t_3;
	elseif (mu <= -3.75e+24)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_2;
	elseif (mu <= -1.25e-165)
		tmp = t_1;
	elseif (mu <= -3.1e-198)
		tmp = t_0;
	elseif (mu <= 4.6e-226)
		tmp = t_1;
	elseif (mu <= 1.85e+143)
		tmp = t_0;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(2.0 + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -4.8e+107], t$95$3, If[LessEqual[mu, -3.75e+24], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[mu, -1.25e-165], t$95$1, If[LessEqual[mu, -3.1e-198], t$95$0, If[LessEqual[mu, 4.6e-226], t$95$1, If[LessEqual[mu, 1.85e+143], t$95$0, t$95$3]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if mu < -4.8000000000000001e107 or 1.8500000000000001e143 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 86.5%

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

   5. Taylor expanded in mu around inf 81.5%

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

      1. associate-*r/ 39.3%

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

      2. mul-1-neg 39.3%

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

   7. Simplified 81.5%

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

   if -4.8000000000000001e107 < mu < -3.75000000000000007e24

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 73.8%

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

   5. Taylor expanded in mu around inf 60.1%

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

   if -3.75000000000000007e24 < mu < -1.24999999999999995e-165 or -3.0999999999999998e-198 < mu < 4.6000000000000001e-226

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

   4. Taylor expanded in EAccept around inf 79.6%

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

   5. Taylor expanded in EDonor around inf 71.1%

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

   if -1.24999999999999995e-165 < mu < -3.0999999999999998e-198 or 4.6000000000000001e-226 < mu < 1.8500000000000001e143

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 66.5%

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

   5. Taylor expanded in EAccept around 0 69.3%

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

4. Final simplification 72.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -4.8 \cdot 10^{+107}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -3.75 \cdot 10^{+24}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.25 \cdot 10^{-165}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq -3.1 \cdot 10^{-198}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 4.6 \cdot 10^{-226}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.85 \cdot 10^{+143}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \end{array} \]

Alternative 5: 77.1% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= mu -1e+72) (not (<= mu 5.5e+103)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
    (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if mu < -9.99999999999999944e71 or 5.50000000000000001e103 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 85.7%

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

   if -9.99999999999999944e71 < mu < 5.50000000000000001e103

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

   4. Taylor expanded in EAccept around inf 81.0%

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

4. Final simplification 82.9%

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

Alternative 6: 73.2% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= Ev -3.5e+136)
     (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (if (<= Ev 1.55e-135)
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -3.5e+136) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (Ev <= 1.55e-135) {
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	} else {
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (Ev <= -3.5e+136)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (Ev <= 1.55e-135)
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	else
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -3.50000000000000001e136

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

   4. Taylor expanded in Ev around inf 96.5%

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

   if -3.50000000000000001e136 < Ev < 1.55e-135

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 76.4%

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

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

   4. Taylor expanded in EAccept around inf 68.8%

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

4. Final simplification 75.7%

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

Alternative 7: 46.2% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -3.7 \cdot 10^{+36}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq -5.6 \cdot 10^{-244}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq -2 \cdot 10^{-282}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 1.65 \cdot 10^{-215}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 5.8:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq 1.1 \cdot 10^{+93}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 5.8 \cdot 10^{+94}:\\ \;\;\;\;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 (/ EAccept KbT)))))
        (t_1 (- (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))) (/ (* KbT NaChar) mu)))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= KbT -3.7e+36)
     t_2
     (if (<= KbT -5.6e-244)
       t_0
       (if (<= KbT -2e-282)
         t_1
         (if (<= KbT 1.65e-215)
           t_0
           (if (<= KbT 5.8)
             t_2
             (if (<= KbT 1.1e+93) t_0 (if (<= KbT 5.8e+94) 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((EAccept / KbT)));
	double t_1 = (NdChar / (1.0 + exp((-Ec / KbT)))) - ((KbT * NaChar) / mu);
	double t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -3.7e+36) {
		tmp = t_2;
	} else if (KbT <= -5.6e-244) {
		tmp = t_0;
	} else if (KbT <= -2e-282) {
		tmp = t_1;
	} else if (KbT <= 1.65e-215) {
		tmp = t_0;
	} else if (KbT <= 5.8) {
		tmp = t_2;
	} else if (KbT <= 1.1e+93) {
		tmp = t_0;
	} else if (KbT <= 5.8e+94) {
		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((eaccept / kbt)))
    t_1 = (ndchar / (1.0d0 + exp((-ec / kbt)))) - ((kbt * nachar) / mu)
    t_2 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-3.7d+36)) then
        tmp = t_2
    else if (kbt <= (-5.6d-244)) then
        tmp = t_0
    else if (kbt <= (-2d-282)) then
        tmp = t_1
    else if (kbt <= 1.65d-215) then
        tmp = t_0
    else if (kbt <= 5.8d0) then
        tmp = t_2
    else if (kbt <= 1.1d+93) then
        tmp = t_0
    else if (kbt <= 5.8d+94) 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((EAccept / KbT)));
	double t_1 = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) - ((KbT * NaChar) / mu);
	double t_2 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -3.7e+36) {
		tmp = t_2;
	} else if (KbT <= -5.6e-244) {
		tmp = t_0;
	} else if (KbT <= -2e-282) {
		tmp = t_1;
	} else if (KbT <= 1.65e-215) {
		tmp = t_0;
	} else if (KbT <= 5.8) {
		tmp = t_2;
	} else if (KbT <= 1.1e+93) {
		tmp = t_0;
	} else if (KbT <= 5.8e+94) {
		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((EAccept / KbT)))
	t_1 = (NdChar / (1.0 + math.exp((-Ec / KbT)))) - ((KbT * NaChar) / mu)
	t_2 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -3.7e+36:
		tmp = t_2
	elif KbT <= -5.6e-244:
		tmp = t_0
	elif KbT <= -2e-282:
		tmp = t_1
	elif KbT <= 1.65e-215:
		tmp = t_0
	elif KbT <= 5.8:
		tmp = t_2
	elif KbT <= 1.1e+93:
		tmp = t_0
	elif KbT <= 5.8e+94:
		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(EAccept / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) - Float64(Float64(KbT * NaChar) / mu))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -3.7e+36)
		tmp = t_2;
	elseif (KbT <= -5.6e-244)
		tmp = t_0;
	elseif (KbT <= -2e-282)
		tmp = t_1;
	elseif (KbT <= 1.65e-215)
		tmp = t_0;
	elseif (KbT <= 5.8)
		tmp = t_2;
	elseif (KbT <= 1.1e+93)
		tmp = t_0;
	elseif (KbT <= 5.8e+94)
		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((EAccept / KbT)));
	t_1 = (NdChar / (1.0 + exp((-Ec / KbT)))) - ((KbT * NaChar) / mu);
	t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -3.7e+36)
		tmp = t_2;
	elseif (KbT <= -5.6e-244)
		tmp = t_0;
	elseif (KbT <= -2e-282)
		tmp = t_1;
	elseif (KbT <= 1.65e-215)
		tmp = t_0;
	elseif (KbT <= 5.8)
		tmp = t_2;
	elseif (KbT <= 1.1e+93)
		tmp = t_0;
	elseif (KbT <= 5.8e+94)
		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[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(KbT * NaChar), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -3.7e+36], t$95$2, If[LessEqual[KbT, -5.6e-244], t$95$0, If[LessEqual[KbT, -2e-282], t$95$1, If[LessEqual[KbT, 1.65e-215], t$95$0, If[LessEqual[KbT, 5.8], t$95$2, If[LessEqual[KbT, 1.1e+93], t$95$0, If[LessEqual[KbT, 5.8e+94], t$95$1, t$95$2]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -3.70000000000000029e36 or 1.6499999999999999e-215 < KbT < 5.79999999999999982 or 5.7999999999999997e94 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 58.5%

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

   if -3.70000000000000029e36 < KbT < -5.60000000000000026e-244 or -2e-282 < KbT < 1.6499999999999999e-215 or 5.79999999999999982 < KbT < 1.10000000000000011e93

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 29.3%

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

   5. Taylor expanded in EAccept around inf 23.5%

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

   6. Taylor expanded in NdChar around 0 47.5%

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

   if -5.60000000000000026e-244 < KbT < -2e-282 or 1.10000000000000011e93 < KbT < 5.7999999999999997e94

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 59.4%

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

   5. Taylor expanded in mu around inf 83.3%

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

      1. associate-*r/ 83.3%

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

      2. mul-1-neg 83.3%

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

   7. Simplified 83.3%

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

   8. Taylor expanded in Ec around inf 66.5%

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

      1. associate-*r/ 66.5%

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

      2. mul-1-neg 66.5%

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

   10. Simplified 66.5%

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

4. Final simplification 54.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.7 \cdot 10^{+36}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -5.6 \cdot 10^{-244}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq -2 \cdot 10^{-282}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ \mathbf{elif}\;KbT \leq 1.65 \cdot 10^{-215}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 5.8:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.1 \cdot 10^{+93}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 5.8 \cdot 10^{+94}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 8: 50.3% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{KbT}{\frac{Vef}{NaChar}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;NaChar \leq -1.5 \cdot 10^{+15}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NaChar \leq -1.05 \cdot 10^{-61}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -3.4 \cdot 10^{-185}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 1.25 \cdot 10^{-110}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq 1550000000 \lor \neg \left(NaChar \leq 1.42 \cdot 10^{+54}\right):\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{KbT}{\frac{EAccept}{NaChar}}\\ \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 (+ EDonor (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 (/ KbT (/ Vef NaChar))))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= NaChar -1.5e+15)
     t_2
     (if (<= NaChar -1.05e-61)
       t_1
       (if (<= NaChar -3.4e-185)
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
         (if (<= NaChar 1.25e-110)
           t_1
           (if (or (<= NaChar 1550000000.0) (not (<= NaChar 1.42e+54)))
             t_2
             (+ t_0 (/ KbT (/ EAccept NaChar))))))))))

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 + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (KbT / (Vef / NaChar));
	double t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -1.5e+15) {
		tmp = t_2;
	} else if (NaChar <= -1.05e-61) {
		tmp = t_1;
	} else if (NaChar <= -3.4e-185) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (NaChar <= 1.25e-110) {
		tmp = t_1;
	} else if ((NaChar <= 1550000000.0) || !(NaChar <= 1.42e+54)) {
		tmp = t_2;
	} else {
		tmp = t_0 + (KbT / (EAccept / NaChar));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = t_0 + (kbt / (vef / nachar))
    t_2 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (nachar <= (-1.5d+15)) then
        tmp = t_2
    else if (nachar <= (-1.05d-61)) then
        tmp = t_1
    else if (nachar <= (-3.4d-185)) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if (nachar <= 1.25d-110) then
        tmp = t_1
    else if ((nachar <= 1550000000.0d0) .or. (.not. (nachar <= 1.42d+54))) then
        tmp = t_2
    else
        tmp = t_0 + (kbt / (eaccept / nachar))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (KbT / (Vef / NaChar));
	double t_2 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -1.5e+15) {
		tmp = t_2;
	} else if (NaChar <= -1.05e-61) {
		tmp = t_1;
	} else if (NaChar <= -3.4e-185) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if (NaChar <= 1.25e-110) {
		tmp = t_1;
	} else if ((NaChar <= 1550000000.0) || !(NaChar <= 1.42e+54)) {
		tmp = t_2;
	} else {
		tmp = t_0 + (KbT / (EAccept / NaChar));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = t_0 + (KbT / (Vef / NaChar))
	t_2 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if NaChar <= -1.5e+15:
		tmp = t_2
	elif NaChar <= -1.05e-61:
		tmp = t_1
	elif NaChar <= -3.4e-185:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif NaChar <= 1.25e-110:
		tmp = t_1
	elif (NaChar <= 1550000000.0) or not (NaChar <= 1.42e+54):
		tmp = t_2
	else:
		tmp = t_0 + (KbT / (EAccept / NaChar))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + Float64(KbT / Float64(Vef / NaChar)))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (NaChar <= -1.5e+15)
		tmp = t_2;
	elseif (NaChar <= -1.05e-61)
		tmp = t_1;
	elseif (NaChar <= -3.4e-185)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (NaChar <= 1.25e-110)
		tmp = t_1;
	elseif ((NaChar <= 1550000000.0) || !(NaChar <= 1.42e+54))
		tmp = t_2;
	else
		tmp = Float64(t_0 + Float64(KbT / Float64(EAccept / NaChar)));
	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 + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = t_0 + (KbT / (Vef / NaChar));
	t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (NaChar <= -1.5e+15)
		tmp = t_2;
	elseif (NaChar <= -1.05e-61)
		tmp = t_1;
	elseif (NaChar <= -3.4e-185)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (NaChar <= 1.25e-110)
		tmp = t_1;
	elseif ((NaChar <= 1550000000.0) || ~((NaChar <= 1.42e+54)))
		tmp = t_2;
	else
		tmp = t_0 + (KbT / (EAccept / NaChar));
	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[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(KbT / N[(Vef / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.5e+15], t$95$2, If[LessEqual[NaChar, -1.05e-61], t$95$1, If[LessEqual[NaChar, -3.4e-185], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.25e-110], t$95$1, If[Or[LessEqual[NaChar, 1550000000.0], N[Not[LessEqual[NaChar, 1.42e+54]], $MachinePrecision]], t$95$2, N[(t$95$0 + N[(KbT / N[(EAccept / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -1.5e15 or 1.25e-110 < NaChar < 1.55e9 or 1.41999999999999995e54 < NaChar

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

   4. Taylor expanded in KbT around inf 57.8%

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

   if -1.5e15 < NaChar < -1.05e-61 or -3.3999999999999998e-185 < NaChar < 1.25e-110

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 73.2%

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

   5. Taylor expanded in Vef around inf 62.6%

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

      1. associate-/l* 62.7%

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

   7. Simplified 62.7%

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

   if -1.05e-61 < NaChar < -3.3999999999999998e-185

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 35.7%

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

   5. Taylor expanded in EAccept around inf 31.4%

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

   6. Taylor expanded in NdChar around 0 39.3%

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

   if 1.55e9 < NaChar < 1.41999999999999995e54

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 60.2%

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

   5. Taylor expanded in EAccept around inf 43.8%

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

      1. associate-/l* 43.8%

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

   7. Simplified 43.8%

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

4. Final simplification 57.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.5 \cdot 10^{+15}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq -1.05 \cdot 10^{-61}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{Vef}{NaChar}}\\ \mathbf{elif}\;NaChar \leq -3.4 \cdot 10^{-185}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 1.25 \cdot 10^{-110}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{Vef}{NaChar}}\\ \mathbf{elif}\;NaChar \leq 1550000000 \lor \neg \left(NaChar \leq 1.42 \cdot 10^{+54}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{EAccept}{NaChar}}\\ \end{array} \]

Alternative 9: 46.6% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{1}{\frac{\frac{mu}{KbT}}{NaChar}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -2.2 \cdot 10^{+134}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq -8.5 \cdot 10^{+72}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq -4.4 \cdot 10^{-120}:\\ \;\;\;\;t_0 + \frac{KbT}{\frac{Ev}{NaChar}}\\ \mathbf{elif}\;KbT \leq -3 \cdot 10^{-239}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 3.2 \cdot 10^{-225}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 8.6 \cdot 10^{+79}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 (/ 1.0 (/ (/ mu KbT) NaChar))))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= KbT -2.2e+134)
     t_2
     (if (<= KbT -8.5e+72)
       t_1
       (if (<= KbT -4.4e-120)
         (+ t_0 (/ KbT (/ Ev NaChar)))
         (if (<= KbT -3e-239)
           (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
           (if (<= KbT 3.2e-225)
             t_1
             (if (<= KbT 8.6e+79) t_2 (+ t_0 (/ 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 t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (1.0 / ((mu / KbT) / NaChar));
	double t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -2.2e+134) {
		tmp = t_2;
	} else if (KbT <= -8.5e+72) {
		tmp = t_1;
	} else if (KbT <= -4.4e-120) {
		tmp = t_0 + (KbT / (Ev / NaChar));
	} else if (KbT <= -3e-239) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (KbT <= 3.2e-225) {
		tmp = t_1;
	} else if (KbT <= 8.6e+79) {
		tmp = t_2;
	} else {
		tmp = t_0 + (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) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = t_0 + (1.0d0 / ((mu / kbt) / nachar))
    t_2 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-2.2d+134)) then
        tmp = t_2
    else if (kbt <= (-8.5d+72)) then
        tmp = t_1
    else if (kbt <= (-4.4d-120)) then
        tmp = t_0 + (kbt / (ev / nachar))
    else if (kbt <= (-3d-239)) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if (kbt <= 3.2d-225) then
        tmp = t_1
    else if (kbt <= 8.6d+79) then
        tmp = t_2
    else
        tmp = t_0 + (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 t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (1.0 / ((mu / KbT) / NaChar));
	double t_2 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -2.2e+134) {
		tmp = t_2;
	} else if (KbT <= -8.5e+72) {
		tmp = t_1;
	} else if (KbT <= -4.4e-120) {
		tmp = t_0 + (KbT / (Ev / NaChar));
	} else if (KbT <= -3e-239) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if (KbT <= 3.2e-225) {
		tmp = t_1;
	} else if (KbT <= 8.6e+79) {
		tmp = t_2;
	} else {
		tmp = t_0 + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = t_0 + (1.0 / ((mu / KbT) / NaChar))
	t_2 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -2.2e+134:
		tmp = t_2
	elif KbT <= -8.5e+72:
		tmp = t_1
	elif KbT <= -4.4e-120:
		tmp = t_0 + (KbT / (Ev / NaChar))
	elif KbT <= -3e-239:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif KbT <= 3.2e-225:
		tmp = t_1
	elif KbT <= 8.6e+79:
		tmp = t_2
	else:
		tmp = t_0 + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + Float64(1.0 / Float64(Float64(mu / KbT) / NaChar)))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -2.2e+134)
		tmp = t_2;
	elseif (KbT <= -8.5e+72)
		tmp = t_1;
	elseif (KbT <= -4.4e-120)
		tmp = Float64(t_0 + Float64(KbT / Float64(Ev / NaChar)));
	elseif (KbT <= -3e-239)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (KbT <= 3.2e-225)
		tmp = t_1;
	elseif (KbT <= 8.6e+79)
		tmp = t_2;
	else
		tmp = Float64(t_0 + Float64(NaChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = t_0 + (1.0 / ((mu / KbT) / NaChar));
	t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -2.2e+134)
		tmp = t_2;
	elseif (KbT <= -8.5e+72)
		tmp = t_1;
	elseif (KbT <= -4.4e-120)
		tmp = t_0 + (KbT / (Ev / NaChar));
	elseif (KbT <= -3e-239)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (KbT <= 3.2e-225)
		tmp = t_1;
	elseif (KbT <= 8.6e+79)
		tmp = t_2;
	else
		tmp = t_0 + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(1.0 / N[(N[(mu / KbT), $MachinePrecision] / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.2e+134], t$95$2, If[LessEqual[KbT, -8.5e+72], t$95$1, If[LessEqual[KbT, -4.4e-120], N[(t$95$0 + N[(KbT / N[(Ev / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -3e-239], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.2e-225], t$95$1, If[LessEqual[KbT, 8.6e+79], t$95$2, N[(t$95$0 + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if KbT < -2.2e134 or 3.19999999999999975e-225 < KbT < 8.6000000000000006e79

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

   4. Taylor expanded in KbT around inf 59.3%

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

   if -2.2e134 < KbT < -8.5000000000000004e72 or -2.9999999999999998e-239 < KbT < 3.19999999999999975e-225

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 57.9%

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

   5. Taylor expanded in mu around inf 65.8%

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

      1. associate-*r/ 65.8%

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

      2. mul-1-neg 65.8%

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

   7. Simplified 65.8%

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

      1. clear-num 65.8%

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

      2. inv-pow 65.8%

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

      3. add-sqr-sqrt 48.3%

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

      4. sqrt-unprod 65.7%

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

      5. sqr-neg 65.7%

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

      6. sqrt-unprod 41.7%

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

      7. add-sqr-sqrt 65.9%

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

   9. Applied egg-rr 65.9%

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

       1. unpow-1 65.9%

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

       2. associate-/r* 67.5%

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

   11. Simplified 67.5%

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

   if -8.5000000000000004e72 < KbT < -4.40000000000000025e-120

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.6%

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

   5. Taylor expanded in Ev around inf 29.7%

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

      1. associate-/l* 31.0%

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

   7. Simplified 31.0%

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

   if -4.40000000000000025e-120 < KbT < -2.9999999999999998e-239

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 38.4%

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

   5. Taylor expanded in EAccept around inf 30.2%

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

   6. Taylor expanded in NdChar around 0 61.0%

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

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

   4. Taylor expanded in KbT around inf 74.2%

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

4. Final simplification 59.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.2 \cdot 10^{+134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -8.5 \cdot 10^{+72}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{1}{\frac{\frac{mu}{KbT}}{NaChar}}\\ \mathbf{elif}\;KbT \leq -4.4 \cdot 10^{-120}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{Ev}{NaChar}}\\ \mathbf{elif}\;KbT \leq -3 \cdot 10^{-239}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 3.2 \cdot 10^{-225}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{1}{\frac{\frac{mu}{KbT}}{NaChar}}\\ \mathbf{elif}\;KbT \leq 8.6 \cdot 10^{+79}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]

Alternative 10: 62.6% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= NdChar -2.1e-31)
     (+ t_0 (/ NaChar (- (+ 2.0 (+ (/ Ev KbT) (/ Vef KbT))) (/ mu KbT))))
     (if (<= NdChar 5.3e-12)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
        (/ NdChar (+ 1.0 (+ 1.0 (/ mu KbT)))))
       (+ t_0 (/ NaChar (+ (/ Vef 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 t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -2.1e-31) {
		tmp = t_0 + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)));
	} else if (NdChar <= 5.3e-12) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (mu / KbT))));
	} else {
		tmp = t_0 + (NaChar / ((Vef / 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) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    if (ndchar <= (-2.1d-31)) then
        tmp = t_0 + (nachar / ((2.0d0 + ((ev / kbt) + (vef / kbt))) - (mu / kbt)))
    else if (ndchar <= 5.3d-12) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (mu / kbt))))
    else
        tmp = t_0 + (nachar / ((vef / 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 t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -2.1e-31) {
		tmp = t_0 + (NaChar / ((2.0 + ((Ev / KbT) + (Vef / KbT))) - (mu / KbT)));
	} else if (NdChar <= 5.3e-12) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + (1.0 + (mu / KbT))));
	} else {
		tmp = t_0 + (NaChar / ((Vef / KbT) + 2.0));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -2.09999999999999991e-31

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 63.4%

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

   5. Taylor expanded in EAccept around 0 65.3%

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

   if -2.09999999999999991e-31 < NdChar < 5.29999999999999963e-12

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. 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(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]

   5. Taylor expanded in mu around 0 65.4%

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

   if 5.29999999999999963e-12 < NdChar

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

   4. Taylor expanded in Vef around inf 82.3%

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

   5. Taylor expanded in Vef around 0 65.9%

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

4. Final simplification 65.6%

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

Alternative 11: 46.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -2.2 \cdot 10^{+134}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq -6 \cdot 10^{+41}:\\ \;\;\;\;t_1 + \frac{KbT}{\frac{EAccept}{NaChar}}\\ \mathbf{elif}\;KbT \leq -6 \cdot 10^{-18}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq -1.18 \cdot 10^{-120}:\\ \;\;\;\;t_1 + \frac{KbT}{\frac{Ev}{NaChar}}\\ \mathbf{elif}\;KbT \leq -2.1 \cdot 10^{-239}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 3.3 \cdot 10^{-224}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ \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 (/ EAccept KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= KbT -2.2e+134)
     t_2
     (if (<= KbT -6e+41)
       (+ t_1 (/ KbT (/ EAccept NaChar)))
       (if (<= KbT -6e-18)
         t_0
         (if (<= KbT -1.18e-120)
           (+ t_1 (/ KbT (/ Ev NaChar)))
           (if (<= KbT -2.1e-239)
             t_0
             (if (<= KbT 3.3e-224)
               (-
                (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))
                (/ (* KbT NaChar) mu))
               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((EAccept / KbT)));
	double t_1 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -2.2e+134) {
		tmp = t_2;
	} else if (KbT <= -6e+41) {
		tmp = t_1 + (KbT / (EAccept / NaChar));
	} else if (KbT <= -6e-18) {
		tmp = t_0;
	} else if (KbT <= -1.18e-120) {
		tmp = t_1 + (KbT / (Ev / NaChar));
	} else if (KbT <= -2.1e-239) {
		tmp = t_0;
	} else if (KbT <= 3.3e-224) {
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	} 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((eaccept / kbt)))
    t_1 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_2 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-2.2d+134)) then
        tmp = t_2
    else if (kbt <= (-6d+41)) then
        tmp = t_1 + (kbt / (eaccept / nachar))
    else if (kbt <= (-6d-18)) then
        tmp = t_0
    else if (kbt <= (-1.18d-120)) then
        tmp = t_1 + (kbt / (ev / nachar))
    else if (kbt <= (-2.1d-239)) then
        tmp = t_0
    else if (kbt <= 3.3d-224) then
        tmp = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) - ((kbt * nachar) / mu)
    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((EAccept / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_2 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -2.2e+134) {
		tmp = t_2;
	} else if (KbT <= -6e+41) {
		tmp = t_1 + (KbT / (EAccept / NaChar));
	} else if (KbT <= -6e-18) {
		tmp = t_0;
	} else if (KbT <= -1.18e-120) {
		tmp = t_1 + (KbT / (Ev / NaChar));
	} else if (KbT <= -2.1e-239) {
		tmp = t_0;
	} else if (KbT <= 3.3e-224) {
		tmp = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	} 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((EAccept / KbT)))
	t_1 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_2 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -2.2e+134:
		tmp = t_2
	elif KbT <= -6e+41:
		tmp = t_1 + (KbT / (EAccept / NaChar))
	elif KbT <= -6e-18:
		tmp = t_0
	elif KbT <= -1.18e-120:
		tmp = t_1 + (KbT / (Ev / NaChar))
	elif KbT <= -2.1e-239:
		tmp = t_0
	elif KbT <= 3.3e-224:
		tmp = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu)
	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(EAccept / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -2.2e+134)
		tmp = t_2;
	elseif (KbT <= -6e+41)
		tmp = Float64(t_1 + Float64(KbT / Float64(EAccept / NaChar)));
	elseif (KbT <= -6e-18)
		tmp = t_0;
	elseif (KbT <= -1.18e-120)
		tmp = Float64(t_1 + Float64(KbT / Float64(Ev / NaChar)));
	elseif (KbT <= -2.1e-239)
		tmp = t_0;
	elseif (KbT <= 3.3e-224)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))) - Float64(Float64(KbT * NaChar) / mu));
	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((EAccept / KbT)));
	t_1 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -2.2e+134)
		tmp = t_2;
	elseif (KbT <= -6e+41)
		tmp = t_1 + (KbT / (EAccept / NaChar));
	elseif (KbT <= -6e-18)
		tmp = t_0;
	elseif (KbT <= -1.18e-120)
		tmp = t_1 + (KbT / (Ev / NaChar));
	elseif (KbT <= -2.1e-239)
		tmp = t_0;
	elseif (KbT <= 3.3e-224)
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	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[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.2e+134], t$95$2, If[LessEqual[KbT, -6e+41], N[(t$95$1 + N[(KbT / N[(EAccept / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -6e-18], t$95$0, If[LessEqual[KbT, -1.18e-120], N[(t$95$1 + N[(KbT / N[(Ev / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2.1e-239], t$95$0, If[LessEqual[KbT, 3.3e-224], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(KbT * NaChar), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if KbT < -2.2e134 or 3.3000000000000001e-224 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 59.8%

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

   if -2.2e134 < KbT < -5.9999999999999997e41

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 70.4%

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

   5. Taylor expanded in EAccept around inf 45.3%

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

      1. associate-/l* 53.4%

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

   7. Simplified 53.4%

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

   if -5.9999999999999997e41 < KbT < -5.99999999999999966e-18 or -1.17999999999999999e-120 < KbT < -2.1000000000000002e-239

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 29.9%

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

   5. Taylor expanded in EAccept around inf 21.3%

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

   6. Taylor expanded in NdChar around 0 51.5%

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

   if -5.99999999999999966e-18 < KbT < -1.17999999999999999e-120

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 55.4%

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

   5. Taylor expanded in Ev around inf 35.8%

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

      1. associate-/l* 35.5%

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

   7. Simplified 35.5%

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

   if -2.1000000000000002e-239 < KbT < 3.3000000000000001e-224

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.3%

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

   5. Taylor expanded in mu around inf 66.0%

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

      1. associate-*r/ 66.0%

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

      2. mul-1-neg 66.0%

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

   7. Simplified 66.0%

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

   8. Taylor expanded in EDonor around 0 59.5%

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

4. Final simplification 56.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.2 \cdot 10^{+134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -6 \cdot 10^{+41}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{EAccept}{NaChar}}\\ \mathbf{elif}\;KbT \leq -6 \cdot 10^{-18}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq -1.18 \cdot 10^{-120}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{Ev}{NaChar}}\\ \mathbf{elif}\;KbT \leq -2.1 \cdot 10^{-239}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 3.3 \cdot 10^{-224}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 12: 52.5% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{KbT}{\frac{Vef}{NaChar}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;NaChar \leq -8 \cdot 10^{+14}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NaChar \leq -2.7 \cdot 10^{-62}:\\ \;\;\;\;t_0 + t_1\\ \mathbf{elif}\;NaChar \leq -4.7 \cdot 10^{-185}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -7.6 \cdot 10^{-291}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + t_1\\ \mathbf{elif}\;NaChar \leq 4.8 \cdot 10^{+53}:\\ \;\;\;\;t_0 + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1 (/ KbT (/ Vef NaChar)))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= NaChar -8e+14)
     t_2
     (if (<= NaChar -2.7e-62)
       (+ t_0 t_1)
       (if (<= NaChar -4.7e-185)
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
         (if (<= NaChar -7.6e-291)
           (+ (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))) t_1)
           (if (<= NaChar 4.8e+53) (+ t_0 (/ NaChar 2.0)) t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = KbT / (Vef / NaChar);
	double t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -8e+14) {
		tmp = t_2;
	} else if (NaChar <= -2.7e-62) {
		tmp = t_0 + t_1;
	} else if (NaChar <= -4.7e-185) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (NaChar <= -7.6e-291) {
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + t_1;
	} else if (NaChar <= 4.8e+53) {
		tmp = t_0 + (NaChar / 2.0);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = kbt / (vef / nachar)
    t_2 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (nachar <= (-8d+14)) then
        tmp = t_2
    else if (nachar <= (-2.7d-62)) then
        tmp = t_0 + t_1
    else if (nachar <= (-4.7d-185)) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if (nachar <= (-7.6d-291)) then
        tmp = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) + t_1
    else if (nachar <= 4.8d+53) then
        tmp = t_0 + (nachar / 2.0d0)
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = KbT / (Vef / NaChar);
	double t_2 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -8e+14) {
		tmp = t_2;
	} else if (NaChar <= -2.7e-62) {
		tmp = t_0 + t_1;
	} else if (NaChar <= -4.7e-185) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if (NaChar <= -7.6e-291) {
		tmp = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) + t_1;
	} else if (NaChar <= 4.8e+53) {
		tmp = t_0 + (NaChar / 2.0);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = KbT / (Vef / NaChar)
	t_2 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if NaChar <= -8e+14:
		tmp = t_2
	elif NaChar <= -2.7e-62:
		tmp = t_0 + t_1
	elif NaChar <= -4.7e-185:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif NaChar <= -7.6e-291:
		tmp = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))) + t_1
	elif NaChar <= 4.8e+53:
		tmp = t_0 + (NaChar / 2.0)
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(KbT / Float64(Vef / NaChar))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (NaChar <= -8e+14)
		tmp = t_2;
	elseif (NaChar <= -2.7e-62)
		tmp = Float64(t_0 + t_1);
	elseif (NaChar <= -4.7e-185)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (NaChar <= -7.6e-291)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))) + t_1);
	elseif (NaChar <= 4.8e+53)
		tmp = Float64(t_0 + Float64(NaChar / 2.0));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = KbT / (Vef / NaChar);
	t_2 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (NaChar <= -8e+14)
		tmp = t_2;
	elseif (NaChar <= -2.7e-62)
		tmp = t_0 + t_1;
	elseif (NaChar <= -4.7e-185)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (NaChar <= -7.6e-291)
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + t_1;
	elseif (NaChar <= 4.8e+53)
		tmp = t_0 + (NaChar / 2.0);
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(KbT / N[(Vef / NaChar), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -8e+14], t$95$2, If[LessEqual[NaChar, -2.7e-62], N[(t$95$0 + t$95$1), $MachinePrecision], If[LessEqual[NaChar, -4.7e-185], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -7.6e-291], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[NaChar, 4.8e+53], N[(t$95$0 + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if NaChar < -8e14 or 4.8e53 < NaChar

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

   4. Taylor expanded in KbT around inf 59.9%

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

   if -8e14 < NaChar < -2.70000000000000019e-62

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 66.3%

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

   5. Taylor expanded in Vef around inf 62.2%

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

      1. associate-/l* 62.2%

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

   7. Simplified 62.2%

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

   if -2.70000000000000019e-62 < NaChar < -4.7000000000000002e-185

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 35.7%

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

   5. Taylor expanded in EAccept around inf 31.4%

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

   6. Taylor expanded in NdChar around 0 39.3%

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

   if -4.7000000000000002e-185 < NaChar < -7.5999999999999995e-291

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 83.8%

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

   5. Taylor expanded in Vef around inf 74.5%

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

      1. associate-/l* 74.3%

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

   7. Simplified 74.3%

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

   8. Taylor expanded in EDonor around 0 74.3%

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

   if -7.5999999999999995e-291 < NaChar < 4.8e53

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 58.0%

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

4. Final simplification 58.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -8 \cdot 10^{+14}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq -2.7 \cdot 10^{-62}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{Vef}{NaChar}}\\ \mathbf{elif}\;NaChar \leq -4.7 \cdot 10^{-185}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -7.6 \cdot 10^{-291}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{KbT}{\frac{Vef}{NaChar}}\\ \mathbf{elif}\;NaChar \leq 4.8 \cdot 10^{+53}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 13: 63.0% accurate, 1.8× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.7e14 or 5.6e53 < NaChar

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

   4. Taylor expanded in mu around inf 75.7%

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

   5. Taylor expanded in mu around 0 63.7%

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

   if -2.7e14 < NaChar < 5.6e53

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 83.9%

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

   5. Taylor expanded in Vef around 0 67.9%

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

4. Final simplification 66.2%

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

Alternative 14: 45.9% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -2.3 \cdot 10^{+134}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq -5.5 \cdot 10^{+36}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq -8.2 \cdot 10^{-240}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.85 \cdot 10^{-224}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (-
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))
          (/ (* KbT NaChar) mu)))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= KbT -2.3e+134)
     t_1
     (if (<= KbT -5.5e+36)
       t_0
       (if (<= KbT -8.2e-240)
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
         (if (<= KbT 1.85e-224) t_0 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -2.3e+134) {
		tmp = t_1;
	} else if (KbT <= -5.5e+36) {
		tmp = t_0;
	} else if (KbT <= -8.2e-240) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (KbT <= 1.85e-224) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) - ((kbt * nachar) / mu)
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-2.3d+134)) then
        tmp = t_1
    else if (kbt <= (-5.5d+36)) then
        tmp = t_0
    else if (kbt <= (-8.2d-240)) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if (kbt <= 1.85d-224) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -2.3e+134) {
		tmp = t_1;
	} else if (KbT <= -5.5e+36) {
		tmp = t_0;
	} else if (KbT <= -8.2e-240) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if (KbT <= 1.85e-224) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu)
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -2.3e+134:
		tmp = t_1
	elif KbT <= -5.5e+36:
		tmp = t_0
	elif KbT <= -8.2e-240:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif KbT <= 1.85e-224:
		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(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))) - Float64(Float64(KbT * NaChar) / mu))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -2.3e+134)
		tmp = t_1;
	elseif (KbT <= -5.5e+36)
		tmp = t_0;
	elseif (KbT <= -8.2e-240)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (KbT <= 1.85e-224)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -2.3e+134)
		tmp = t_1;
	elseif (KbT <= -5.5e+36)
		tmp = t_0;
	elseif (KbT <= -8.2e-240)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (KbT <= 1.85e-224)
		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[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(KbT * NaChar), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.3e+134], t$95$1, If[LessEqual[KbT, -5.5e+36], t$95$0, If[LessEqual[KbT, -8.2e-240], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.85e-224], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.2999999999999998e134 or 1.8500000000000001e-224 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 59.8%

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

   if -2.2999999999999998e134 < KbT < -5.5000000000000002e36 or -8.2000000000000003e-240 < KbT < 1.8500000000000001e-224

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 59.0%

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

   5. Taylor expanded in mu around inf 61.6%

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

      1. associate-*r/ 61.6%

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

      2. mul-1-neg 61.6%

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

   7. Simplified 61.6%

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

   8. Taylor expanded in EDonor around 0 54.9%

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

   if -5.5000000000000002e36 < KbT < -8.2000000000000003e-240

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 31.5%

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

   5. Taylor expanded in EAccept around inf 23.8%

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

   6. Taylor expanded in NdChar around 0 49.2%

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

4. Final simplification 56.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.3 \cdot 10^{+134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -5.5 \cdot 10^{+36}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ \mathbf{elif}\;KbT \leq -8.2 \cdot 10^{-240}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.85 \cdot 10^{-224}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 15: 46.4% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -2.2 \cdot 10^{+134}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq -5.5 \cdot 10^{+41}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{EAccept}{NaChar}}\\ \mathbf{elif}\;KbT \leq -2.4 \cdot 10^{-239}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 3.4 \cdot 10^{-224}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= KbT -2.2e+134)
     t_0
     (if (<= KbT -5.5e+41)
       (+
        (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
        (/ KbT (/ EAccept NaChar)))
       (if (<= KbT -2.4e-239)
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
         (if (<= KbT 3.4e-224)
           (-
            (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))
            (/ (* KbT NaChar) mu))
           t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -2.2e+134) {
		tmp = t_0;
	} else if (KbT <= -5.5e+41) {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (KbT / (EAccept / NaChar));
	} else if (KbT <= -2.4e-239) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (KbT <= 3.4e-224) {
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-2.2d+134)) then
        tmp = t_0
    else if (kbt <= (-5.5d+41)) then
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (kbt / (eaccept / nachar))
    else if (kbt <= (-2.4d-239)) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if (kbt <= 3.4d-224) then
        tmp = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) - ((kbt * nachar) / mu)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -2.2e+134) {
		tmp = t_0;
	} else if (KbT <= -5.5e+41) {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (KbT / (EAccept / NaChar));
	} else if (KbT <= -2.4e-239) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if (KbT <= 3.4e-224) {
		tmp = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -2.2e+134:
		tmp = t_0
	elif KbT <= -5.5e+41:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (KbT / (EAccept / NaChar))
	elif KbT <= -2.4e-239:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif KbT <= 3.4e-224:
		tmp = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu)
	else:
		tmp = t_0
	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(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -2.2e+134)
		tmp = t_0;
	elseif (KbT <= -5.5e+41)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(KbT / Float64(EAccept / NaChar)));
	elseif (KbT <= -2.4e-239)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (KbT <= 3.4e-224)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))) - Float64(Float64(KbT * NaChar) / mu));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -2.2e+134)
		tmp = t_0;
	elseif (KbT <= -5.5e+41)
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (KbT / (EAccept / NaChar));
	elseif (KbT <= -2.4e-239)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (KbT <= 3.4e-224)
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) - ((KbT * NaChar) / mu);
	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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.2e+134], t$95$0, If[LessEqual[KbT, -5.5e+41], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(KbT / N[(EAccept / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2.4e-239], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.4e-224], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(KbT * NaChar), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -2.2e134 or 3.39999999999999992e-224 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 59.8%

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

   if -2.2e134 < KbT < -5.5000000000000003e41

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 70.4%

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

   5. Taylor expanded in EAccept around inf 45.3%

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

      1. associate-/l* 53.4%

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

   7. Simplified 53.4%

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

   if -5.5000000000000003e41 < KbT < -2.39999999999999993e-239

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 30.8%

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

   5. Taylor expanded in EAccept around inf 23.1%

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

   6. Taylor expanded in NdChar around 0 47.6%

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

   if -2.39999999999999993e-239 < KbT < 3.39999999999999992e-224

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.3%

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

   5. Taylor expanded in mu around inf 66.0%

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

      1. associate-*r/ 66.0%

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

      2. mul-1-neg 66.0%

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

   7. Simplified 66.0%

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

   8. Taylor expanded in EDonor around 0 59.5%

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

4. Final simplification 56.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.2 \cdot 10^{+134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -5.5 \cdot 10^{+41}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{KbT}{\frac{EAccept}{NaChar}}\\ \mathbf{elif}\;KbT \leq -2.4 \cdot 10^{-239}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 3.4 \cdot 10^{-224}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} - \frac{KbT \cdot NaChar}{mu}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 16: 61.3% accurate, 1.8× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -3.1e16 or 8.5000000000000002e53 < NaChar

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

   4. Taylor expanded in KbT around inf 59.9%

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

   if -3.1e16 < NaChar < 8.5000000000000002e53

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 83.9%

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

   5. Taylor expanded in Vef around 0 67.9%

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

4. Final simplification 64.7%

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

Alternative 17: 47.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -7.6 \cdot 10^{+36}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq -1.9 \cdot 10^{-240}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 8.6 \cdot 10^{-249}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{KbT}{\frac{Vef}{NaChar}}\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= KbT -7.6e+36)
     t_0
     (if (<= KbT -1.9e-240)
       (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
       (if (<= KbT 8.6e-249)
         (+
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))
          (/ KbT (/ Vef NaChar)))
         t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -7.6e+36) {
		tmp = t_0;
	} else if (KbT <= -1.9e-240) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (KbT <= 8.6e-249) {
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + (KbT / (Vef / NaChar));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-7.6d+36)) then
        tmp = t_0
    else if (kbt <= (-1.9d-240)) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if (kbt <= 8.6d-249) then
        tmp = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))) + (kbt / (vef / nachar))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -7.6e+36) {
		tmp = t_0;
	} else if (KbT <= -1.9e-240) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if (KbT <= 8.6e-249) {
		tmp = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) + (KbT / (Vef / NaChar));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -7.6e+36:
		tmp = t_0
	elif KbT <= -1.9e-240:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif KbT <= 8.6e-249:
		tmp = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))) + (KbT / (Vef / NaChar))
	else:
		tmp = t_0
	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(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -7.6e+36)
		tmp = t_0;
	elseif (KbT <= -1.9e-240)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (KbT <= 8.6e-249)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))) + Float64(KbT / Float64(Vef / NaChar)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -7.6e+36)
		tmp = t_0;
	elseif (KbT <= -1.9e-240)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (KbT <= 8.6e-249)
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)))) + (KbT / (Vef / NaChar));
	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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -7.6e+36], t$95$0, If[LessEqual[KbT, -1.9e-240], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 8.6e-249], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(KbT / N[(Vef / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -7.6000000000000005e36 or 8.6000000000000003e-249 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 54.1%

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

   if -7.6000000000000005e36 < KbT < -1.89999999999999994e-240

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 31.5%

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

   5. Taylor expanded in EAccept around inf 23.8%

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

   6. Taylor expanded in NdChar around 0 49.2%

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

   if -1.89999999999999994e-240 < KbT < 8.6000000000000003e-249

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 49.6%

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

   5. Taylor expanded in Vef around inf 61.6%

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

      1. associate-/l* 60.5%

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

   7. Simplified 60.5%

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

   8. Taylor expanded in EDonor around 0 55.9%

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

4. Final simplification 53.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -7.6 \cdot 10^{+36}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -1.9 \cdot 10^{-240}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 8.6 \cdot 10^{-249}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}} + \frac{KbT}{\frac{Vef}{NaChar}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 18: 37.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;Vef \leq -7.2 \cdot 10^{+134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{KbT}{\frac{Vef}{NdChar}}\\ \mathbf{elif}\;Vef \leq -7.6 \cdot 10^{-94}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;Vef \leq -3.3 \cdot 10^{-304}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;Vef \leq 2.5 \cdot 10^{-267} \lor \neg \left(Vef \leq 2.35 \cdot 10^{+130}\right):\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
   (if (<= Vef -7.2e+134)
     (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (/ KbT (/ Vef NdChar)))
     (if (<= Vef -7.6e-94)
       t_0
       (if (<= Vef -3.3e-304)
         (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (* NdChar 0.5))
         (if (or (<= Vef 2.5e-267) (not (<= Vef 2.35e+130)))
           t_0
           (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
	double tmp;
	if (Vef <= -7.2e+134) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (KbT / (Vef / NdChar));
	} else if (Vef <= -7.6e-94) {
		tmp = t_0;
	} else if (Vef <= -3.3e-304) {
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5);
	} else if ((Vef <= 2.5e-267) || !(Vef <= 2.35e+130)) {
		tmp = t_0;
	} else {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((eaccept / kbt)))
    if (vef <= (-7.2d+134)) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (kbt / (vef / ndchar))
    else if (vef <= (-7.6d-94)) then
        tmp = t_0
    else if (vef <= (-3.3d-304)) then
        tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar * 0.5d0)
    else if ((vef <= 2.5d-267) .or. (.not. (vef <= 2.35d+130))) then
        tmp = t_0
    else
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	double tmp;
	if (Vef <= -7.2e+134) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (KbT / (Vef / NdChar));
	} else if (Vef <= -7.6e-94) {
		tmp = t_0;
	} else if (Vef <= -3.3e-304) {
		tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar * 0.5);
	} else if ((Vef <= 2.5e-267) || !(Vef <= 2.35e+130)) {
		tmp = t_0;
	} else {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((EAccept / KbT)))
	tmp = 0
	if Vef <= -7.2e+134:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (KbT / (Vef / NdChar))
	elif Vef <= -7.6e-94:
		tmp = t_0
	elif Vef <= -3.3e-304:
		tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar * 0.5)
	elif (Vef <= 2.5e-267) or not (Vef <= 2.35e+130):
		tmp = t_0
	else:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))
	tmp = 0.0
	if (Vef <= -7.2e+134)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(KbT / Float64(Vef / NdChar)));
	elseif (Vef <= -7.6e-94)
		tmp = t_0;
	elseif (Vef <= -3.3e-304)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar * 0.5));
	elseif ((Vef <= 2.5e-267) || !(Vef <= 2.35e+130))
		tmp = t_0;
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
	tmp = 0.0;
	if (Vef <= -7.2e+134)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (KbT / (Vef / NdChar));
	elseif (Vef <= -7.6e-94)
		tmp = t_0;
	elseif (Vef <= -3.3e-304)
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5);
	elseif ((Vef <= 2.5e-267) || ~((Vef <= 2.35e+130)))
		tmp = t_0;
	else
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -7.2e+134], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(KbT / N[(Vef / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -7.6e-94], t$95$0, If[LessEqual[Vef, -3.3e-304], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[Vef, 2.5e-267], N[Not[LessEqual[Vef, 2.35e+130]], $MachinePrecision]], t$95$0, N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -7.19999999999999976e134

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

   4. Taylor expanded in Vef around inf 92.9%

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

   5. Taylor expanded in KbT around inf 52.0%

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

   6. Taylor expanded in Vef around inf 62.5%

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

      1. associate-/l* 64.8%

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

   8. Simplified 64.8%

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

   if -7.19999999999999976e134 < Vef < -7.59999999999999999e-94 or -3.30000000000000013e-304 < Vef < 2.5e-267 or 2.35000000000000023e130 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 36.8%

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

   5. Taylor expanded in EAccept around inf 32.5%

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

   6. Taylor expanded in NdChar around 0 47.5%

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

   if -7.59999999999999999e-94 < Vef < -3.30000000000000013e-304

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in KbT around inf 65.0%

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

   5. Taylor expanded in mu around inf 53.5%

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

      1. associate-*r/ 53.5%

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

      2. mul-1-neg 53.5%

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

   7. Simplified 53.5%

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

   if 2.5e-267 < Vef < 2.35000000000000023e130

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 76.1%

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

   5. Taylor expanded in KbT around inf 45.5%

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

4. Final simplification 50.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -7.2 \cdot 10^{+134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{KbT}{\frac{Vef}{NdChar}}\\ \mathbf{elif}\;Vef \leq -7.6 \cdot 10^{-94}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;Vef \leq -3.3 \cdot 10^{-304}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;Vef \leq 2.5 \cdot 10^{-267} \lor \neg \left(Vef \leq 2.35 \cdot 10^{+130}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]

Alternative 19: 41.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -6 \cdot 10^{+77}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 3.8 \cdot 10^{-210}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 1.25 \cdot 10^{-80}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 3.1 \cdot 10^{+90}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
        (t_1 (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (* NdChar 0.5))))
   (if (<= KbT -6e+77)
     t_1
     (if (<= KbT 3.8e-210)
       t_0
       (if (<= KbT 1.25e-80)
         t_1
         (if (<= KbT 3.1e+90)
           t_0
           (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (* NdChar 0.5))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
	double t_1 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -6e+77) {
		tmp = t_1;
	} else if (KbT <= 3.8e-210) {
		tmp = t_0;
	} else if (KbT <= 1.25e-80) {
		tmp = t_1;
	} else if (KbT <= 3.1e+90) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((eaccept / kbt)))
    t_1 = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-6d+77)) then
        tmp = t_1
    else if (kbt <= 3.8d-210) then
        tmp = t_0
    else if (kbt <= 1.25d-80) then
        tmp = t_1
    else if (kbt <= 3.1d+90) then
        tmp = t_0
    else
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar * 0.5d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -6e+77) {
		tmp = t_1;
	} else if (KbT <= 3.8e-210) {
		tmp = t_0;
	} else if (KbT <= 1.25e-80) {
		tmp = t_1;
	} else if (KbT <= 3.1e+90) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((EAccept / KbT)))
	t_1 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -6e+77:
		tmp = t_1
	elif KbT <= 3.8e-210:
		tmp = t_0
	elif KbT <= 1.25e-80:
		tmp = t_1
	elif KbT <= 3.1e+90:
		tmp = t_0
	else:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -6e+77)
		tmp = t_1;
	elseif (KbT <= 3.8e-210)
		tmp = t_0;
	elseif (KbT <= 1.25e-80)
		tmp = t_1;
	elseif (KbT <= 3.1e+90)
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
	t_1 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -6e+77)
		tmp = t_1;
	elseif (KbT <= 3.8e-210)
		tmp = t_0;
	elseif (KbT <= 1.25e-80)
		tmp = t_1;
	elseif (KbT <= 3.1e+90)
		tmp = t_0;
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -6e+77], t$95$1, If[LessEqual[KbT, 3.8e-210], t$95$0, If[LessEqual[KbT, 1.25e-80], t$95$1, If[LessEqual[KbT, 3.1e+90], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -5.9999999999999996e77 or 3.80000000000000003e-210 < KbT < 1.25e-80

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.6%

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

   5. Taylor expanded in mu around inf 57.3%

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

      1. associate-*r/ 57.3%

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

      2. mul-1-neg 57.3%

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

   7. Simplified 57.3%

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

   if -5.9999999999999996e77 < KbT < 3.80000000000000003e-210 or 1.25e-80 < KbT < 3.09999999999999988e90

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

   4. Taylor expanded in KbT around inf 29.3%

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

   5. Taylor expanded in EAccept around inf 23.6%

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

   6. Taylor expanded in NdChar around 0 42.3%

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

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

   4. Taylor expanded in KbT around inf 66.1%

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

   5. Taylor expanded in Vef around inf 61.6%

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

4. Final simplification 49.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -6 \cdot 10^{+77}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 3.8 \cdot 10^{-210}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.25 \cdot 10^{-80}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 3.1 \cdot 10^{+90}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 20: 42.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;KbT \leq -2.5 \cdot 10^{+37}:\\ \;\;\;\;t_0 + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 5.8 \cdot 10^{+49}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.5e+37], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 5.8e+49], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.49999999999999994e37

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

   4. Taylor expanded in KbT around inf 59.7%

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

   5. Taylor expanded in EAccept around inf 49.4%

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

   if -2.49999999999999994e37 < KbT < 5.8e49

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

   4. Taylor expanded in KbT around inf 32.2%

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

   5. Taylor expanded in EAccept around inf 23.0%

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

   6. Taylor expanded in NdChar around 0 41.4%

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

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

   4. Taylor expanded in KbT around inf 60.8%

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

   5. Taylor expanded in Ev around inf 49.1%

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

4. Final simplification 44.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.5 \cdot 10^{+37}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 5.8 \cdot 10^{+49}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 21: 42.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;KbT \leq -3 \cdot 10^{+40}:\\ \;\;\;\;t_0 + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 6.3 \cdot 10^{+91}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
   (if (<= KbT -3e+40)
     (+ t_0 (* NdChar 0.5))
     (if (<= KbT 6.3e+91)
       t_0
       (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (* NdChar 0.5))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -3e+40], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 6.3e+91], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -3.0000000000000002e40

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

   4. Taylor expanded in KbT around inf 60.6%

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

   5. Taylor expanded in EAccept around inf 50.2%

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

   if -3.0000000000000002e40 < KbT < 6.3e91

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

   4. Taylor expanded in KbT around inf 32.7%

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

   5. Taylor expanded in EAccept around inf 23.7%

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

   6. Taylor expanded in NdChar around 0 41.2%

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

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

   4. Taylor expanded in KbT around inf 66.1%

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

   5. Taylor expanded in Vef around inf 61.6%

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

4. Final simplification 46.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3 \cdot 10^{+40}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 6.3 \cdot 10^{+91}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 22: 42.0% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;KbT \leq -1.25 \cdot 10^{+40}:\\ \;\;\;\;t_0 + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 2.5 \cdot 10^{+91}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
	tmp = 0.0;
	if (KbT <= -1.25e+40)
		tmp = t_0 + (NdChar * 0.5);
	elseif (KbT <= 2.5e+91)
		tmp = t_0;
	else
		tmp = 0.5 * (NdChar + NaChar);
	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[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.25e+40], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.5e+91], t$95$0, N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.25000000000000001e40

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

   4. Taylor expanded in KbT around inf 60.6%

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

   5. Taylor expanded in EAccept around inf 50.2%

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

   if -1.25000000000000001e40 < KbT < 2.5000000000000001e91

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

   4. Taylor expanded in KbT around inf 32.7%

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

   5. Taylor expanded in EAccept around inf 23.7%

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

   6. Taylor expanded in NdChar around 0 41.2%

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

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

   4. Taylor expanded in KbT around inf 66.1%

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

   5. Taylor expanded in EAccept around inf 57.5%

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

   6. Taylor expanded in EAccept around 0 55.5%

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

      1. distribute-lft-out 55.5%

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

   8. Simplified 55.5%

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

4. Final simplification 45.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.25 \cdot 10^{+40}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 2.5 \cdot 10^{+91}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]

Alternative 23: 40.9% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -4.9 \cdot 10^{+204}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef}{KbT} + 2} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.2 \cdot 10^{+89}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -4.9e+204)
   (+ (/ NaChar (+ (/ Vef KbT) 2.0)) (* NdChar 0.5))
   (if (<= KbT 1.2e+89)
     (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
     (* 0.5 (+ NdChar NaChar)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -4.9e+204], N[(N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.2e+89], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -4.8999999999999997e204

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

   4. Taylor expanded in KbT around inf 82.3%

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

   5. Taylor expanded in Vef around inf 78.6%

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

   6. Taylor expanded in Vef around 0 78.6%

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

   if -4.8999999999999997e204 < KbT < 1.20000000000000002e89

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 35.0%

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

   5. Taylor expanded in EAccept around inf 25.0%

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

   6. Taylor expanded in NdChar around 0 38.9%

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

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

   4. Taylor expanded in KbT around inf 66.1%

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

   5. Taylor expanded in EAccept around inf 57.5%

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

   6. Taylor expanded in EAccept around 0 55.5%

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

      1. distribute-lft-out 55.5%

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

   8. Simplified 55.5%

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

4. Final simplification 45.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -4.9 \cdot 10^{+204}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef}{KbT} + 2} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.2 \cdot 10^{+89}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]

Alternative 24: 28.2% accurate, 5.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -9.5 \cdot 10^{+258}:\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{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}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Vef <= -9.5e+258)
		tmp = Float64(Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(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(0.5 * Float64(NdChar + NaChar));
	end
	return tmp
end

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -9.5e258

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 69.1%

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

   5. Taylor expanded in KbT around inf 37.8%

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

   if -9.5e258 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 46.0%

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

   5. Taylor expanded in EAccept around inf 37.1%

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

   6. Taylor expanded in EAccept around 0 28.8%

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

      1. distribute-lft-out 28.8%

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

   8. Simplified 28.8%

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

4. Final simplification 29.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -9.5 \cdot 10^{+258}:\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{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}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]

Alternative 25: 28.1% accurate, 8.5× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -6.79999999999999962e258

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 69.1%

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

   5. Taylor expanded in Vef around inf 69.4%

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

      1. associate-/l* 74.3%

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

   7. Simplified 74.3%

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

   8. Taylor expanded in KbT around inf 32.8%

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

   if -6.79999999999999962e258 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 46.0%

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

   5. Taylor expanded in EAccept around inf 37.1%

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

   6. Taylor expanded in EAccept around 0 28.8%

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

      1. distribute-lft-out 28.8%

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

   8. Simplified 28.8%

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

4. Final simplification 29.1%

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

Alternative 26: 27.8% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

3. Simplified 99.9%

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

4. Taylor expanded in KbT around inf 44.3%

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

5. Taylor expanded in EAccept around inf 35.0%

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

6. Taylor expanded in EAccept around 0 27.3%

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

   1. distribute-lft-out 27.3%

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

8. Simplified 27.3%

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

9. Final simplification 27.3%

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

Reproduce

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