Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 34.6s

Alternatives: 22

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -8.313561752830016e+57
  2. Ec = -2.4945296537084976e-46
  3. Vef = -1.9946753767905927e+256
  4. EDonor = -4.187398055696952e-238
  5. mu = -2.976806675322726e+141
  6. KbT = 5.978756095138367e+211
  7. NaChar = 3.248006576784141e+58
  8. Ev = -1.3513601596253324e-243
  9. EAccept = -1.061757776584895e-164

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. 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}}} \]
6. Add Preprocessing

Alternative 2: 71.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;EDonor \leq -1.25 \cdot 10^{+64}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;EDonor \leq -1.6 \cdot 10^{-133}:\\ \;\;\;\;t\_0 + NaChar\\ \mathbf{elif}\;EDonor \leq 5.5 \cdot 10^{-46}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - mu\right)}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 6.6 \cdot 10^{+117} \lor \neg \left(EDonor \leq 6.8 \cdot 10^{+166}\right):\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= EDonor -1.25e+64)
     t_1
     (if (<= EDonor -1.6e-133)
       (+ t_0 NaChar)
       (if (<= EDonor 5.5e-46)
         (+
          (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev mu)) KbT)))))
         (if (or (<= EDonor 6.6e+117) (not (<= EDonor 6.8e+166)))
           t_1
           (+ t_0 (/ NaChar (+ 1.0 (/ Ev KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -1.25e+64) {
		tmp = t_1;
	} else if (EDonor <= -1.6e-133) {
		tmp = t_0 + NaChar;
	} else if (EDonor <= 5.5e-46) {
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp(((Vef + (Ev - mu)) / KbT))));
	} else if ((EDonor <= 6.6e+117) || !(EDonor <= 6.8e+166)) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: 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 / (1.0d0 + exp((edonor / kbt))))
    if (edonor <= (-1.25d+64)) then
        tmp = t_1
    else if (edonor <= (-1.6d-133)) then
        tmp = t_0 + nachar
    else if (edonor <= 5.5d-46) then
        tmp = (ndchar / (1.0d0 + exp((-ec / kbt)))) + (nachar / (1.0d0 + exp(((vef + (ev - mu)) / kbt))))
    else if ((edonor <= 6.6d+117) .or. (.not. (edonor <= 6.8d+166))) then
        tmp = t_1
    else
        tmp = t_0 + (nachar / (1.0d0 + (ev / kbt)))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double 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 / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -1.25e+64) {
		tmp = t_1;
	} else if (EDonor <= -1.6e-133) {
		tmp = t_0 + NaChar;
	} else if (EDonor <= 5.5e-46) {
		tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + (Ev - mu)) / KbT))));
	} else if ((EDonor <= 6.6e+117) || !(EDonor <= 6.8e+166)) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if EDonor <= -1.25e+64:
		tmp = t_1
	elif EDonor <= -1.6e-133:
		tmp = t_0 + NaChar
	elif EDonor <= 5.5e-46:
		tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar / (1.0 + math.exp(((Vef + (Ev - mu)) / KbT))))
	elif (EDonor <= 6.6e+117) or not (EDonor <= 6.8e+166):
		tmp = t_1
	else:
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (EDonor <= -1.25e+64)
		tmp = t_1;
	elseif (EDonor <= -1.6e-133)
		tmp = Float64(t_0 + NaChar);
	elseif (EDonor <= 5.5e-46)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev - mu)) / KbT)))));
	elseif ((EDonor <= 6.6e+117) || !(EDonor <= 6.8e+166))
		tmp = t_1;
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (EDonor <= -1.25e+64)
		tmp = t_1;
	elseif (EDonor <= -1.6e-133)
		tmp = t_0 + NaChar;
	elseif (EDonor <= 5.5e-46)
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp(((Vef + (Ev - mu)) / KbT))));
	elseif ((EDonor <= 6.6e+117) || ~((EDonor <= 6.8e+166)))
		tmp = t_1;
	else
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -1.25e+64], t$95$1, If[LessEqual[EDonor, -1.6e-133], N[(t$95$0 + NaChar), $MachinePrecision], If[LessEqual[EDonor, 5.5e-46], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EDonor, 6.6e+117], N[Not[LessEqual[EDonor, 6.8e+166]], $MachinePrecision]], t$95$1, N[(t$95$0 + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if EDonor < -1.25e64 or 5.49999999999999983e-46 < EDonor < 6.5999999999999996e117 or 6.8000000000000001e166 < EDonor

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 89.5%

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

   if -1.25e64 < EDonor < -1.60000000000000006e-133

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 50.2%

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

   6. Taylor expanded in EAccept around inf 67.7%

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

   7. Taylor expanded in EAccept around 0 85.8%

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

   if -1.60000000000000006e-133 < EDonor < 5.49999999999999983e-46

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in Ec around inf 80.4%

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

      1. associate-*r/ 80.4%

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

      2. mul-1-neg 80.4%

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

   7. Simplified 80.4%

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

   8. Taylor expanded in EAccept around 0 70.8%

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

      1. +-commutative 70.8%

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

      2. +-commutative 70.8%

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

      3. associate--l+ 70.8%

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

   10. Simplified 70.8%

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

   if 6.5999999999999996e117 < EDonor < 6.8000000000000001e166

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.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)}} \]

   6. Taylor expanded in Ev around inf 49.9%

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

