Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 23.3s

Alternatives: 22

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -1.2161636308340689e-10
  2. Ec = -4.741328055411909e-289
  3. Vef = 4.2305545898285605e+266
  4. EDonor = 5.394441360591748e+295
  5. mu = -1.9473557918025142e+197
  6. KbT = -1.412539300476009e+166
  7. NaChar = 1.957395368388387e-8
  8. Ev = 4905526.237088565
  9. EAccept = 7.168422319562131e+302

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Final simplification 100.0%

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

Alternative 2: 70.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;Ev \leq -4 \cdot 10^{+37}:\\ \;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -2.25 \cdot 10^{-89}:\\ \;\;\;\;\frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\ \mathbf{elif}\;Ev \leq -2.2 \cdot 10^{-147}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;Ev \leq -6.2 \cdot 10^{-149}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_1 + \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 (+ 1.0 (exp (/ Vef KbT))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))))
   (if (<= Ev -4e+37)
     (+ t_1 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (if (<= Ev -2.25e-89)
       (+ (/ NaChar t_0) (/ NdChar t_0))
       (if (<= Ev -2.2e-147)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/
           NdChar
           (+
            1.0
            (-
             (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
             (/ Ec KbT)))))
         (if (<= Ev -6.2e-149)
           (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
           (+ t_1 (/ 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 = 1.0 + exp((Vef / KbT));
	double t_1 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -4e+37) {
		tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (Ev <= -2.25e-89) {
		tmp = (NaChar / t_0) + (NdChar / t_0);
	} else if (Ev <= -2.2e-147) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	} else if (Ev <= -6.2e-149) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = 1.0d0 + exp((vef / kbt))
    t_1 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    if (ev <= (-4d+37)) then
        tmp = t_1 + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (ev <= (-2.25d-89)) then
        tmp = (nachar / t_0) + (ndchar / t_0)
    else if (ev <= (-2.2d-147)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + ((1.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt))))
    else if (ev <= (-6.2d-149)) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else
        tmp = t_1 + (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 = 1.0 + Math.exp((Vef / KbT));
	double t_1 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -4e+37) {
		tmp = t_1 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (Ev <= -2.25e-89) {
		tmp = (NaChar / t_0) + (NdChar / t_0);
	} else if (Ev <= -2.2e-147) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	} else if (Ev <= -6.2e-149) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = t_1 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	t_1 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	tmp = 0
	if Ev <= -4e+37:
		tmp = t_1 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif Ev <= -2.25e-89:
		tmp = (NaChar / t_0) + (NdChar / t_0)
	elif Ev <= -2.2e-147:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))))
	elif Ev <= -6.2e-149:
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	else:
		tmp = t_1 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + exp(Float64(Vef / KbT)))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (Ev <= -4e+37)
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (Ev <= -2.25e-89)
		tmp = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0));
	elseif (Ev <= -2.2e-147)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT)))));
	elseif (Ev <= -6.2e-149)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	else
		tmp = Float64(t_1 + 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 = 1.0 + exp((Vef / KbT));
	t_1 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (Ev <= -4e+37)
		tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (Ev <= -2.25e-89)
		tmp = (NaChar / t_0) + (NdChar / t_0);
	elseif (Ev <= -2.2e-147)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	elseif (Ev <= -6.2e-149)
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	else
		tmp = t_1 + (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[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -4e+37], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -2.25e-89], N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -2.2e-147], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(N[(1.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]), $MachinePrecision], If[LessEqual[Ev, -6.2e-149], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 5 regimes

2. if Ev < -3.99999999999999982e37

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 88.3%

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

   if -3.99999999999999982e37 < Ev < -2.25e-89

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 69.5%

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

   5. Taylor expanded in Vef around inf 57.1%

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

   if -2.25e-89 < Ev < -2.2000000000000001e-147

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 75.8%

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

   if -2.2000000000000001e-147 < Ev < -6.19999999999999974e-149

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 53.5%

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

   5. Taylor expanded in Vef around inf 30.2%

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

      1. associate-/l* 30.9%

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

   7. Simplified 30.9%

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

   8. Taylor expanded in NdChar around inf 62.2%

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

   if -6.19999999999999974e-149 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 66.7%

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

4. Final simplification 71.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -4 \cdot 10^{+37}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -2.25 \cdot 10^{-89}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Ev \leq -2.2 \cdot 10^{-147}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;Ev \leq -6.2 \cdot 10^{-149}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 3: 72.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ t_1 := \frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\ \mathbf{if}\;Vef \leq -95000000000000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq 3.25 \cdot 10^{+112}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;Vef \leq 3.2 \cdot 10^{+183}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 1.0 (exp (/ Vef KbT))))
        (t_1 (+ (/ NaChar t_0) (/ NdChar t_0))))
   (if (<= Vef -95000000000000.0)
     t_1
     (if (<= Vef 3.25e+112)
       (+
        (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
       (if (<= Vef 3.2e+183)
         (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + exp((Vef / KbT));
	double t_1 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -95000000000000.0) {
		tmp = t_1;
	} else if (Vef <= 3.25e+112) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (Vef <= 3.2e+183) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = 1.0d0 + exp((vef / kbt))
    t_1 = (nachar / t_0) + (ndchar / t_0)
    if (vef <= (-95000000000000.0d0)) then
        tmp = t_1
    else if (vef <= 3.25d+112) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (vef <= 3.2d+183) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + Math.exp((Vef / KbT));
	double t_1 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -95000000000000.0) {
		tmp = t_1;
	} else if (Vef <= 3.25e+112) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (Vef <= 3.2e+183) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	t_1 = (NaChar / t_0) + (NdChar / t_0)
	tmp = 0
	if Vef <= -95000000000000.0:
		tmp = t_1
	elif Vef <= 3.25e+112:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif Vef <= 3.2e+183:
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + exp(Float64(Vef / KbT)))
	t_1 = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0))
	tmp = 0.0
	if (Vef <= -95000000000000.0)
		tmp = t_1;
	elseif (Vef <= 3.25e+112)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (Vef <= 3.2e+183)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	t_1 = (NaChar / t_0) + (NdChar / t_0);
	tmp = 0.0;
	if (Vef <= -95000000000000.0)
		tmp = t_1;
	elseif (Vef <= 3.25e+112)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (Vef <= 3.2e+183)
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -95000000000000.0], t$95$1, If[LessEqual[Vef, 3.25e+112], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 3.2e+183], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -9.5e13 or 3.2000000000000002e183 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 86.2%

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

   5. Taylor expanded in Vef around inf 78.6%

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

   if -9.5e13 < Vef < 3.2499999999999999e112

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 72.0%

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

   if 3.2499999999999999e112 < Vef < 3.2000000000000002e183

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 45.0%

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

   5. Taylor expanded in Vef around inf 49.8%

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

      1. associate-/l* 53.7%

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

   7. Simplified 53.7%

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

   8. Taylor expanded in NdChar around inf 76.7%

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

4. Final simplification 74.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -95000000000000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq 3.25 \cdot 10^{+112}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;Vef \leq 3.2 \cdot 10^{+183}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]