4. Final simplification 80.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EDonor \leq -1.25 \cdot 10^{+64}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;EDonor \leq -1.6 \cdot 10^{-133}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;EDonor \leq 5.5 \cdot 10^{-46}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev - mu\right)}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 6.6 \cdot 10^{+117} \lor \neg \left(EDonor \leq 6.8 \cdot 10^{+166}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 74.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_2 := t\_1 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;EDonor \leq -1.2 \cdot 10^{+64}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;EDonor \leq -1.65 \cdot 10^{-129}:\\ \;\;\;\;t\_0 + NaChar\\ \mathbf{elif}\;EDonor \leq 5.8 \cdot 10^{-31}:\\ \;\;\;\;t\_1 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 6.6 \cdot 10^{+117} \lor \neg \left(EDonor \leq 6.8 \cdot 10^{+166}\right):\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
        (t_2 (+ t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= EDonor -1.2e+64)
     t_2
     (if (<= EDonor -1.65e-129)
       (+ t_0 NaChar)
       (if (<= EDonor 5.8e-31)
         (+ t_1 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))
         (if (or (<= EDonor 6.6e+117) (not (<= EDonor 6.8e+166)))
           t_2
           (+ t_0 (/ NaChar (+ 1.0 (/ Ev KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -1.2e+64) {
		tmp = t_2;
	} else if (EDonor <= -1.65e-129) {
		tmp = t_0 + NaChar;
	} else if (EDonor <= 5.8e-31) {
		tmp = t_1 + (NdChar / (1.0 + exp((Vef / KbT))));
	} else if ((EDonor <= 6.6e+117) || !(EDonor <= 6.8e+166)) {
		tmp = t_2;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: 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 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    t_2 = t_1 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    if (edonor <= (-1.2d+64)) then
        tmp = t_2
    else if (edonor <= (-1.65d-129)) then
        tmp = t_0 + nachar
    else if (edonor <= 5.8d-31) then
        tmp = t_1 + (ndchar / (1.0d0 + exp((vef / kbt))))
    else if ((edonor <= 6.6d+117) .or. (.not. (edonor <= 6.8d+166))) then
        tmp = t_2
    else
        tmp = t_0 + (nachar / (1.0d0 + (ev / kbt)))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double 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)));
	double t_2 = t_1 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -1.2e+64) {
		tmp = t_2;
	} else if (EDonor <= -1.65e-129) {
		tmp = t_0 + NaChar;
	} else if (EDonor <= 5.8e-31) {
		tmp = t_1 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	} else if ((EDonor <= 6.6e+117) || !(EDonor <= 6.8e+166)) {
		tmp = t_2;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	t_2 = t_1 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if EDonor <= -1.2e+64:
		tmp = t_2
	elif EDonor <= -1.65e-129:
		tmp = t_0 + NaChar
	elif EDonor <= 5.8e-31:
		tmp = t_1 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	elif (EDonor <= 6.6e+117) or not (EDonor <= 6.8e+166):
		tmp = t_2
	else:
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	t_2 = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (EDonor <= -1.2e+64)
		tmp = t_2;
	elseif (EDonor <= -1.65e-129)
		tmp = Float64(t_0 + NaChar);
	elseif (EDonor <= 5.8e-31)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	elseif ((EDonor <= 6.6e+117) || !(EDonor <= 6.8e+166))
		tmp = t_2;
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	t_2 = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (EDonor <= -1.2e+64)
		tmp = t_2;
	elseif (EDonor <= -1.65e-129)
		tmp = t_0 + NaChar;
	elseif (EDonor <= 5.8e-31)
		tmp = t_1 + (NdChar / (1.0 + exp((Vef / KbT))));
	elseif ((EDonor <= 6.6e+117) || ~((EDonor <= 6.8e+166)))
		tmp = t_2;
	else
		tmp = t_0 + (NaChar / (1.0 + (Ev / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -1.2e+64], t$95$2, If[LessEqual[EDonor, -1.65e-129], N[(t$95$0 + NaChar), $MachinePrecision], If[LessEqual[EDonor, 5.8e-31], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EDonor, 6.6e+117], N[Not[LessEqual[EDonor, 6.8e+166]], $MachinePrecision]], t$95$2, N[(t$95$0 + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if EDonor < -1.2e64 or 5.8000000000000001e-31 < EDonor < 6.5999999999999996e117 or 6.8000000000000001e166 < EDonor

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 90.1%

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

   if -1.2e64 < EDonor < -1.64999999999999994e-129

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 48.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)}} \]

   6. 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 + \color{blue}{\frac{EAccept}{KbT}}} \]

   7. Taylor expanded in EAccept around 0 85.3%

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

   if -1.64999999999999994e-129 < EDonor < 5.8000000000000001e-31

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in Vef around inf 84.8%

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

   if 6.5999999999999996e117 < EDonor < 6.8000000000000001e166

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.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)}} \]

   6. Taylor expanded in Ev around inf 49.9%

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

4. Final simplification 85.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EDonor \leq -1.2 \cdot 10^{+64}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;EDonor \leq -1.65 \cdot 10^{-129}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;EDonor \leq 5.8 \cdot 10^{-31}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 6.6 \cdot 10^{+117} \lor \neg \left(EDonor \leq 6.8 \cdot 10^{+166}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 68.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t\_0 + NaChar\\ \mathbf{if}\;NdChar \leq -7.5 \cdot 10^{-84}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq -2.25 \cdot 10^{-131}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + Vef \cdot \left(\frac{1}{KbT} + \frac{Ev}{Vef \cdot KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 7.4 \cdot 10^{-45}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept + \left(Ev - mu\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 NaChar)))
   (if (<= NdChar -7.5e-84)
     t_1
     (if (<= NdChar -2.25e-131)
       (+
        t_0
        (/
         NaChar
         (+
          1.0
          (-
           (+
            1.0
            (+ (/ EAccept KbT) (* Vef (+ (/ 1.0 KbT) (/ Ev (* Vef KbT))))))
           (/ mu KbT)))))
       (if (<= NdChar 7.4e-45)
         (+
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
          (/ NaChar (+ 1.0 (exp (/ (+ EAccept (- Ev mu)) KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (NdChar <= -7.5e-84) {
		tmp = t_1;
	} else if (NdChar <= -2.25e-131) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))))) - (mu / KbT))));
	} else if (NdChar <= 7.4e-45) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp(((EAccept + (Ev - mu)) / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = t_0 + nachar
    if (ndchar <= (-7.5d-84)) then
        tmp = t_1
    else if (ndchar <= (-2.25d-131)) then
        tmp = t_0 + (nachar / (1.0d0 + ((1.0d0 + ((eaccept / kbt) + (vef * ((1.0d0 / kbt) + (ev / (vef * kbt)))))) - (mu / kbt))))
    else if (ndchar <= 7.4d-45) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp(((eaccept + (ev - mu)) / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (NdChar <= -7.5e-84) {
		tmp = t_1;
	} else if (NdChar <= -2.25e-131) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))))) - (mu / KbT))));
	} else if (NdChar <= 7.4e-45) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp(((EAccept + (Ev - mu)) / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = t_0 + NaChar
	tmp = 0
	if NdChar <= -7.5e-84:
		tmp = t_1
	elif NdChar <= -2.25e-131:
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))))) - (mu / KbT))))
	elif NdChar <= 7.4e-45:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp(((EAccept + (Ev - mu)) / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + NaChar)
	tmp = 0.0
	if (NdChar <= -7.5e-84)
		tmp = t_1;
	elseif (NdChar <= -2.25e-131)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(Vef * Float64(Float64(1.0 / KbT) + Float64(Ev / Float64(Vef * KbT)))))) - Float64(mu / KbT)))));
	elseif (NdChar <= 7.4e-45)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(EAccept + Float64(Ev - mu)) / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = t_0 + NaChar;
	tmp = 0.0;
	if (NdChar <= -7.5e-84)
		tmp = t_1;
	elseif (NdChar <= -2.25e-131)
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))))) - (mu / KbT))));
	elseif (NdChar <= 7.4e-45)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp(((EAccept + (Ev - mu)) / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + NaChar), $MachinePrecision]}, If[LessEqual[NdChar, -7.5e-84], t$95$1, If[LessEqual[NdChar, -2.25e-131], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(Vef * N[(N[(1.0 / KbT), $MachinePrecision] + N[(Ev / N[(Vef * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 7.4e-45], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -7.50000000000000026e-84 or 7.4e-45 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.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)}} \]

   6. Taylor expanded in EAccept around inf 64.8%

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

   7. Taylor expanded in EAccept around 0 78.5%

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

   if -7.50000000000000026e-84 < NdChar < -2.2500000000000001e-131

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 67.4%

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

   6. Taylor expanded in Vef around inf 83.4%

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

   if -2.2500000000000001e-131 < NdChar < 7.4e-45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 85.0%

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

   6. Taylor expanded in Vef around 0 78.1%

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

      1. +-commutative 78.1%

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

      2. associate--l+ 78.1%

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

   8. Simplified 78.1%

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

4. Final simplification 78.6%

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

Alternative 5: 69.5% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
          NaChar)))
   (if (<= NdChar -1.4e-47)
     t_0
     (if (<= NdChar -7.6e-140)
       (+
        (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (- Ev mu)) KbT)))))
       (if (<= NdChar 5.8e-45)
         (+
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
          (/ NaChar (+ 1.0 (exp (/ (+ EAccept (- Ev mu)) KbT)))))
         t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	double tmp;
	if (NdChar <= -1.4e-47) {
		tmp = t_0;
	} else if (NdChar <= -7.6e-140) {
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp(((Vef + (Ev - mu)) / KbT))));
	} else if (NdChar <= 5.8e-45) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp(((EAccept + (Ev - mu)) / KbT))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + nachar
    if (ndchar <= (-1.4d-47)) then
        tmp = t_0
    else if (ndchar <= (-7.6d-140)) then
        tmp = (ndchar / (1.0d0 + exp((-ec / kbt)))) + (nachar / (1.0d0 + exp(((vef + (ev - mu)) / kbt))))
    else if (ndchar <= 5.8d-45) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp(((eaccept + (ev - mu)) / kbt))))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	double tmp;
	if (NdChar <= -1.4e-47) {
		tmp = t_0;
	} else if (NdChar <= -7.6e-140) {
		tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + (Ev - mu)) / KbT))));
	} else if (NdChar <= 5.8e-45) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp(((EAccept + (Ev - mu)) / KbT))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar
	tmp = 0
	if NdChar <= -1.4e-47:
		tmp = t_0
	elif NdChar <= -7.6e-140:
		tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar / (1.0 + math.exp(((Vef + (Ev - mu)) / KbT))))
	elif NdChar <= 5.8e-45:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp(((EAccept + (Ev - mu)) / KbT))))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + NaChar)
	tmp = 0.0
	if (NdChar <= -1.4e-47)
		tmp = t_0;
	elseif (NdChar <= -7.6e-140)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev - mu)) / KbT)))));
	elseif (NdChar <= 5.8e-45)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(EAccept + Float64(Ev - mu)) / KbT)))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + NaChar;
	tmp = 0.0;
	if (NdChar <= -1.4e-47)
		tmp = t_0;
	elseif (NdChar <= -7.6e-140)
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp(((Vef + (Ev - mu)) / KbT))));
	elseif (NdChar <= 5.8e-45)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp(((EAccept + (Ev - mu)) / KbT))));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -1.39999999999999996e-47 or 5.8e-45 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.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)}} \]

   6. Taylor expanded in EAccept around inf 66.0%

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

   7. Taylor expanded in EAccept around 0 77.7%

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

   if -1.39999999999999996e-47 < NdChar < -7.59999999999999997e-140

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 82.3%

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

      1. associate-*r/ 82.3%

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

      2. mul-1-neg 82.3%

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

   7. Simplified 82.3%

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

   8. Taylor expanded in EAccept around 0 62.9%

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

      1. +-commutative 62.9%

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

      2. +-commutative 62.9%

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

      3. associate--l+ 62.9%

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

   10. Simplified 62.9%

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

   if -7.59999999999999997e-140 < NdChar < 5.8e-45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 85.5%

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

   6. Taylor expanded in Vef around 0 79.5%

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

      1. +-commutative 79.5%

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

      2. associate--l+ 79.5%

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

   8. Simplified 79.5%

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

4. Final simplification 77.2%

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