Alternative 4: 72.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -6.3e+177) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (Ev <= -5.5e-138) {
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	} else {
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 90.8%

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

   if -6.2999999999999999e177 < Ev < -5.5000000000000003e-138

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 71.4%

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

   if -5.5000000000000003e-138 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 66.9%

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

4. Final simplification 71.0%

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

Alternative 5: 63.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{if}\;NaChar \leq -1.65 \cdot 10^{+206}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -6.5 \cdot 10^{+16}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq -1.3 \cdot 10^{-155}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;NaChar \leq 3.4 \cdot 10^{+19}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))))
   (if (<= NaChar -1.65e+206)
     (+
      (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
      (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
     (if (<= NaChar -6.5e+16)
       t_0
       (if (<= NaChar -1.3e-155)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
          NaChar)
         (if (<= NaChar 3.4e+19)
           t_0
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
            (/ NdChar 2.0))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (NaChar <= -1.65e+206) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (NaChar <= -6.5e+16) {
		tmp = t_0;
	} else if (NaChar <= -1.3e-155) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	} else if (NaChar <= 3.4e+19) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    if (nachar <= (-1.65d+206)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (nachar <= (-6.5d+16)) then
        tmp = t_0
    else if (nachar <= (-1.3d-155)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + nachar
    else if (nachar <= 3.4d+19) then
        tmp = t_0
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (NaChar <= -1.65e+206) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (NaChar <= -6.5e+16) {
		tmp = t_0;
	} else if (NaChar <= -1.3e-155) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	} else if (NaChar <= 3.4e+19) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	tmp = 0
	if NaChar <= -1.65e+206:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif NaChar <= -6.5e+16:
		tmp = t_0
	elif NaChar <= -1.3e-155:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar
	elif NaChar <= 3.4e+19:
		tmp = t_0
	else:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 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(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	tmp = 0.0
	if (NaChar <= -1.65e+206)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (NaChar <= -6.5e+16)
		tmp = t_0;
	elseif (NaChar <= -1.3e-155)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + NaChar);
	elseif (NaChar <= 3.4e+19)
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / 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((((EDonor + (mu + Vef)) - Ec) / KbT)));
	tmp = 0.0;
	if (NaChar <= -1.65e+206)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (NaChar <= -6.5e+16)
		tmp = t_0;
	elseif (NaChar <= -1.3e-155)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	elseif (NaChar <= 3.4e+19)
		tmp = t_0;
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 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[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.65e+206], 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], If[LessEqual[NaChar, -6.5e+16], t$95$0, If[LessEqual[NaChar, -1.3e-155], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + NaChar), $MachinePrecision], If[LessEqual[NaChar, 3.4e+19], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -1.64999999999999992e206

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 47.6%

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

   5. Taylor expanded in EDonor around inf 47.5%

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

   if -1.64999999999999992e206 < NaChar < -6.5e16 or -1.30000000000000004e-155 < NaChar < 3.4e19

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.5%

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

   5. Taylor expanded in Vef around inf 43.9%

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

      1. associate-/l* 45.9%

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

   7. Simplified 45.9%

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

   8. Taylor expanded in NdChar around inf 78.6%

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

   if -6.5e16 < NaChar < -1.30000000000000004e-155

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 60.4%

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

   5. Taylor expanded in EAccept around inf 64.7%

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

   6. Taylor expanded in EAccept around 0 80.1%

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

   if 3.4e19 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 66.9%

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

4. Final simplification 73.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.65 \cdot 10^{+206}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -6.5 \cdot 10^{+16}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -1.3 \cdot 10^{-155}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;NaChar \leq 3.4 \cdot 10^{+19}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 6: 65.5% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{if}\;KbT \leq -4.5 \cdot 10^{+221}:\\ \;\;\;\;\frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\ \mathbf{elif}\;KbT \leq 3.8 \cdot 10^{-259}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq 1.18 \cdot 10^{-163}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 2.5 \cdot 10^{-99}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq 2.5 \cdot 10^{+138}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 1.0 (exp (/ Vef KbT))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
          NaChar)))
   (if (<= KbT -4.5e+221)
     (+ (/ NaChar t_0) (/ NdChar t_0))
     (if (<= KbT 3.8e-259)
       t_2
       (if (<= KbT 1.18e-163)
         t_1
         (if (<= KbT 2.5e-99)
           t_2
           (if (<= KbT 2.5e+138)
             t_1
             (+
              (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
              (/ NdChar 2.0)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + exp((Vef / KbT));
	double t_1 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_2 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	double tmp;
	if (KbT <= -4.5e+221) {
		tmp = (NaChar / t_0) + (NdChar / t_0);
	} else if (KbT <= 3.8e-259) {
		tmp = t_2;
	} else if (KbT <= 1.18e-163) {
		tmp = t_1;
	} else if (KbT <= 2.5e-99) {
		tmp = t_2;
	} else if (KbT <= 2.5e+138) {
		tmp = t_1;
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = 1.0d0 + exp((vef / kbt))
    t_1 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    t_2 = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + nachar
    if (kbt <= (-4.5d+221)) then
        tmp = (nachar / t_0) + (ndchar / t_0)
    else if (kbt <= 3.8d-259) then
        tmp = t_2
    else if (kbt <= 1.18d-163) then
        tmp = t_1
    else if (kbt <= 2.5d-99) then
        tmp = t_2
    else if (kbt <= 2.5d+138) then
        tmp = t_1
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + Math.exp((Vef / KbT));
	double t_1 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_2 = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	double tmp;
	if (KbT <= -4.5e+221) {
		tmp = (NaChar / t_0) + (NdChar / t_0);
	} else if (KbT <= 3.8e-259) {
		tmp = t_2;
	} else if (KbT <= 1.18e-163) {
		tmp = t_1;
	} else if (KbT <= 2.5e-99) {
		tmp = t_2;
	} else if (KbT <= 2.5e+138) {
		tmp = t_1;
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	t_1 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	t_2 = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar
	tmp = 0
	if KbT <= -4.5e+221:
		tmp = (NaChar / t_0) + (NdChar / t_0)
	elif KbT <= 3.8e-259:
		tmp = t_2
	elif KbT <= 1.18e-163:
		tmp = t_1
	elif KbT <= 2.5e-99:
		tmp = t_2
	elif KbT <= 2.5e+138:
		tmp = t_1
	else:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + exp(Float64(Vef / KbT)))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + NaChar)
	tmp = 0.0
	if (KbT <= -4.5e+221)
		tmp = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0));
	elseif (KbT <= 3.8e-259)
		tmp = t_2;
	elseif (KbT <= 1.18e-163)
		tmp = t_1;
	elseif (KbT <= 2.5e-99)
		tmp = t_2;
	elseif (KbT <= 2.5e+138)
		tmp = t_1;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	t_1 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	t_2 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	tmp = 0.0;
	if (KbT <= -4.5e+221)
		tmp = (NaChar / t_0) + (NdChar / t_0);
	elseif (KbT <= 3.8e-259)
		tmp = t_2;
	elseif (KbT <= 1.18e-163)
		tmp = t_1;
	elseif (KbT <= 2.5e-99)
		tmp = t_2;
	elseif (KbT <= 2.5e+138)
		tmp = t_1;
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + NaChar), $MachinePrecision]}, If[LessEqual[KbT, -4.5e+221], N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.8e-259], t$95$2, If[LessEqual[KbT, 1.18e-163], t$95$1, If[LessEqual[KbT, 2.5e-99], t$95$2, If[LessEqual[KbT, 2.5e+138], t$95$1, N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -4.5000000000000002e221

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 100.0%

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

   5. Taylor expanded in Vef around inf 95.5%

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

   if -4.5000000000000002e221 < KbT < 3.8e-259 or 1.18000000000000004e-163 < KbT < 2.49999999999999985e-99

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 40.3%

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

   5. Taylor expanded in EAccept around inf 54.9%

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

   6. Taylor expanded in EAccept around 0 69.6%

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

   if 3.8e-259 < KbT < 1.18000000000000004e-163 or 2.49999999999999985e-99 < KbT < 2.50000000000000008e138

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.0%

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

   5. Taylor expanded in Vef around inf 33.0%

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

      1. associate-/l* 31.5%

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

   7. Simplified 31.5%

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

   8. Taylor expanded in NdChar around inf 81.8%

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

   if 2.50000000000000008e138 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 87.0%

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

4. Final simplification 77.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -4.5 \cdot 10^{+221}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;KbT \leq 3.8 \cdot 10^{-259}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 1.18 \cdot 10^{-163}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.5 \cdot 10^{-99}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 2.5 \cdot 10^{+138}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 7: 65.0% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{if}\;NaChar \leq -1.8 \cdot 10^{+206}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -8500000000:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq -1.15 \cdot 10^{-163}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;NaChar \leq 8.5 \cdot 10^{+21}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar 2.0))))
   (if (<= NaChar -1.8e+206)
     t_1
     (if (<= NaChar -8500000000.0)
       t_0
       (if (<= NaChar -1.15e-163)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
          NaChar)
         (if (<= NaChar 8.5e+21) t_0 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	double tmp;
	if (NaChar <= -1.8e+206) {
		tmp = t_1;
	} else if (NaChar <= -8500000000.0) {
		tmp = t_0;
	} else if (NaChar <= -1.15e-163) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	} else if (NaChar <= 8.5e+21) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / 2.0d0)
    if (nachar <= (-1.8d+206)) then
        tmp = t_1
    else if (nachar <= (-8500000000.0d0)) then
        tmp = t_0
    else if (nachar <= (-1.15d-163)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + nachar
    else if (nachar <= 8.5d+21) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	double tmp;
	if (NaChar <= -1.8e+206) {
		tmp = t_1;
	} else if (NaChar <= -8500000000.0) {
		tmp = t_0;
	} else if (NaChar <= -1.15e-163) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	} else if (NaChar <= 8.5e+21) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0)
	tmp = 0
	if NaChar <= -1.8e+206:
		tmp = t_1
	elif NaChar <= -8500000000.0:
		tmp = t_0
	elif NaChar <= -1.15e-163:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar
	elif NaChar <= 8.5e+21:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / 2.0))
	tmp = 0.0
	if (NaChar <= -1.8e+206)
		tmp = t_1;
	elseif (NaChar <= -8500000000.0)
		tmp = t_0;
	elseif (NaChar <= -1.15e-163)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + NaChar);
	elseif (NaChar <= 8.5e+21)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	tmp = 0.0;
	if (NaChar <= -1.8e+206)
		tmp = t_1;
	elseif (NaChar <= -8500000000.0)
		tmp = t_0;
	elseif (NaChar <= -1.15e-163)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	elseif (NaChar <= 8.5e+21)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.8e+206], t$95$1, If[LessEqual[NaChar, -8500000000.0], t$95$0, If[LessEqual[NaChar, -1.15e-163], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + NaChar), $MachinePrecision], If[LessEqual[NaChar, 8.5e+21], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.80000000000000014e206 or 8.5e21 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 67.1%

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

   if -1.80000000000000014e206 < NaChar < -8.5e9 or -1.15e-163 < NaChar < 8.5e21

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.5%

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

   5. Taylor expanded in Vef around inf 43.9%

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

      1. associate-/l* 45.9%

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

   7. Simplified 45.9%

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

   8. Taylor expanded in NdChar around inf 78.6%

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

   if -8.5e9 < NaChar < -1.15e-163

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 60.4%

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

   5. Taylor expanded in EAccept around inf 64.7%

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

   6. Taylor expanded in EAccept around 0 80.1%

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

4. Final simplification 74.8%

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

Alternative 8: 64.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{if}\;KbT \leq -4.5 \cdot 10^{+221}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 6 \cdot 10^{-262}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 10^{-163}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 1.15 \cdot 10^{-98}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 2 \cdot 10^{+137}:\\ \;\;\;\;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 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)))))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
          NaChar)))
   (if (<= KbT -4.5e+221)
     (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (* NdChar 0.5))
     (if (<= KbT 6e-262)
       t_1
       (if (<= KbT 1e-163)
         t_0
         (if (<= KbT 1.15e-98)
           t_1
           (if (<= KbT 2e+137)
             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 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	double tmp;
	if (KbT <= -4.5e+221) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 6e-262) {
		tmp = t_1;
	} else if (KbT <= 1e-163) {
		tmp = t_0;
	} else if (KbT <= 1.15e-98) {
		tmp = t_1;
	} else if (KbT <= 2e+137) {
		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) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    t_1 = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + nachar
    if (kbt <= (-4.5d+221)) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= 6d-262) then
        tmp = t_1
    else if (kbt <= 1d-163) then
        tmp = t_0
    else if (kbt <= 1.15d-98) then
        tmp = t_1
    else if (kbt <= 2d+137) 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 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	double tmp;
	if (KbT <= -4.5e+221) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 6e-262) {
		tmp = t_1;
	} else if (KbT <= 1e-163) {
		tmp = t_0;
	} else if (KbT <= 1.15e-98) {
		tmp = t_1;
	} else if (KbT <= 2e+137) {
		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 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	t_1 = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar
	tmp = 0
	if KbT <= -4.5e+221:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar * 0.5)
	elif KbT <= 6e-262:
		tmp = t_1
	elif KbT <= 1e-163:
		tmp = t_0
	elif KbT <= 1.15e-98:
		tmp = t_1
	elif KbT <= 2e+137:
		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(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + NaChar)
	tmp = 0.0
	if (KbT <= -4.5e+221)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= 6e-262)
		tmp = t_1;
	elseif (KbT <= 1e-163)
		tmp = t_0;
	elseif (KbT <= 1.15e-98)
		tmp = t_1;
	elseif (KbT <= 2e+137)
		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 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	t_1 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	tmp = 0.0;
	if (KbT <= -4.5e+221)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= 6e-262)
		tmp = t_1;
	elseif (KbT <= 1e-163)
		tmp = t_0;
	elseif (KbT <= 1.15e-98)
		tmp = t_1;
	elseif (KbT <= 2e+137)
		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[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + NaChar), $MachinePrecision]}, If[LessEqual[KbT, -4.5e+221], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 6e-262], t$95$1, If[LessEqual[KbT, 1e-163], t$95$0, If[LessEqual[KbT, 1.15e-98], t$95$1, If[LessEqual[KbT, 2e+137], 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 4 regimes

2. if KbT < -4.5000000000000002e221

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 100.0%

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

   5. Taylor expanded in KbT around inf 84.6%

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

   if -4.5000000000000002e221 < KbT < 6.00000000000000036e-262 or 9.99999999999999923e-164 < KbT < 1.15e-98

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 40.3%

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

   5. Taylor expanded in EAccept around inf 54.9%

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

   6. Taylor expanded in EAccept around 0 69.6%

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

   if 6.00000000000000036e-262 < KbT < 9.99999999999999923e-164 or 1.15e-98 < KbT < 2.0000000000000001e137

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.0%

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

   5. Taylor expanded in Vef around inf 33.0%

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

      1. associate-/l* 31.5%

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

   7. Simplified 31.5%

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

   8. Taylor expanded in NdChar around inf 81.8%

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

   if 2.0000000000000001e137 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 82.9%

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

   5. Taylor expanded in KbT around inf 72.6%

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

4. Final simplification 74.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -4.5 \cdot 10^{+221}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 6 \cdot 10^{-262}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 10^{-163}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.15 \cdot 10^{-98}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 2 \cdot 10^{+137}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 9: 64.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_2 := t_1 + NaChar\\ \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+210}:\\ \;\;\;\;t_1 + NaChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.8 \cdot 10^{-259}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq 1.25 \cdot 10^{-163}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 5.2 \cdot 10^{-99}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq 3.5 \cdot 10^{+138}:\\ \;\;\;\;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 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_2 (+ t_1 NaChar)))
   (if (<= KbT -9.2e+210)
     (+ t_1 (* NaChar 0.5))
     (if (<= KbT 1.8e-259)
       t_2
       (if (<= KbT 1.25e-163)
         t_0
         (if (<= KbT 5.2e-99)
           t_2
           (if (<= KbT 3.5e+138)
             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 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_2 = t_1 + NaChar;
	double tmp;
	if (KbT <= -9.2e+210) {
		tmp = t_1 + (NaChar * 0.5);
	} else if (KbT <= 1.8e-259) {
		tmp = t_2;
	} else if (KbT <= 1.25e-163) {
		tmp = t_0;
	} else if (KbT <= 5.2e-99) {
		tmp = t_2;
	} else if (KbT <= 3.5e+138) {
		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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    t_1 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_2 = t_1 + nachar
    if (kbt <= (-9.2d+210)) then
        tmp = t_1 + (nachar * 0.5d0)
    else if (kbt <= 1.8d-259) then
        tmp = t_2
    else if (kbt <= 1.25d-163) then
        tmp = t_0
    else if (kbt <= 5.2d-99) then
        tmp = t_2
    else if (kbt <= 3.5d+138) 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 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_2 = t_1 + NaChar;
	double tmp;
	if (KbT <= -9.2e+210) {
		tmp = t_1 + (NaChar * 0.5);
	} else if (KbT <= 1.8e-259) {
		tmp = t_2;
	} else if (KbT <= 1.25e-163) {
		tmp = t_0;
	} else if (KbT <= 5.2e-99) {
		tmp = t_2;
	} else if (KbT <= 3.5e+138) {
		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 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	t_1 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_2 = t_1 + NaChar
	tmp = 0
	if KbT <= -9.2e+210:
		tmp = t_1 + (NaChar * 0.5)
	elif KbT <= 1.8e-259:
		tmp = t_2
	elif KbT <= 1.25e-163:
		tmp = t_0
	elif KbT <= 5.2e-99:
		tmp = t_2
	elif KbT <= 3.5e+138:
		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(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_2 = Float64(t_1 + NaChar)
	tmp = 0.0
	if (KbT <= -9.2e+210)
		tmp = Float64(t_1 + Float64(NaChar * 0.5));
	elseif (KbT <= 1.8e-259)
		tmp = t_2;
	elseif (KbT <= 1.25e-163)
		tmp = t_0;
	elseif (KbT <= 5.2e-99)
		tmp = t_2;
	elseif (KbT <= 3.5e+138)
		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 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	t_1 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_2 = t_1 + NaChar;
	tmp = 0.0;
	if (KbT <= -9.2e+210)
		tmp = t_1 + (NaChar * 0.5);
	elseif (KbT <= 1.8e-259)
		tmp = t_2;
	elseif (KbT <= 1.25e-163)
		tmp = t_0;
	elseif (KbT <= 5.2e-99)
		tmp = t_2;
	elseif (KbT <= 3.5e+138)
		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[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + NaChar), $MachinePrecision]}, If[LessEqual[KbT, -9.2e+210], N[(t$95$1 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.8e-259], t$95$2, If[LessEqual[KbT, 1.25e-163], t$95$0, If[LessEqual[KbT, 5.2e-99], t$95$2, If[LessEqual[KbT, 3.5e+138], 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 4 regimes

2. if KbT < -9.1999999999999995e210

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 81.4%

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

   if -9.1999999999999995e210 < KbT < 1.7999999999999999e-259 or 1.24999999999999994e-163 < KbT < 5.2000000000000001e-99

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 40.2%

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

   5. Taylor expanded in EAccept around inf 54.9%

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

   6. Taylor expanded in EAccept around 0 69.9%

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

   if 1.7999999999999999e-259 < KbT < 1.24999999999999994e-163 or 5.2000000000000001e-99 < KbT < 3.4999999999999998e138

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.0%

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

   5. Taylor expanded in Vef around inf 33.0%

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

      1. associate-/l* 31.5%

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

   7. Simplified 31.5%

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

   8. Taylor expanded in NdChar around inf 81.8%

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

   if 3.4999999999999998e138 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 82.9%

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

   5. Taylor expanded in KbT around inf 72.6%

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

4. Final simplification 74.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+210}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.8 \cdot 10^{-259}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 1.25 \cdot 10^{-163}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 5.2 \cdot 10^{-99}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 3.5 \cdot 10^{+138}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 10: 63.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{if}\;KbT \leq -1.25 \cdot 10^{+226}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 2.9 \cdot 10^{-155}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 2.45 \cdot 10^{-101}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.2 \cdot 10^{+139}:\\ \;\;\;\;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 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))))
   (if (<= KbT -1.25e+226)
     (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (* NdChar 0.5))
     (if (<= KbT 2.9e-155)
       t_0
       (if (<= KbT 2.45e-101)
         (+ NaChar (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
         (if (<= KbT 2.2e+139)
           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 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (KbT <= -1.25e+226) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 2.9e-155) {
		tmp = t_0;
	} else if (KbT <= 2.45e-101) {
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (KbT <= 2.2e+139) {
		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 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    if (kbt <= (-1.25d+226)) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= 2.9d-155) then
        tmp = t_0
    else if (kbt <= 2.45d-101) then
        tmp = nachar + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (kbt <= 2.2d+139) 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 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (KbT <= -1.25e+226) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= 2.9e-155) {
		tmp = t_0;
	} else if (KbT <= 2.45e-101) {
		tmp = NaChar + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (KbT <= 2.2e+139) {
		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 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	tmp = 0
	if KbT <= -1.25e+226:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar * 0.5)
	elif KbT <= 2.9e-155:
		tmp = t_0
	elif KbT <= 2.45e-101:
		tmp = NaChar + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif KbT <= 2.2e+139:
		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(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	tmp = 0.0
	if (KbT <= -1.25e+226)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= 2.9e-155)
		tmp = t_0;
	elseif (KbT <= 2.45e-101)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (KbT <= 2.2e+139)
		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 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	tmp = 0.0;
	if (KbT <= -1.25e+226)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= 2.9e-155)
		tmp = t_0;
	elseif (KbT <= 2.45e-101)
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (KbT <= 2.2e+139)
		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[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.25e+226], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.9e-155], t$95$0, If[LessEqual[KbT, 2.45e-101], N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.2e+139], 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 4 regimes

2. if KbT < -1.2500000000000001e226

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 100.0%

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

   5. Taylor expanded in KbT around inf 88.8%

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

   if -1.2500000000000001e226 < KbT < 2.9000000000000001e-155 or 2.45e-101 < KbT < 2.1999999999999999e139

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 48.7%

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

   5. Taylor expanded in Vef around inf 36.4%

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

      1. associate-/l* 36.3%

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

   7. Simplified 36.3%

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

   8. Taylor expanded in NdChar around inf 69.6%

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

   if 2.9000000000000001e-155 < KbT < 2.45e-101

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 34.6%

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

   5. Taylor expanded in EAccept around inf 44.3%

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

   6. Taylor expanded in EAccept around 0 91.5%

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

   7. Taylor expanded in Ec around inf 77.5%

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

      1. associate-*r/ 77.5%

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

      2. mul-1-neg 77.5%

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

   9. Simplified 77.5%

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

   if 2.1999999999999999e139 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 82.9%

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

   5. Taylor expanded in KbT around inf 72.6%

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

4. Final simplification 71.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.25 \cdot 10^{+226}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 2.9 \cdot 10^{-155}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.45 \cdot 10^{-101}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.2 \cdot 10^{+139}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 11: 49.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;KbT \leq -1.05 \cdot 10^{+223}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -9.6 \cdot 10^{-109}:\\ \;\;\;\;NaChar + t_0\\ \mathbf{elif}\;KbT \leq 6.4 \cdot 10^{+25}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 9.5 \cdot 10^{+62}:\\ \;\;\;\;NaChar \cdot 0.5 + 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 (/ NdChar (+ 1.0 (exp (/ mu KbT))))))
   (if (<= KbT -1.05e+223)
     (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (* NdChar 0.5))
     (if (<= KbT -9.6e-109)
       (+ NaChar t_0)
       (if (<= KbT 6.4e+25)
         (+ NaChar (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
         (if (<= KbT 9.5e+62)
           (+ (* NaChar 0.5) 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 = NdChar / (1.0 + exp((mu / KbT)));
	double tmp;
	if (KbT <= -1.05e+223) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= -9.6e-109) {
		tmp = NaChar + t_0;
	} else if (KbT <= 6.4e+25) {
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (KbT <= 9.5e+62) {
		tmp = (NaChar * 0.5) + 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 = ndchar / (1.0d0 + exp((mu / kbt)))
    if (kbt <= (-1.05d+223)) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= (-9.6d-109)) then
        tmp = nachar + t_0
    else if (kbt <= 6.4d+25) then
        tmp = nachar + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (kbt <= 9.5d+62) then
        tmp = (nachar * 0.5d0) + 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 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double tmp;
	if (KbT <= -1.05e+223) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= -9.6e-109) {
		tmp = NaChar + t_0;
	} else if (KbT <= 6.4e+25) {
		tmp = NaChar + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (KbT <= 9.5e+62) {
		tmp = (NaChar * 0.5) + 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 = NdChar / (1.0 + math.exp((mu / KbT)))
	tmp = 0
	if KbT <= -1.05e+223:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar * 0.5)
	elif KbT <= -9.6e-109:
		tmp = NaChar + t_0
	elif KbT <= 6.4e+25:
		tmp = NaChar + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif KbT <= 9.5e+62:
		tmp = (NaChar * 0.5) + 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(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	tmp = 0.0
	if (KbT <= -1.05e+223)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= -9.6e-109)
		tmp = Float64(NaChar + t_0);
	elseif (KbT <= 6.4e+25)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (KbT <= 9.5e+62)
		tmp = Float64(Float64(NaChar * 0.5) + 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 = NdChar / (1.0 + exp((mu / KbT)));
	tmp = 0.0;
	if (KbT <= -1.05e+223)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= -9.6e-109)
		tmp = NaChar + t_0;
	elseif (KbT <= 6.4e+25)
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (KbT <= 9.5e+62)
		tmp = (NaChar * 0.5) + 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[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.05e+223], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -9.6e-109], N[(NaChar + t$95$0), $MachinePrecision], If[LessEqual[KbT, 6.4e+25], N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 9.5e+62], N[(N[(NaChar * 0.5), $MachinePrecision] + t$95$0), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 5 regimes

2. if KbT < -1.04999999999999995e223

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 100.0%

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

   5. Taylor expanded in KbT around inf 84.6%

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

   if -1.04999999999999995e223 < KbT < -9.59999999999999955e-109

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.5%

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

   5. Taylor expanded in EAccept around inf 51.5%

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

   6. Taylor expanded in EAccept around 0 63.6%

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

   7. Taylor expanded in mu around inf 53.4%

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

   if -9.59999999999999955e-109 < KbT < 6.3999999999999999e25

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 45.6%

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

   5. Taylor expanded in EAccept around inf 56.7%

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

   6. Taylor expanded in EAccept around 0 63.9%

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

   7. Taylor expanded in Ec around inf 53.6%

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

      1. associate-*r/ 53.6%

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

      2. mul-1-neg 53.6%

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

   9. Simplified 53.6%

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

   if 6.3999999999999999e25 < KbT < 9.5000000000000003e62

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 76.8%

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

   5. Taylor expanded in mu around inf 74.9%

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

   if 9.5000000000000003e62 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 74.9%

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

   5. Taylor expanded in KbT around inf 61.7%

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

4. Final simplification 58.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.05 \cdot 10^{+223}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -9.6 \cdot 10^{-109}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 6.4 \cdot 10^{+25}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 9.5 \cdot 10^{+62}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 12: 48.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := NaChar + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;KbT \leq -9.6 \cdot 10^{+210}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq -4.6 \cdot 10^{-192}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 2.7 \cdot 10^{-169}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.25 \cdot 10^{+184}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ NaChar (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
   (if (<= KbT -9.6e+210)
     (+ (* NaChar 0.5) (/ NdChar (+ (/ Vef KbT) 2.0)))
     (if (<= KbT -4.6e-192)
       t_0
       (if (<= KbT 2.7e-169)
         (+ NaChar (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (if (<= KbT 2.25e+184)
           t_0
           (+ (* NdChar 0.5) (/ NaChar (+ (/ Ev KbT) 2.0)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar + (NdChar / (1.0 + exp((Vef / KbT))));
	double tmp;
	if (KbT <= -9.6e+210) {
		tmp = (NaChar * 0.5) + (NdChar / ((Vef / KbT) + 2.0));
	} else if (KbT <= -4.6e-192) {
		tmp = t_0;
	} else if (KbT <= 2.7e-169) {
		tmp = NaChar + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (KbT <= 2.25e+184) {
		tmp = t_0;
	} else {
		tmp = (NdChar * 0.5) + (NaChar / ((Ev / KbT) + 2.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar + (ndchar / (1.0d0 + exp((vef / kbt))))
    if (kbt <= (-9.6d+210)) then
        tmp = (nachar * 0.5d0) + (ndchar / ((vef / kbt) + 2.0d0))
    else if (kbt <= (-4.6d-192)) then
        tmp = t_0
    else if (kbt <= 2.7d-169) then
        tmp = nachar + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (kbt <= 2.25d+184) then
        tmp = t_0
    else
        tmp = (ndchar * 0.5d0) + (nachar / ((ev / kbt) + 2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	double tmp;
	if (KbT <= -9.6e+210) {
		tmp = (NaChar * 0.5) + (NdChar / ((Vef / KbT) + 2.0));
	} else if (KbT <= -4.6e-192) {
		tmp = t_0;
	} else if (KbT <= 2.7e-169) {
		tmp = NaChar + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (KbT <= 2.25e+184) {
		tmp = t_0;
	} else {
		tmp = (NdChar * 0.5) + (NaChar / ((Ev / KbT) + 2.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar + (NdChar / (1.0 + math.exp((Vef / KbT))))
	tmp = 0
	if KbT <= -9.6e+210:
		tmp = (NaChar * 0.5) + (NdChar / ((Vef / KbT) + 2.0))
	elif KbT <= -4.6e-192:
		tmp = t_0
	elif KbT <= 2.7e-169:
		tmp = NaChar + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif KbT <= 2.25e+184:
		tmp = t_0
	else:
		tmp = (NdChar * 0.5) + (NaChar / ((Ev / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	tmp = 0.0
	if (KbT <= -9.6e+210)
		tmp = Float64(Float64(NaChar * 0.5) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0)));
	elseif (KbT <= -4.6e-192)
		tmp = t_0;
	elseif (KbT <= 2.7e-169)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (KbT <= 2.25e+184)
		tmp = t_0;
	else
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar + (NdChar / (1.0 + exp((Vef / KbT))));
	tmp = 0.0;
	if (KbT <= -9.6e+210)
		tmp = (NaChar * 0.5) + (NdChar / ((Vef / KbT) + 2.0));
	elseif (KbT <= -4.6e-192)
		tmp = t_0;
	elseif (KbT <= 2.7e-169)
		tmp = NaChar + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (KbT <= 2.25e+184)
		tmp = t_0;
	else
		tmp = (NdChar * 0.5) + (NaChar / ((Ev / KbT) + 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[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -9.6e+210], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -4.6e-192], t$95$0, If[LessEqual[KbT, 2.7e-169], N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.25e+184], t$95$0, N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -9.59999999999999953e210

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 81.4%

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

   5. Taylor expanded in Vef around inf 77.3%

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

   6. Taylor expanded in Vef around 0 77.1%

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

      1. +-commutative 77.1%

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

   8. Simplified 77.1%

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

   if -9.59999999999999953e210 < KbT < -4.60000000000000037e-192 or 2.7000000000000002e-169 < KbT < 2.25000000000000018e184

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.0%

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

   5. Taylor expanded in EAccept around inf 53.1%

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

   6. Taylor expanded in EAccept around 0 65.4%

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

   7. Taylor expanded in Vef around inf 49.0%

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

   if -4.60000000000000037e-192 < KbT < 2.7000000000000002e-169

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 35.5%

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

   5. Taylor expanded in EAccept around inf 56.0%

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

   6. Taylor expanded in EAccept around 0 54.7%

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

   7. Taylor expanded in EDonor around inf 45.1%

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

   if 2.25000000000000018e184 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 96.2%

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

   5. Taylor expanded in KbT around inf 88.1%

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

   6. Taylor expanded in Ev around 0 82.9%

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

4. Final simplification 53.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -9.6 \cdot 10^{+210}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq -4.6 \cdot 10^{-192}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.7 \cdot 10^{-169}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.25 \cdot 10^{+184}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \]

Alternative 13: 50.6% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;KbT \leq -3.6 \cdot 10^{+211}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq -1.85 \cdot 10^{-95}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq 1.35 \cdot 10^{+26}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2 \cdot 10^{+186}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ NaChar (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= KbT -3.6e+211)
     (+ (* NaChar 0.5) (/ NdChar (+ (/ Vef KbT) 2.0)))
     (if (<= KbT -1.85e-95)
       t_0
       (if (<= KbT 1.35e+26)
         (+ NaChar (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
         (if (<= KbT 2e+186)
           t_0
           (+ (* NdChar 0.5) (/ NaChar (+ (/ Ev KbT) 2.0)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (KbT <= -3.6e+211) {
		tmp = (NaChar * 0.5) + (NdChar / ((Vef / KbT) + 2.0));
	} else if (KbT <= -1.85e-95) {
		tmp = t_0;
	} else if (KbT <= 1.35e+26) {
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (KbT <= 2e+186) {
		tmp = t_0;
	} else {
		tmp = (NdChar * 0.5) + (NaChar / ((Ev / KbT) + 2.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (kbt <= (-3.6d+211)) then
        tmp = (nachar * 0.5d0) + (ndchar / ((vef / kbt) + 2.0d0))
    else if (kbt <= (-1.85d-95)) then
        tmp = t_0
    else if (kbt <= 1.35d+26) then
        tmp = nachar + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (kbt <= 2d+186) then
        tmp = t_0
    else
        tmp = (ndchar * 0.5d0) + (nachar / ((ev / kbt) + 2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (KbT <= -3.6e+211) {
		tmp = (NaChar * 0.5) + (NdChar / ((Vef / KbT) + 2.0));
	} else if (KbT <= -1.85e-95) {
		tmp = t_0;
	} else if (KbT <= 1.35e+26) {
		tmp = NaChar + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (KbT <= 2e+186) {
		tmp = t_0;
	} else {
		tmp = (NdChar * 0.5) + (NaChar / ((Ev / KbT) + 2.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if KbT <= -3.6e+211:
		tmp = (NaChar * 0.5) + (NdChar / ((Vef / KbT) + 2.0))
	elif KbT <= -1.85e-95:
		tmp = t_0
	elif KbT <= 1.35e+26:
		tmp = NaChar + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif KbT <= 2e+186:
		tmp = t_0
	else:
		tmp = (NdChar * 0.5) + (NaChar / ((Ev / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (KbT <= -3.6e+211)
		tmp = Float64(Float64(NaChar * 0.5) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0)));
	elseif (KbT <= -1.85e-95)
		tmp = t_0;
	elseif (KbT <= 1.35e+26)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (KbT <= 2e+186)
		tmp = t_0;
	else
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (KbT <= -3.6e+211)
		tmp = (NaChar * 0.5) + (NdChar / ((Vef / KbT) + 2.0));
	elseif (KbT <= -1.85e-95)
		tmp = t_0;
	elseif (KbT <= 1.35e+26)
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (KbT <= 2e+186)
		tmp = t_0;
	else
		tmp = (NdChar * 0.5) + (NaChar / ((Ev / KbT) + 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[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -3.6e+211], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -1.85e-95], t$95$0, If[LessEqual[KbT, 1.35e+26], N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2e+186], t$95$0, N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -3.60000000000000003e211

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 81.4%

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

   5. Taylor expanded in Vef around inf 77.3%

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

   6. Taylor expanded in Vef around 0 77.1%

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

      1. +-commutative 77.1%

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

   8. Simplified 77.1%

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

   if -3.60000000000000003e211 < KbT < -1.84999999999999997e-95 or 1.35e26 < KbT < 1.99999999999999996e186

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 48.8%

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

   5. Taylor expanded in EAccept around inf 51.6%

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

   6. Taylor expanded in EAccept around 0 61.8%

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

   7. Taylor expanded in mu around inf 53.8%

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

   if -1.84999999999999997e-95 < KbT < 1.35e26

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 45.7%

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

   5. Taylor expanded in EAccept around inf 55.8%

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

   6. Taylor expanded in EAccept around 0 63.6%

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

   7. Taylor expanded in Ec around inf 53.6%

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

      1. associate-*r/ 53.6%

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

      2. mul-1-neg 53.6%

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

   9. Simplified 53.6%

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

   if 1.99999999999999996e186 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 96.2%

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

   5. Taylor expanded in KbT around inf 88.1%

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

   6. Taylor expanded in Ev around 0 82.9%

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

4. Final simplification 58.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.6 \cdot 10^{+211}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq -1.85 \cdot 10^{-95}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.35 \cdot 10^{+26}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2 \cdot 10^{+186}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \]

Alternative 14: 50.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+210}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq -2.15 \cdot 10^{-96}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{+56}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))))
   (if (<= KbT -9.2e+210)
     t_0
     (if (<= KbT -2.15e-96)
       (+ NaChar (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
       (if (<= KbT 1.9e+56)
         (+ NaChar (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
         t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -9.2e+210) {
		tmp = t_0;
	} else if (KbT <= -2.15e-96) {
		tmp = NaChar + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (KbT <= 1.9e+56) {
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-9.2d+210)) then
        tmp = t_0
    else if (kbt <= (-2.15d-96)) then
        tmp = nachar + (ndchar / (1.0d0 + exp((mu / kbt))))
    else if (kbt <= 1.9d+56) then
        tmp = nachar + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -9.2e+210) {
		tmp = t_0;
	} else if (KbT <= -2.15e-96) {
		tmp = NaChar + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else if (KbT <= 1.9e+56) {
		tmp = NaChar + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -9.2e+210:
		tmp = t_0
	elif KbT <= -2.15e-96:
		tmp = NaChar + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif KbT <= 1.9e+56:
		tmp = NaChar + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -9.2e+210)
		tmp = t_0;
	elseif (KbT <= -2.15e-96)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (KbT <= 1.9e+56)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -9.2e+210)
		tmp = t_0;
	elseif (KbT <= -2.15e-96)
		tmp = NaChar + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (KbT <= 1.9e+56)
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -9.2e+210], t$95$0, If[LessEqual[KbT, -2.15e-96], N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.9e+56], N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -9.1999999999999995e210 or 1.89999999999999998e56 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 77.5%

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

   5. Taylor expanded in KbT around inf 66.1%

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

   if -9.1999999999999995e210 < KbT < -2.1499999999999999e-96

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.3%

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

   5. Taylor expanded in EAccept around inf 53.0%

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

   6. Taylor expanded in EAccept around 0 64.4%

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

   7. Taylor expanded in mu around inf 53.6%

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

   if -2.1499999999999999e-96 < KbT < 1.89999999999999998e56

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 48.2%

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

   5. Taylor expanded in EAccept around inf 56.9%

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

   6. Taylor expanded in EAccept around 0 64.2%

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

   7. Taylor expanded in Ec around inf 51.9%

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

      1. associate-*r/ 51.9%

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

      2. mul-1-neg 51.9%

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

   9. Simplified 51.9%

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

4. Final simplification 56.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+210}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -2.15 \cdot 10^{-96}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{+56}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 15: 50.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -4.5 \cdot 10^{+221}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -1.9 \cdot 10^{-108}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.5 \cdot 10^{+56}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -4.5e+221)
   (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (* NdChar 0.5))
   (if (<= KbT -1.9e-108)
     (+ NaChar (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
     (if (<= KbT 1.5e+56)
       (+ NaChar (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
       (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -4.5e+221) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= -1.9e-108) {
		tmp = NaChar + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (KbT <= 1.5e+56) {
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -4.5e+221:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar * 0.5)
	elif KbT <= -1.9e-108:
		tmp = NaChar + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif KbT <= 1.5e+56:
		tmp = NaChar + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	else:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -4.5e+221)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= -1.9e-108)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (KbT <= 1.5e+56)
		tmp = Float64(NaChar + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -4.5e+221)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= -1.9e-108)
		tmp = NaChar + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (KbT <= 1.5e+56)
		tmp = NaChar + (NdChar / (1.0 + exp((-Ec / KbT))));
	else
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -4.5e+221], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -1.9e-108], N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.5e+56], N[(NaChar + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -4.5000000000000002e221

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 100.0%

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

   5. Taylor expanded in KbT around inf 84.6%

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

   if -4.5000000000000002e221 < KbT < -1.89999999999999987e-108

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.5%

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

   5. Taylor expanded in EAccept around inf 51.5%

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

   6. Taylor expanded in EAccept around 0 63.6%

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

   7. Taylor expanded in mu around inf 53.4%

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

   if -1.89999999999999987e-108 < KbT < 1.50000000000000003e56

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 48.1%

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

   5. Taylor expanded in EAccept around inf 57.8%

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

   6. Taylor expanded in EAccept around 0 64.4%

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

   7. Taylor expanded in Ec around inf 51.9%

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

      1. associate-*r/ 51.9%

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

      2. mul-1-neg 51.9%

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

   9. Simplified 51.9%

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

   if 1.50000000000000003e56 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 75.9%

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

   5. Taylor expanded in KbT around inf 61.6%

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

4. Final simplification 56.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -4.5 \cdot 10^{+221}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -1.9 \cdot 10^{-108}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.5 \cdot 10^{+56}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 16: 49.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -5.8 \cdot 10^{+211}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq 1.2 \cdot 10^{+186}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -5.8000000000000001e211

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 81.4%

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

   5. Taylor expanded in Vef around inf 77.3%

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

   6. Taylor expanded in Vef around 0 77.1%

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

      1. +-commutative 77.1%

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

   8. Simplified 77.1%

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

   if -5.8000000000000001e211 < KbT < 1.19999999999999998e186

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.2%

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

   5. Taylor expanded in EAccept around inf 53.8%

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

   6. Taylor expanded in EAccept around 0 62.8%

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

   7. Taylor expanded in EDonor around inf 45.0%

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

   if 1.19999999999999998e186 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 96.2%

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

   5. Taylor expanded in KbT around inf 88.1%

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

   6. Taylor expanded in Ev around 0 82.9%

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

4. Final simplification 50.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -5.8 \cdot 10^{+211}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq 1.2 \cdot 10^{+186}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \]

Alternative 17: 51.2% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.35 \cdot 10^{+213}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq 1.7 \cdot 10^{+184}:\\ \;\;\;\;NaChar + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -2.35e+213)
   (+ (* NaChar 0.5) (/ NdChar (+ (/ Vef KbT) 2.0)))
   (if (<= KbT 1.7e+184)
     (+ NaChar (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
     (+ (* NdChar 0.5) (/ NaChar (+ (/ Ev KbT) 2.0))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -2.3499999999999999e213

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 81.4%

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

   5. Taylor expanded in Vef around inf 77.3%

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

   6. Taylor expanded in Vef around 0 77.1%

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

      1. +-commutative 77.1%

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

   8. Simplified 77.1%

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

   if -2.3499999999999999e213 < KbT < 1.7000000000000001e184

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.2%

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

   5. Taylor expanded in EAccept around inf 53.8%

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

   6. Taylor expanded in EAccept around 0 62.8%

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

   7. Taylor expanded in mu around inf 50.0%

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

   if 1.7000000000000001e184 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 96.2%

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

   5. Taylor expanded in KbT around inf 88.1%

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

   6. Taylor expanded in Ev around 0 82.9%

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

4. Final simplification 55.0%

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

Alternative 18: 39.3% accurate, 15.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.8 \cdot 10^{+209}:\\ \;\;\;\;NaChar \cdot 0.5 + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.3 \cdot 10^{+186}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.8e+209], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.3e+186], N[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.80000000000000013e209

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 81.4%

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

   5. Taylor expanded in KbT around inf 77.1%

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

   if -2.80000000000000013e209 < KbT < 1.3e186

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.2%

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

   5. Taylor expanded in EAccept around inf 53.8%

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

   6. Taylor expanded in EAccept around 0 62.8%

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

   7. Taylor expanded in KbT around inf 35.8%

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

   if 1.3e186 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 96.2%

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

   5. Taylor expanded in KbT around inf 88.1%

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

   6. Taylor expanded in Ev around 0 82.9%

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

4. Final simplification 43.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.8 \cdot 10^{+209}:\\ \;\;\;\;NaChar \cdot 0.5 + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.3 \cdot 10^{+186}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \]

Alternative 19: 39.3% accurate, 15.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.2 \cdot 10^{+214}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq 1.65 \cdot 10^{+184}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.2e+214], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.65e+184], N[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.2e214

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 81.4%

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

   5. Taylor expanded in Vef around inf 77.3%

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

   6. Taylor expanded in Vef around 0 77.1%

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

      1. +-commutative 77.1%

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

   8. Simplified 77.1%

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

   if -1.2e214 < KbT < 1.6499999999999999e184

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.2%

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

   5. Taylor expanded in EAccept around inf 53.8%

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

   6. Taylor expanded in EAccept around 0 62.8%

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

   7. Taylor expanded in KbT around inf 35.8%

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

   if 1.6499999999999999e184 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ev around inf 96.2%

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

   5. Taylor expanded in KbT around inf 88.1%

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

   6. Taylor expanded in Ev around 0 82.9%

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

4. Final simplification 43.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.2 \cdot 10^{+214}:\\ \;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq 1.65 \cdot 10^{+184}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \]

Alternative 20: 39.3% accurate, 20.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.05 \cdot 10^{+210} \lor \neg \left(KbT \leq 2 \cdot 10^{+183}\right):\\ \;\;\;\;NaChar \cdot 0.5 + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -1.05e+210) (not (<= KbT 2e+183)))
   (+ (* NaChar 0.5) (* NdChar 0.5))
   (+ NaChar (* NdChar 0.5))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -1.05e+210) || !(KbT <= 2e+183)) {
		tmp = (NaChar * 0.5) + (NdChar * 0.5);
	} else {
		tmp = NaChar + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((kbt <= (-1.05d+210)) .or. (.not. (kbt <= 2d+183))) then
        tmp = (nachar * 0.5d0) + (ndchar * 0.5d0)
    else
        tmp = nachar + (ndchar * 0.5d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -1.05e+210) || !(KbT <= 2e+183)) {
		tmp = (NaChar * 0.5) + (NdChar * 0.5);
	} else {
		tmp = NaChar + (NdChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -1.05e+210) or not (KbT <= 2e+183):
		tmp = (NaChar * 0.5) + (NdChar * 0.5)
	else:
		tmp = NaChar + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -1.05e+210) || !(KbT <= 2e+183))
		tmp = Float64(Float64(NaChar * 0.5) + Float64(NdChar * 0.5));
	else
		tmp = Float64(NaChar + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -1.05e+210) || ~((KbT <= 2e+183)))
		tmp = (NaChar * 0.5) + (NdChar * 0.5);
	else
		tmp = NaChar + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -1.05e+210], N[Not[LessEqual[KbT, 2e+183]], $MachinePrecision]], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -1.0499999999999999e210 or 1.99999999999999989e183 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 86.1%

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

   5. Taylor expanded in KbT around inf 79.8%

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

   if -1.0499999999999999e210 < KbT < 1.99999999999999989e183

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.2%

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

   5. Taylor expanded in EAccept around inf 53.8%

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

   6. Taylor expanded in EAccept around 0 62.8%

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

   7. Taylor expanded in KbT around inf 35.8%

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

4. Final simplification 43.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.05 \cdot 10^{+210} \lor \neg \left(KbT \leq 2 \cdot 10^{+183}\right):\\ \;\;\;\;NaChar \cdot 0.5 + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \end{array} \]

Alternative 21: 35.4% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 53.5%

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

5. Taylor expanded in EAccept around inf 53.5%

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

6. Taylor expanded in EAccept around 0 61.4%

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

7. Taylor expanded in KbT around inf 38.1%

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

8. Final simplification 38.1%

   \[\leadsto NaChar + NdChar \cdot 0.5 \]

Alternative 22: 18.3% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 53.5%

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

5. Taylor expanded in EAccept around inf 53.5%

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

6. Taylor expanded in KbT around inf 26.7%

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

7. Taylor expanded in NdChar around inf 17.9%

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

8. Final simplification 17.9%

   \[\leadsto NdChar \cdot 0.5 \]

Reproduce

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