Alternative 6: 67.4% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t\_0 + NaChar\\ \mathbf{if}\;NdChar \leq -8.5 \cdot 10^{-93}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq -8.2 \cdot 10^{-116}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\left(Vef \cdot \left(\frac{1}{KbT} + \frac{Ev}{Vef \cdot KbT}\right) + \left(\frac{EAccept}{KbT} + 2\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq -4.1 \cdot 10^{-131}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 5.2 \cdot 10^{-105}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 5.1 \cdot 10^{-45}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + Ev \cdot \left(\frac{1}{KbT} + \frac{Vef}{KbT \cdot Ev}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 NaChar)))
   (if (<= NdChar -8.5e-93)
     t_1
     (if (<= NdChar -8.2e-116)
       (+
        (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
        (/
         NaChar
         (-
          (+
           (* Vef (+ (/ 1.0 KbT) (/ Ev (* Vef KbT))))
           (+ (/ EAccept KbT) 2.0))
          (/ mu KbT))))
       (if (<= NdChar -4.1e-131)
         t_1
         (if (<= NdChar 5.2e-105)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
            (/ NdChar (+ (/ EDonor KbT) 2.0)))
           (if (<= NdChar 5.1e-45)
             (+
              t_0
              (/
               NaChar
               (+
                1.0
                (-
                 (+
                  1.0
                  (+
                   (/ EAccept KbT)
                   (* Ev (+ (/ 1.0 KbT) (/ Vef (* KbT Ev))))))
                 (/ mu KbT)))))
             t_1)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (NdChar <= -8.5e-93) {
		tmp = t_1;
	} else if (NdChar <= -8.2e-116) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (((Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))) + ((EAccept / KbT) + 2.0)) - (mu / KbT)));
	} else if (NdChar <= -4.1e-131) {
		tmp = t_1;
	} else if (NdChar <= 5.2e-105) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 5.1e-45) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Ev * ((1.0 / KbT) + (Vef / (KbT * Ev)))))) - (mu / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = t_0 + nachar
    if (ndchar <= (-8.5d-93)) then
        tmp = t_1
    else if (ndchar <= (-8.2d-116)) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (((vef * ((1.0d0 / kbt) + (ev / (vef * kbt)))) + ((eaccept / kbt) + 2.0d0)) - (mu / kbt)))
    else if (ndchar <= (-4.1d-131)) then
        tmp = t_1
    else if (ndchar <= 5.2d-105) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (ndchar <= 5.1d-45) then
        tmp = t_0 + (nachar / (1.0d0 + ((1.0d0 + ((eaccept / kbt) + (ev * ((1.0d0 / kbt) + (vef / (kbt * ev)))))) - (mu / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (NdChar <= -8.5e-93) {
		tmp = t_1;
	} else if (NdChar <= -8.2e-116) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (((Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))) + ((EAccept / KbT) + 2.0)) - (mu / KbT)));
	} else if (NdChar <= -4.1e-131) {
		tmp = t_1;
	} else if (NdChar <= 5.2e-105) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 5.1e-45) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Ev * ((1.0 / KbT) + (Vef / (KbT * Ev)))))) - (mu / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = t_0 + NaChar
	tmp = 0
	if NdChar <= -8.5e-93:
		tmp = t_1
	elif NdChar <= -8.2e-116:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (((Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))) + ((EAccept / KbT) + 2.0)) - (mu / KbT)))
	elif NdChar <= -4.1e-131:
		tmp = t_1
	elif NdChar <= 5.2e-105:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	elif NdChar <= 5.1e-45:
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Ev * ((1.0 / KbT) + (Vef / (KbT * Ev)))))) - (mu / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + NaChar)
	tmp = 0.0
	if (NdChar <= -8.5e-93)
		tmp = t_1;
	elseif (NdChar <= -8.2e-116)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(Float64(Float64(Vef * Float64(Float64(1.0 / KbT) + Float64(Ev / Float64(Vef * KbT)))) + Float64(Float64(EAccept / KbT) + 2.0)) - Float64(mu / KbT))));
	elseif (NdChar <= -4.1e-131)
		tmp = t_1;
	elseif (NdChar <= 5.2e-105)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	elseif (NdChar <= 5.1e-45)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(Ev * Float64(Float64(1.0 / KbT) + Float64(Vef / Float64(KbT * Ev)))))) - Float64(mu / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = t_0 + NaChar;
	tmp = 0.0;
	if (NdChar <= -8.5e-93)
		tmp = t_1;
	elseif (NdChar <= -8.2e-116)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (((Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))) + ((EAccept / KbT) + 2.0)) - (mu / KbT)));
	elseif (NdChar <= -4.1e-131)
		tmp = t_1;
	elseif (NdChar <= 5.2e-105)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NdChar <= 5.1e-45)
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Ev * ((1.0 / KbT) + (Vef / (KbT * Ev)))))) - (mu / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + NaChar), $MachinePrecision]}, If[LessEqual[NdChar, -8.5e-93], t$95$1, If[LessEqual[NdChar, -8.2e-116], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(N[(Vef * N[(N[(1.0 / KbT), $MachinePrecision] + N[(Ev / N[(Vef * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -4.1e-131], t$95$1, If[LessEqual[NdChar, 5.2e-105], 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[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 5.1e-45], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(Ev * N[(N[(1.0 / KbT), $MachinePrecision] + N[(Vef / N[(KbT * Ev), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -8.5000000000000007e-93 or -8.1999999999999998e-116 < NdChar < -4.1000000000000002e-131 or 5.0999999999999997e-45 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.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)}} \]

   6. Taylor expanded in EAccept around inf 64.8%

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

   7. Taylor expanded in EAccept around 0 78.1%

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

   if -8.5000000000000007e-93 < NdChar < -8.1999999999999998e-116

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 100.0%

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

   6. Taylor expanded in KbT around inf 80.2%

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

      1. associate-+r+ 80.2%

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

   8. Simplified 80.2%

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

   9. Taylor expanded in Vef around inf 100.0%

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

   if -4.1000000000000002e-131 < NdChar < 5.1999999999999997e-105

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 88.6%

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

   6. Taylor expanded in EDonor around 0 80.1%

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

   if 5.1999999999999997e-105 < NdChar < 5.0999999999999997e-45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 61.4%

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

   6. Taylor expanded in Ev around inf 68.3%

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

4. Final simplification 78.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -8.5 \cdot 10^{-93}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;NdChar \leq -8.2 \cdot 10^{-116}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\left(Vef \cdot \left(\frac{1}{KbT} + \frac{Ev}{Vef \cdot KbT}\right) + \left(\frac{EAccept}{KbT} + 2\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq -4.1 \cdot 10^{-131}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;NdChar \leq 5.2 \cdot 10^{-105}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 5.1 \cdot 10^{-45}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + Ev \cdot \left(\frac{1}{KbT} + \frac{Vef}{KbT \cdot Ev}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 67.4% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t\_0 + NaChar\\ t_2 := t\_0 + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + Vef \cdot \left(\frac{1}{KbT} + \frac{Ev}{Vef \cdot KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{if}\;NdChar \leq -2.1 \cdot 10^{-83}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq -2.06 \cdot 10^{-131}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;NdChar \leq 2.4 \cdot 10^{-105}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 3.6 \cdot 10^{-44}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 NaChar))
        (t_2
         (+
          t_0
          (/
           NaChar
           (+
            1.0
            (-
             (+
              1.0
              (+ (/ EAccept KbT) (* Vef (+ (/ 1.0 KbT) (/ Ev (* Vef KbT))))))
             (/ mu KbT)))))))
   (if (<= NdChar -2.1e-83)
     t_1
     (if (<= NdChar -2.06e-131)
       t_2
       (if (<= NdChar 2.4e-105)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar (+ (/ EDonor KbT) 2.0)))
         (if (<= NdChar 3.6e-44) t_2 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double t_2 = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))))) - (mu / KbT))));
	double tmp;
	if (NdChar <= -2.1e-83) {
		tmp = t_1;
	} else if (NdChar <= -2.06e-131) {
		tmp = t_2;
	} else if (NdChar <= 2.4e-105) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 3.6e-44) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = t_0 + nachar
    t_2 = t_0 + (nachar / (1.0d0 + ((1.0d0 + ((eaccept / kbt) + (vef * ((1.0d0 / kbt) + (ev / (vef * kbt)))))) - (mu / kbt))))
    if (ndchar <= (-2.1d-83)) then
        tmp = t_1
    else if (ndchar <= (-2.06d-131)) then
        tmp = t_2
    else if (ndchar <= 2.4d-105) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (ndchar <= 3.6d-44) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double t_2 = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))))) - (mu / KbT))));
	double tmp;
	if (NdChar <= -2.1e-83) {
		tmp = t_1;
	} else if (NdChar <= -2.06e-131) {
		tmp = t_2;
	} else if (NdChar <= 2.4e-105) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 3.6e-44) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = t_0 + NaChar
	t_2 = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))))) - (mu / KbT))))
	tmp = 0
	if NdChar <= -2.1e-83:
		tmp = t_1
	elif NdChar <= -2.06e-131:
		tmp = t_2
	elif NdChar <= 2.4e-105:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	elif NdChar <= 3.6e-44:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + NaChar)
	t_2 = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(Vef * Float64(Float64(1.0 / KbT) + Float64(Ev / Float64(Vef * KbT)))))) - Float64(mu / KbT)))))
	tmp = 0.0
	if (NdChar <= -2.1e-83)
		tmp = t_1;
	elseif (NdChar <= -2.06e-131)
		tmp = t_2;
	elseif (NdChar <= 2.4e-105)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	elseif (NdChar <= 3.6e-44)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = t_0 + NaChar;
	t_2 = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + (Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))))) - (mu / KbT))));
	tmp = 0.0;
	if (NdChar <= -2.1e-83)
		tmp = t_1;
	elseif (NdChar <= -2.06e-131)
		tmp = t_2;
	elseif (NdChar <= 2.4e-105)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NdChar <= 3.6e-44)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -2.0999999999999999e-83 or 3.5999999999999999e-44 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.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)}} \]

   6. Taylor expanded in EAccept around inf 64.8%

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

   7. Taylor expanded in EAccept around 0 78.5%

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

   if -2.0999999999999999e-83 < NdChar < -2.0599999999999999e-131 or 2.40000000000000015e-105 < NdChar < 3.5999999999999999e-44

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 64.2%

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

   6. Taylor expanded in Vef around inf 78.9%

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

   if -2.0599999999999999e-131 < NdChar < 2.40000000000000015e-105

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 89.5%

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

   6. Taylor expanded in EDonor around 0 80.9%

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

4. Final simplification 79.2%

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

Alternative 8: 67.5% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t\_0 + NaChar\\ \mathbf{if}\;NdChar \leq -9 \cdot 10^{-93}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq -4.3 \cdot 10^{-117}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\left(Vef \cdot \left(\frac{1}{KbT} + \frac{Ev}{Vef \cdot KbT}\right) + \left(\frac{EAccept}{KbT} + 2\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq -5.5 \cdot 10^{-131}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 4.5 \cdot 10^{-105}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 8 \cdot 10^{-44}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \frac{\left(EAccept + \left(Ev + \left(Vef + KbT\right)\right)\right) - mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 NaChar)))
   (if (<= NdChar -9e-93)
     t_1
     (if (<= NdChar -4.3e-117)
       (+
        (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
        (/
         NaChar
         (-
          (+
           (* Vef (+ (/ 1.0 KbT) (/ Ev (* Vef KbT))))
           (+ (/ EAccept KbT) 2.0))
          (/ mu KbT))))
       (if (<= NdChar -5.5e-131)
         t_1
         (if (<= NdChar 4.5e-105)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
            (/ NdChar (+ (/ EDonor KbT) 2.0)))
           (if (<= NdChar 8e-44)
             (+
              t_0
              (/ NaChar (+ 1.0 (/ (- (+ EAccept (+ Ev (+ Vef KbT))) mu) KbT))))
             t_1)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (NdChar <= -9e-93) {
		tmp = t_1;
	} else if (NdChar <= -4.3e-117) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (((Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))) + ((EAccept / KbT) + 2.0)) - (mu / KbT)));
	} else if (NdChar <= -5.5e-131) {
		tmp = t_1;
	} else if (NdChar <= 4.5e-105) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 8e-44) {
		tmp = t_0 + (NaChar / (1.0 + (((EAccept + (Ev + (Vef + KbT))) - mu) / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = t_0 + nachar
    if (ndchar <= (-9d-93)) then
        tmp = t_1
    else if (ndchar <= (-4.3d-117)) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (((vef * ((1.0d0 / kbt) + (ev / (vef * kbt)))) + ((eaccept / kbt) + 2.0d0)) - (mu / kbt)))
    else if (ndchar <= (-5.5d-131)) then
        tmp = t_1
    else if (ndchar <= 4.5d-105) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (ndchar <= 8d-44) then
        tmp = t_0 + (nachar / (1.0d0 + (((eaccept + (ev + (vef + kbt))) - mu) / kbt)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (NdChar <= -9e-93) {
		tmp = t_1;
	} else if (NdChar <= -4.3e-117) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (((Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))) + ((EAccept / KbT) + 2.0)) - (mu / KbT)));
	} else if (NdChar <= -5.5e-131) {
		tmp = t_1;
	} else if (NdChar <= 4.5e-105) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 8e-44) {
		tmp = t_0 + (NaChar / (1.0 + (((EAccept + (Ev + (Vef + KbT))) - mu) / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = t_0 + NaChar
	tmp = 0
	if NdChar <= -9e-93:
		tmp = t_1
	elif NdChar <= -4.3e-117:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (((Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))) + ((EAccept / KbT) + 2.0)) - (mu / KbT)))
	elif NdChar <= -5.5e-131:
		tmp = t_1
	elif NdChar <= 4.5e-105:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	elif NdChar <= 8e-44:
		tmp = t_0 + (NaChar / (1.0 + (((EAccept + (Ev + (Vef + KbT))) - mu) / KbT)))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + NaChar)
	tmp = 0.0
	if (NdChar <= -9e-93)
		tmp = t_1;
	elseif (NdChar <= -4.3e-117)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(Float64(Float64(Vef * Float64(Float64(1.0 / KbT) + Float64(Ev / Float64(Vef * KbT)))) + Float64(Float64(EAccept / KbT) + 2.0)) - Float64(mu / KbT))));
	elseif (NdChar <= -5.5e-131)
		tmp = t_1;
	elseif (NdChar <= 4.5e-105)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	elseif (NdChar <= 8e-44)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(EAccept + Float64(Ev + Float64(Vef + KbT))) - mu) / KbT))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = t_0 + NaChar;
	tmp = 0.0;
	if (NdChar <= -9e-93)
		tmp = t_1;
	elseif (NdChar <= -4.3e-117)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (((Vef * ((1.0 / KbT) + (Ev / (Vef * KbT)))) + ((EAccept / KbT) + 2.0)) - (mu / KbT)));
	elseif (NdChar <= -5.5e-131)
		tmp = t_1;
	elseif (NdChar <= 4.5e-105)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NdChar <= 8e-44)
		tmp = t_0 + (NaChar / (1.0 + (((EAccept + (Ev + (Vef + KbT))) - mu) / KbT)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + NaChar), $MachinePrecision]}, If[LessEqual[NdChar, -9e-93], t$95$1, If[LessEqual[NdChar, -4.3e-117], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(N[(Vef * N[(N[(1.0 / KbT), $MachinePrecision] + N[(Ev / N[(Vef * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -5.5e-131], t$95$1, If[LessEqual[NdChar, 4.5e-105], 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[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 8e-44], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(N[(EAccept + N[(Ev + N[(Vef + KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -9.0000000000000004e-93 or -4.3e-117 < NdChar < -5.4999999999999997e-131 or 7.99999999999999962e-44 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.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)}} \]

   6. Taylor expanded in EAccept around inf 64.8%

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

   7. Taylor expanded in EAccept around 0 78.1%

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

   if -9.0000000000000004e-93 < NdChar < -4.3e-117

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 100.0%

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

   6. Taylor expanded in KbT around inf 80.2%

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

      1. associate-+r+ 80.2%

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

   8. Simplified 80.2%

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

   9. Taylor expanded in Vef around inf 100.0%

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

   if -5.4999999999999997e-131 < NdChar < 4.4999999999999997e-105

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 88.6%

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

   6. Taylor expanded in EDonor around 0 80.1%

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

   if 4.4999999999999997e-105 < NdChar < 7.99999999999999962e-44

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 61.4%

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

   6. Taylor expanded in KbT around 0 61.4%

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

4. Final simplification 78.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -9 \cdot 10^{-93}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;NdChar \leq -4.3 \cdot 10^{-117}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\left(Vef \cdot \left(\frac{1}{KbT} + \frac{Ev}{Vef \cdot KbT}\right) + \left(\frac{EAccept}{KbT} + 2\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq -5.5 \cdot 10^{-131}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;NdChar \leq 4.5 \cdot 10^{-105}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 8 \cdot 10^{-44}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{\left(EAccept + \left(Ev + \left(Vef + KbT\right)\right)\right) - mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 67.9% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t\_0 + NaChar\\ \mathbf{if}\;NdChar \leq -5.2 \cdot 10^{-73}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 2.4 \cdot 10^{-105}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 5.3 \cdot 10^{-45}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \frac{\left(EAccept + \left(Ev + \left(Vef + KbT\right)\right)\right) - mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 NaChar)))
   (if (<= NdChar -5.2e-73)
     t_1
     (if (<= NdChar 2.4e-105)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
        (/ NdChar (+ (/ EDonor KbT) 2.0)))
       (if (<= NdChar 5.3e-45)
         (+
          t_0
          (/ NaChar (+ 1.0 (/ (- (+ EAccept (+ Ev (+ Vef KbT))) mu) KbT))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (NdChar <= -5.2e-73) {
		tmp = t_1;
	} else if (NdChar <= 2.4e-105) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 5.3e-45) {
		tmp = t_0 + (NaChar / (1.0 + (((EAccept + (Ev + (Vef + KbT))) - mu) / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = t_0 + nachar
    if (ndchar <= (-5.2d-73)) then
        tmp = t_1
    else if (ndchar <= 2.4d-105) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (ndchar <= 5.3d-45) then
        tmp = t_0 + (nachar / (1.0d0 + (((eaccept + (ev + (vef + kbt))) - mu) / kbt)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (NdChar <= -5.2e-73) {
		tmp = t_1;
	} else if (NdChar <= 2.4e-105) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 5.3e-45) {
		tmp = t_0 + (NaChar / (1.0 + (((EAccept + (Ev + (Vef + KbT))) - mu) / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = t_0 + NaChar
	tmp = 0
	if NdChar <= -5.2e-73:
		tmp = t_1
	elif NdChar <= 2.4e-105:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	elif NdChar <= 5.3e-45:
		tmp = t_0 + (NaChar / (1.0 + (((EAccept + (Ev + (Vef + KbT))) - mu) / KbT)))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + NaChar)
	tmp = 0.0
	if (NdChar <= -5.2e-73)
		tmp = t_1;
	elseif (NdChar <= 2.4e-105)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	elseif (NdChar <= 5.3e-45)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(EAccept + Float64(Ev + Float64(Vef + KbT))) - mu) / KbT))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = t_0 + NaChar;
	tmp = 0.0;
	if (NdChar <= -5.2e-73)
		tmp = t_1;
	elseif (NdChar <= 2.4e-105)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NdChar <= 5.3e-45)
		tmp = t_0 + (NaChar / (1.0 + (((EAccept + (Ev + (Vef + KbT))) - mu) / KbT)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + NaChar), $MachinePrecision]}, If[LessEqual[NdChar, -5.2e-73], t$95$1, If[LessEqual[NdChar, 2.4e-105], 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[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 5.3e-45], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(N[(EAccept + N[(Ev + N[(Vef + KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -5.2000000000000002e-73 or 5.2999999999999997e-45 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.2%

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

   6. Taylor expanded in EAccept around inf 65.4%

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

   7. Taylor expanded in EAccept around 0 78.2%

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

   if -5.2000000000000002e-73 < NdChar < 2.40000000000000015e-105

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 86.7%

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

   6. Taylor expanded in EDonor around 0 76.3%

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

   if 2.40000000000000015e-105 < NdChar < 5.2999999999999997e-45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 61.4%

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

   6. Taylor expanded in KbT around 0 61.4%

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

4. Final simplification 76.6%

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

Alternative 10: 67.8% accurate, 1.7× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -2.9e-71], N[Not[LessEqual[NdChar, 8.8e-45]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + NaChar), $MachinePrecision], 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[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -2.8999999999999999e-71 or 8.79999999999999974e-45 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.2%

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

   6. Taylor expanded in EAccept around inf 65.4%

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

   7. Taylor expanded in EAccept around 0 78.2%

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

   if -2.8999999999999999e-71 < NdChar < 8.79999999999999974e-45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 83.1%

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

   6. Taylor expanded in EDonor around 0 70.5%

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

4. Final simplification 75.0%

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

Alternative 11: 65.6% accurate, 1.8× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -6.09999999999999964e-140 or 6.2000000000000002e-45 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.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)}} \]

   6. Taylor expanded in EAccept around inf 62.9%

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

   7. Taylor expanded in EAccept around 0 75.4%

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

   if -6.09999999999999964e-140 < NdChar < 6.2000000000000002e-45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 85.5%

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

   6. Taylor expanded in Vef around 0 79.5%

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

      1. +-commutative 79.5%

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

      2. associate--l+ 79.5%

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

   8. Simplified 79.5%

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

   9. Taylor expanded in EDonor around 0 67.7%

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

4. Final simplification 72.8%

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

Alternative 12: 65.1% accurate, 1.8× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.35e-65], N[Not[LessEqual[NdChar, 5.1e-45]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + NaChar), $MachinePrecision], 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 * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -1.3499999999999999e-65 or 5.0999999999999997e-45 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.2%

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

   6. Taylor expanded in EAccept around inf 65.4%

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

   7. Taylor expanded in EAccept around 0 78.2%

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

   if -1.3499999999999999e-65 < NdChar < 5.0999999999999997e-45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 83.1%

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

   6. Taylor expanded in EDonor around 0 64.3%

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

4. Final simplification 72.5%

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

Alternative 13: 46.1% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -3.99999999999999999e98 or 3.60000000000000029e101 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 64.1%

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

   6. Taylor expanded in EDonor around inf 49.1%

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

   if -3.99999999999999999e98 < NdChar < 3.60000000000000029e101

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. inv-pow 99.8%

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

      3. +-commutative 99.8%

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

      4. div-inv 99.8%

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

      5. div-inv 99.8%

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

      6. associate-+r- 99.8%

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

   6. Applied egg-rr 99.8%

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

      1. unpow-1 99.8%

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

      2. +-commutative 99.8%

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

      3. +-commutative 99.8%

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

      4. associate--l+ 99.8%

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

   8. Simplified 99.8%

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

   9. Taylor expanded in KbT around inf 59.1%

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

   10. Taylor expanded in mu around 0 55.2%

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

4. Final simplification 53.1%

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

Alternative 14: 46.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;NdChar \leq -5.8 \cdot 10^{+102}:\\ \;\;\;\;t\_0 + NaChar \cdot 0.5\\ \mathbf{elif}\;NdChar \leq 1.52 \cdot 10^{+99}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{EAccept + \left(Vef + Ev\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \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 KbT))))))
   (if (<= NdChar -5.8e+102)
     (+ t_0 (* NaChar 0.5))
     (if (<= NdChar 1.52e+99)
       (+
        (/ NdChar 2.0)
        (/ NaChar (+ 1.0 (exp (/ (+ EAccept (+ Vef Ev)) KbT)))))
       (+ t_0 (/ NaChar (+ 1.0 (/ EAccept KbT))))))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((EDonor / KbT)))
	tmp = 0
	if NdChar <= -5.8e+102:
		tmp = t_0 + (NaChar * 0.5)
	elif NdChar <= 1.52e+99:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp(((EAccept + (Vef + Ev)) / KbT))))
	else:
		tmp = t_0 + (NaChar / (1.0 + (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(EDonor / KbT))))
	tmp = 0.0
	if (NdChar <= -5.8e+102)
		tmp = Float64(t_0 + Float64(NaChar * 0.5));
	elseif (NdChar <= 1.52e+99)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(EAccept + Float64(Vef + Ev)) / KbT)))));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + 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 / KbT)));
	tmp = 0.0;
	if (NdChar <= -5.8e+102)
		tmp = t_0 + (NaChar * 0.5);
	elseif (NdChar <= 1.52e+99)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp(((EAccept + (Vef + Ev)) / KbT))));
	else
		tmp = t_0 + (NaChar / (1.0 + (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[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -5.8e+102], N[(t$95$0 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.52e+99], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -5.8000000000000005e102

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 64.1%

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

   6. Taylor expanded in EDonor around inf 50.0%

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

   if -5.8000000000000005e102 < NdChar < 1.51999999999999996e99

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. inv-pow 99.8%

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

      3. +-commutative 99.8%

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

      4. div-inv 99.8%

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

      5. div-inv 99.8%

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

      6. associate-+r- 99.8%

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

   6. Applied egg-rr 99.8%

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

      1. unpow-1 99.8%

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

      2. +-commutative 99.8%

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

      3. +-commutative 99.8%

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

      4. associate--l+ 99.8%

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

   8. Simplified 99.8%

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

   9. Taylor expanded in KbT around inf 59.1%

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

   10. Taylor expanded in mu around 0 55.2%

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

   if 1.51999999999999996e99 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 55.4%

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

   6. Taylor expanded in EAccept around inf 74.5%

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

   7. Taylor expanded in EDonor around inf 55.9%

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

4. Final simplification 54.3%

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

Alternative 15: 46.6% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -5.6e+97)
   (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 0.5))
   (if (<= NdChar 8.2e+75)
     (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ (+ EAccept (+ Vef Ev)) KbT)))))
     (+
      (/ NdChar (+ 1.0 (exp (/ mu KbT))))
      (/ NaChar (+ 1.0 (/ EAccept KbT)))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -5.5999999999999998e97

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 64.1%

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

   6. Taylor expanded in EDonor around inf 50.0%

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

   if -5.5999999999999998e97 < NdChar < 8.1999999999999997e75

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. inv-pow 99.8%

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

      3. +-commutative 99.8%

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

      4. div-inv 99.8%

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

      5. div-inv 99.8%

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

      6. associate-+r- 99.8%

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

   6. Applied egg-rr 99.8%

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

      1. unpow-1 99.8%

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

      2. +-commutative 99.8%

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

      3. +-commutative 99.8%

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

      4. associate--l+ 99.8%

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

   8. Simplified 99.8%

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

   9. Taylor expanded in KbT around inf 59.4%

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

   10. Taylor expanded in mu around 0 55.5%

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

   if 8.1999999999999997e75 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 54.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)}} \]

   6. Taylor expanded in EAccept around inf 72.8%

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

   7. Taylor expanded in mu around inf 55.7%

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

4. Final simplification 54.5%

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

Alternative 16: 64.5% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.25e+85], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.12e+204], 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], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.25e85

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.9%

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

      2. inv-pow 99.9%

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

      3. +-commutative 99.9%

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

      4. div-inv 99.9%

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

      5. div-inv 99.9%

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

      6. associate-+r- 99.9%

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

   6. Applied egg-rr 99.9%

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

      1. unpow-1 99.9%

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

      2. +-commutative 99.9%

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

      3. +-commutative 99.9%

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

      4. associate--l+ 99.9%

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

   8. Simplified 99.9%

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

   9. Taylor expanded in KbT around inf 80.5%

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

   10. Taylor expanded in mu around 0 76.1%

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

   if -1.25e85 < KbT < 1.11999999999999996e204

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 50.9%

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

   6. Taylor expanded in EAccept around inf 50.7%

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

   7. Taylor expanded in EAccept around 0 69.8%

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

   if 1.11999999999999996e204 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. inv-pow 99.8%

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

      3. +-commutative 99.8%

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

      4. div-inv 99.8%

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

      5. div-inv 99.8%

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

      6. associate-+r- 99.8%

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

   6. Applied egg-rr 99.8%

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

      1. unpow-1 99.8%

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

      2. +-commutative 99.8%

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

      3. +-commutative 99.8%

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

      4. associate--l+ 99.8%

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

   8. Simplified 99.8%

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

   9. Taylor expanded in KbT around inf 82.9%

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

   10. Taylor expanded in EAccept around 0 79.4%

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

4. Final simplification 71.7%

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

Alternative 17: 39.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -2.4 \cdot 10^{+36} \lor \neg \left(NaChar \leq 5.6 \cdot 10^{-24}\right):\\ \;\;\;\;NaChar + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -2.4e+36], N[Not[LessEqual[NaChar, 5.6e-24]], $MachinePrecision]], N[(NaChar + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.39999999999999992e36 or 5.6000000000000003e-24 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 41.4%

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

   6. Taylor expanded in EAccept around inf 38.0%

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

   7. Taylor expanded in KbT around inf 23.1%

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

   8. Taylor expanded in EAccept around 0 47.8%

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

   if -2.39999999999999992e36 < NaChar < 5.6000000000000003e-24

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.3%

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

   6. Taylor expanded in EDonor around inf 42.4%

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

4. Final simplification 45.1%

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

Alternative 18: 39.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -7.1 \cdot 10^{+31} \lor \neg \left(NaChar \leq 8.6 \cdot 10^{-35}\right):\\ \;\;\;\;NaChar + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -7.1e+31], N[Not[LessEqual[NaChar, 8.6e-35]], $MachinePrecision]], N[(NaChar + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -7.09999999999999961e31 or 8.6000000000000004e-35 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 41.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)}} \]

   6. Taylor expanded in EAccept around inf 38.2%

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

   7. Taylor expanded in KbT around inf 22.9%

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

   8. Taylor expanded in EAccept around 0 47.2%

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

   if -7.09999999999999961e31 < NaChar < 8.6000000000000004e-35

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.3%

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

   6. Taylor expanded in Vef around inf 43.2%

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

4. Final simplification 45.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -7.1 \cdot 10^{+31} \lor \neg \left(NaChar \leq 8.6 \cdot 10^{-35}\right):\\ \;\;\;\;NaChar + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 19: 39.6% accurate, 5.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -8.50000000000000077e180

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 89.6%

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

   6. Taylor expanded in KbT around inf 68.7%

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

      1. associate-+r+ 68.7%

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

   8. Simplified 68.7%

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

   9. Taylor expanded in EDonor around 0 68.7%

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

   if -8.50000000000000077e180 < KbT < 9.9999999999999998e119

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 46.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)}} \]

   6. Taylor expanded in EAccept around inf 49.0%

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

   7. Taylor expanded in KbT around inf 17.3%

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

   8. Taylor expanded in EAccept around 0 36.6%

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

   if 9.9999999999999998e119 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. inv-pow 99.8%

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

      3. +-commutative 99.8%

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

      4. div-inv 99.8%

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

      5. div-inv 99.8%

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

      6. associate-+r- 99.8%

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

   6. Applied egg-rr 99.8%

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

      1. unpow-1 99.8%

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

      2. +-commutative 99.8%

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

      3. +-commutative 99.8%

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

      4. associate--l+ 99.8%

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

   8. Simplified 99.8%

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

   9. Taylor expanded in KbT around inf 74.2%

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

   10. Taylor expanded in KbT around inf 61.6%

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

       1. associate-+r+ 61.6%

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

       2. associate-*r/ 61.6%

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

       3. metadata-eval 61.6%

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

       4. associate-/r* 61.2%

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

   12. Simplified 61.2%

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

4. Final simplification 43.3%

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

Alternative 20: 39.6% accurate, 8.2× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1e+181)
   (+
    (* NdChar 0.5)
    (/
     NaChar
     (- (+ (+ (/ EAccept KbT) 2.0) (+ (/ Vef KbT) (/ Ev KbT))) (/ mu KbT))))
   (if (<= KbT 5.2e+119)
     (+ NaChar (/ NdChar 2.0))
     (+ (/ NdChar 2.0) (* NaChar 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 <= -1e+181) {
		tmp = (NdChar * 0.5) + (NaChar / ((((EAccept / KbT) + 2.0) + ((Vef / KbT) + (Ev / KbT))) - (mu / KbT)));
	} else if (KbT <= 5.2e+119) {
		tmp = NaChar + (NdChar / 2.0);
	} else {
		tmp = (NdChar / 2.0) + (NaChar * 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 <= (-1d+181)) then
        tmp = (ndchar * 0.5d0) + (nachar / ((((eaccept / kbt) + 2.0d0) + ((vef / kbt) + (ev / kbt))) - (mu / kbt)))
    else if (kbt <= 5.2d+119) then
        tmp = nachar + (ndchar / 2.0d0)
    else
        tmp = (ndchar / 2.0d0) + (nachar * 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 <= -1e+181) {
		tmp = (NdChar * 0.5) + (NaChar / ((((EAccept / KbT) + 2.0) + ((Vef / KbT) + (Ev / KbT))) - (mu / KbT)));
	} else if (KbT <= 5.2e+119) {
		tmp = NaChar + (NdChar / 2.0);
	} else {
		tmp = (NdChar / 2.0) + (NaChar * 0.5);
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1e+181], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(N[(N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 5.2e+119], N[(NaChar + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -9.9999999999999992e180

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 89.6%

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

   6. Taylor expanded in KbT around inf 68.7%

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

      1. associate-+r+ 68.7%

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

   8. Simplified 68.7%

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

   9. Taylor expanded in EDonor around 0 68.7%

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

   if -9.9999999999999992e180 < KbT < 5.2e119

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 46.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)}} \]

   6. Taylor expanded in EAccept around inf 49.0%

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

   7. Taylor expanded in KbT around inf 17.3%

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

   8. Taylor expanded in EAccept around 0 36.6%

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

   if 5.2e119 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 79.6%

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

   6. Taylor expanded in KbT around inf 61.2%

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

4. Final simplification 43.4%

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

Alternative 21: 39.5% accurate, 13.4× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -3.7e+152) (not (<= KbT 8.2e+119)))
   (+ (/ NdChar 2.0) (* NaChar 0.5))
   (+ NaChar (/ NdChar 2.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -3.69999999999999996e152 or 8.1999999999999994e119 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 71.4%

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

   6. Taylor expanded in KbT around inf 58.4%

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

   if -3.69999999999999996e152 < KbT < 8.1999999999999994e119

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 46.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)}} \]

   6. Taylor expanded in EAccept around inf 48.9%

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

   7. Taylor expanded in KbT around inf 17.1%

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

   8. Taylor expanded in EAccept around 0 37.0%

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

4. Final simplification 42.9%

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

Alternative 22: 35.8% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 54.4%

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

6. Taylor expanded in EAccept around inf 50.9%

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

7. Taylor expanded in KbT around inf 23.4%

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

8. Taylor expanded in EAccept around 0 38.3%

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

9. Final simplification 38.3%

   \[\leadsto NaChar + \frac{NdChar}{2} \]
10. Add Preprocessing

Reproduce

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