Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 28.4s

Alternatives: 19

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = 1.7728634315219793e+265
  2. Ec = 1.7381020358646055e+133
  3. Vef = 2.033643946218148e-39
  4. EDonor = -2.9818227439251726e+108
  5. mu = -6.116299170116284e+159
  6. KbT = 3.4366631986344553e-227
  7. NaChar = -1.0718265818771324e+266
  8. Ev = -3.937492981137004e-187
  9. EAccept = -1.3129566642149098e+162

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: 63.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + t\_0\\ t_3 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{if}\;mu \leq -4.8 \cdot 10^{+96}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;mu \leq -3.6 \cdot 10^{-72}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;mu \leq -2.25 \cdot 10^{-121}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.3 \cdot 10^{-273}:\\ \;\;\;\;t\_1 + NdChar \cdot \frac{1}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 1.32 \cdot 10^{-235}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;mu \leq 6.5 \cdot 10^{-204}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t\_0\\ \mathbf{elif}\;mu \leq 1.56 \cdot 10^{-84}:\\ \;\;\;\;t\_1 + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 1.5 \cdot 10^{-13}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 5.8 \cdot 10^{+181}:\\ \;\;\;\;t\_3\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
        (t_2 (+ (/ NaChar (+ 1.0 (exp (/ mu (- KbT))))) t_0))
        (t_3 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
   (if (<= mu -4.8e+96)
     t_2
     (if (<= mu -3.6e-72)
       t_3
       (if (<= mu -2.25e-121)
         (+
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
         (if (<= mu -1.3e-273)
           (+
            t_1
            (*
             NdChar
             (/
              1.0
              (-
               (+ 2.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
               (/ Ec KbT)))))
           (if (<= mu 1.32e-235)
             t_3
             (if (<= mu 6.5e-204)
               (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)
               (if (<= mu 1.56e-84)
                 (+
                  t_1
                  (/
                   NdChar
                   (- (+ 2.0 (+ (/ EDonor KbT) (/ Vef KbT))) (/ Ec KbT))))
                 (if (<= mu 1.5e-13)
                   (+
                    (/
                     NdChar
                     (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
                    (/ NaChar (- 2.0 (/ mu KbT))))
                   (if (<= mu 5.8e+181) t_3 t_2)))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((mu / KbT)));
	double t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = (NaChar / (1.0 + exp((mu / -KbT)))) + t_0;
	double t_3 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	double tmp;
	if (mu <= -4.8e+96) {
		tmp = t_2;
	} else if (mu <= -3.6e-72) {
		tmp = t_3;
	} else if (mu <= -2.25e-121) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (mu <= -1.3e-273) {
		tmp = t_1 + (NdChar * (1.0 / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	} else if (mu <= 1.32e-235) {
		tmp = t_3;
	} else if (mu <= 6.5e-204) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	} else if (mu <= 1.56e-84) {
		tmp = t_1 + (NdChar / ((2.0 + ((EDonor / KbT) + (Vef / KbT))) - (Ec / KbT)));
	} else if (mu <= 1.5e-13) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (2.0 - (mu / KbT)));
	} else if (mu <= 5.8e+181) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((mu / kbt)))
    t_1 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    t_2 = (nachar / (1.0d0 + exp((mu / -kbt)))) + t_0
    t_3 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
    if (mu <= (-4.8d+96)) then
        tmp = t_2
    else if (mu <= (-3.6d-72)) then
        tmp = t_3
    else if (mu <= (-2.25d-121)) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (mu <= (-1.3d-273)) then
        tmp = t_1 + (ndchar * (1.0d0 / ((2.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt))))
    else if (mu <= 1.32d-235) then
        tmp = t_3
    else if (mu <= 6.5d-204) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_0
    else if (mu <= 1.56d-84) then
        tmp = t_1 + (ndchar / ((2.0d0 + ((edonor / kbt) + (vef / kbt))) - (ec / kbt)))
    else if (mu <= 1.5d-13) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (2.0d0 - (mu / kbt)))
    else if (mu <= 5.8d+181) then
        tmp = t_3
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_2 = (NaChar / (1.0 + Math.exp((mu / -KbT)))) + t_0;
	double t_3 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	double tmp;
	if (mu <= -4.8e+96) {
		tmp = t_2;
	} else if (mu <= -3.6e-72) {
		tmp = t_3;
	} else if (mu <= -2.25e-121) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (mu <= -1.3e-273) {
		tmp = t_1 + (NdChar * (1.0 / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	} else if (mu <= 1.32e-235) {
		tmp = t_3;
	} else if (mu <= 6.5e-204) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_0;
	} else if (mu <= 1.56e-84) {
		tmp = t_1 + (NdChar / ((2.0 + ((EDonor / KbT) + (Vef / KbT))) - (Ec / KbT)));
	} else if (mu <= 1.5e-13) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (2.0 - (mu / KbT)));
	} else if (mu <= 5.8e+181) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((mu / KbT)))
	t_1 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	t_2 = (NaChar / (1.0 + math.exp((mu / -KbT)))) + t_0
	t_3 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	tmp = 0
	if mu <= -4.8e+96:
		tmp = t_2
	elif mu <= -3.6e-72:
		tmp = t_3
	elif mu <= -2.25e-121:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif mu <= -1.3e-273:
		tmp = t_1 + (NdChar * (1.0 / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))))
	elif mu <= 1.32e-235:
		tmp = t_3
	elif mu <= 6.5e-204:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_0
	elif mu <= 1.56e-84:
		tmp = t_1 + (NdChar / ((2.0 + ((EDonor / KbT) + (Vef / KbT))) - (Ec / KbT)))
	elif mu <= 1.5e-13:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (2.0 - (mu / KbT)))
	elif mu <= 5.8e+181:
		tmp = t_3
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(mu / Float64(-KbT))))) + t_0)
	t_3 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))
	tmp = 0.0
	if (mu <= -4.8e+96)
		tmp = t_2;
	elseif (mu <= -3.6e-72)
		tmp = t_3;
	elseif (mu <= -2.25e-121)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (mu <= -1.3e-273)
		tmp = Float64(t_1 + Float64(NdChar * Float64(1.0 / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT)))));
	elseif (mu <= 1.32e-235)
		tmp = t_3;
	elseif (mu <= 6.5e-204)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_0);
	elseif (mu <= 1.56e-84)
		tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Vef / KbT))) - Float64(Ec / KbT))));
	elseif (mu <= 1.5e-13)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(2.0 - Float64(mu / KbT))));
	elseif (mu <= 5.8e+181)
		tmp = t_3;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((mu / KbT)));
	t_1 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	t_2 = (NaChar / (1.0 + exp((mu / -KbT)))) + t_0;
	t_3 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	tmp = 0.0;
	if (mu <= -4.8e+96)
		tmp = t_2;
	elseif (mu <= -3.6e-72)
		tmp = t_3;
	elseif (mu <= -2.25e-121)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (mu <= -1.3e-273)
		tmp = t_1 + (NdChar * (1.0 / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	elseif (mu <= 1.32e-235)
		tmp = t_3;
	elseif (mu <= 6.5e-204)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	elseif (mu <= 1.56e-84)
		tmp = t_1 + (NdChar / ((2.0 + ((EDonor / KbT) + (Vef / KbT))) - (Ec / KbT)));
	elseif (mu <= 1.5e-13)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (2.0 - (mu / KbT)));
	elseif (mu <= 5.8e+181)
		tmp = t_3;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / 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[(N[(NaChar / N[(1.0 + N[Exp[N[(mu / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, Block[{t$95$3 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -4.8e+96], t$95$2, If[LessEqual[mu, -3.6e-72], t$95$3, If[LessEqual[mu, -2.25e-121], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -1.3e-273], N[(t$95$1 + N[(NdChar * N[(1.0 / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.32e-235], t$95$3, If[LessEqual[mu, 6.5e-204], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[mu, 1.56e-84], N[(t$95$1 + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.5e-13], 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[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 5.8e+181], t$95$3, t$95$2]]]]]]]]]]]]]

Derivation

1. Split input into 7 regimes

2. if mu < -4.79999999999999986e96 or 5.8e181 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 93.0%

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

   6. Taylor expanded in mu around inf 88.6%

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

      1. mul-1-neg 48.1%

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

      2. distribute-neg-frac2 48.1%

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

   8. Simplified 88.6%

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

   if -4.79999999999999986e96 < mu < -3.6e-72 or -1.29999999999999992e-273 < mu < 1.32e-235 or 1.49999999999999992e-13 < mu < 5.8e181

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 70.4%

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

   6. Taylor expanded in EDonor around 0 47.9%

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

   7. Taylor expanded in NdChar around 0 72.4%

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

      1. associate--l+ 72.4%

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

      2. sub-neg 72.4%

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

      3. associate-+r+ 72.4%

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

      4. mul-1-neg 72.4%

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

      5. mul-1-neg 72.4%

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

      6. associate-+r+ 72.4%

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

      7. sub-neg 72.4%

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

      8. associate--l+ 72.4%

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

      9. associate-+r+ 72.4%

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

   9. Simplified 72.4%

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

   if -3.6e-72 < mu < -2.2500000000000002e-121

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EAccept around inf 83.3%

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

   if -2.2500000000000002e-121 < mu < -1.29999999999999992e-273

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 72.9%

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

      1. div-inv 72.9%

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

   7. Applied egg-rr 72.9%

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

   if 1.32e-235 < mu < 6.49999999999999939e-204

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 82.7%

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

   6. Taylor expanded in Ev around inf 73.5%

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

   if 6.49999999999999939e-204 < mu < 1.55999999999999995e-84

   1. Initial program 100.0%

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

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

   6. Taylor expanded in mu around 0 83.2%

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

   if 1.55999999999999995e-84 < mu < 1.49999999999999992e-13

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 84.0%

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

      1. mul-1-neg 35.1%

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

      2. distribute-neg-frac2 35.1%

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

   7. Simplified 84.0%

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

   8. Taylor expanded in mu around 0 84.0%

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

      1. mul-1-neg 84.0%

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

      2. unsub-neg 84.0%

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

   10. Simplified 84.0%

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

4. Final simplification 79.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -4.8 \cdot 10^{+96}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -3.6 \cdot 10^{-72}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -2.25 \cdot 10^{-121}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.3 \cdot 10^{-273}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot \frac{1}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 1.32 \cdot 10^{-235}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 6.5 \cdot 10^{-204}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.56 \cdot 10^{-84}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 1.5 \cdot 10^{-13}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 5.8 \cdot 10^{+181}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 67.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{if}\;mu \leq -3 \cdot 10^{+95}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;mu \leq -5.2 \cdot 10^{-26}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{-212}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 3 \cdot 10^{-82}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 1.25 \cdot 10^{-12}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 6.6 \cdot 10^{+181}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ mu (- KbT)))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
   (if (<= mu -3e+95)
     t_0
     (if (<= mu -5.2e-26)
       t_1
       (if (<= mu 1.6e-212)
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
         (if (<= mu 3e-82)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
            (/ NdChar (- (+ 2.0 (+ (/ EDonor KbT) (/ Vef KbT))) (/ Ec KbT))))
           (if (<= mu 1.25e-12)
             (+
              (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
              (/ NaChar (- 2.0 (/ mu KbT))))
             (if (<= mu 6.6e+181) t_1 t_0))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((mu / -KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	double tmp;
	if (mu <= -3e+95) {
		tmp = t_0;
	} else if (mu <= -5.2e-26) {
		tmp = t_1;
	} else if (mu <= 1.6e-212) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	} else if (mu <= 3e-82) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + (Vef / KbT))) - (Ec / KbT)));
	} else if (mu <= 1.25e-12) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (2.0 - (mu / KbT)));
	} else if (mu <= 6.6e+181) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((mu / -kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
    if (mu <= (-3d+95)) then
        tmp = t_0
    else if (mu <= (-5.2d-26)) then
        tmp = t_1
    else if (mu <= 1.6d-212) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    else if (mu <= 3d-82) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((2.0d0 + ((edonor / kbt) + (vef / kbt))) - (ec / kbt)))
    else if (mu <= 1.25d-12) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (2.0d0 - (mu / kbt)))
    else if (mu <= 6.6d+181) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((mu / -KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	double tmp;
	if (mu <= -3e+95) {
		tmp = t_0;
	} else if (mu <= -5.2e-26) {
		tmp = t_1;
	} else if (mu <= 1.6e-212) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	} else if (mu <= 3e-82) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + (Vef / KbT))) - (Ec / KbT)));
	} else if (mu <= 1.25e-12) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (2.0 - (mu / KbT)));
	} else if (mu <= 6.6e+181) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((mu / -KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	tmp = 0
	if mu <= -3e+95:
		tmp = t_0
	elif mu <= -5.2e-26:
		tmp = t_1
	elif mu <= 1.6e-212:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	elif mu <= 3e-82:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + (Vef / KbT))) - (Ec / KbT)))
	elif mu <= 1.25e-12:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (2.0 - (mu / KbT)))
	elif mu <= 6.6e+181:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(mu / Float64(-KbT))))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))
	tmp = 0.0
	if (mu <= -3e+95)
		tmp = t_0;
	elseif (mu <= -5.2e-26)
		tmp = t_1;
	elseif (mu <= 1.6e-212)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))));
	elseif (mu <= 3e-82)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Vef / KbT))) - Float64(Ec / KbT))));
	elseif (mu <= 1.25e-12)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(2.0 - Float64(mu / KbT))));
	elseif (mu <= 6.6e+181)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((mu / -KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	tmp = 0.0;
	if (mu <= -3e+95)
		tmp = t_0;
	elseif (mu <= -5.2e-26)
		tmp = t_1;
	elseif (mu <= 1.6e-212)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	elseif (mu <= 3e-82)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + (Vef / KbT))) - (Ec / KbT)));
	elseif (mu <= 1.25e-12)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (2.0 - (mu / KbT)));
	elseif (mu <= 6.6e+181)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(mu / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -3e+95], t$95$0, If[LessEqual[mu, -5.2e-26], t$95$1, If[LessEqual[mu, 1.6e-212], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3e-82], 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[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.25e-12], 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[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 6.6e+181], t$95$1, t$95$0]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if mu < -2.99999999999999991e95 or 6.60000000000000034e181 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 93.0%

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

   6. Taylor expanded in mu around inf 88.6%

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

      1. mul-1-neg 48.1%

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

      2. distribute-neg-frac2 48.1%

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

   8. Simplified 88.6%

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

   if -2.99999999999999991e95 < mu < -5.2000000000000002e-26 or 1.24999999999999992e-12 < mu < 6.60000000000000034e181

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in EDonor around inf 72.9%

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

   6. Taylor expanded in EDonor around 0 51.6%

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

   7. Taylor expanded in NdChar around 0 77.5%

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

      1. associate--l+ 77.5%

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

      2. sub-neg 77.5%

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

      3. associate-+r+ 77.5%

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

      4. mul-1-neg 77.5%

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

      5. mul-1-neg 77.5%

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

      6. associate-+r+ 77.5%

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

      7. sub-neg 77.5%

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

      8. associate--l+ 77.5%

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

      9. associate-+r+ 77.5%

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

   9. Simplified 77.5%

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

   if -5.2000000000000002e-26 < mu < 1.5999999999999999e-212

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 73.8%

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

   6. Taylor expanded in EDonor around 0 64.4%

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

   if 1.5999999999999999e-212 < mu < 2.9999999999999999e-82

   1. Initial program 100.0%

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

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

   6. Taylor expanded in mu around 0 82.3%

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

   if 2.9999999999999999e-82 < mu < 1.24999999999999992e-12

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 84.0%

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

      1. mul-1-neg 35.1%

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

      2. distribute-neg-frac2 35.1%

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

   7. Simplified 84.0%

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

   8. Taylor expanded in mu around 0 84.0%

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

      1. mul-1-neg 84.0%

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

      2. unsub-neg 84.0%

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

   10. Simplified 84.0%

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

4. Final simplification 77.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -3 \cdot 10^{+95}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -5.2 \cdot 10^{-26}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{-212}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 3 \cdot 10^{-82}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 1.25 \cdot 10^{-12}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 6.6 \cdot 10^{+181}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 63.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{if}\;NaChar \leq -2.7 \cdot 10^{-80}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq -9.8 \cdot 10^{-172}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -2.15 \cdot 10^{-197}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NaChar \leq 7.5 \cdot 10^{-84}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 1.4 \cdot 10^{+62} \lor \neg \left(NaChar \leq 3.2 \cdot 10^{+120}\right):\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
   (if (<= NaChar -2.7e-80)
     (+
      (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
      (/ NdChar (+ (/ EDonor KbT) 2.0)))
     (if (<= NaChar -9.8e-172)
       (+
        (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
       (if (<= NaChar -2.15e-197)
         t_0
         (if (<= NaChar 7.5e-84)
           (+
            (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
            (/ NaChar (+ (/ Vef KbT) 2.0)))
           (if (or (<= NaChar 1.4e+62) (not (<= NaChar 3.2e+120)))
             t_0
             (+
              (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
              (/ NdChar (+ 1.0 (exp (/ mu KbT))))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	double tmp;
	if (NaChar <= -2.7e-80) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NaChar <= -9.8e-172) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (NaChar <= -2.15e-197) {
		tmp = t_0;
	} else if (NaChar <= 7.5e-84) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else if ((NaChar <= 1.4e+62) || !(NaChar <= 3.2e+120)) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
    if (nachar <= (-2.7d-80)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (nachar <= (-9.8d-172)) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (nachar <= (-2.15d-197)) then
        tmp = t_0
    else if (nachar <= 7.5d-84) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / ((vef / kbt) + 2.0d0))
    else if ((nachar <= 1.4d+62) .or. (.not. (nachar <= 3.2d+120))) then
        tmp = t_0
    else
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	double tmp;
	if (NaChar <= -2.7e-80) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NaChar <= -9.8e-172) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (NaChar <= -2.15e-197) {
		tmp = t_0;
	} else if (NaChar <= 7.5e-84) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else if ((NaChar <= 1.4e+62) || !(NaChar <= 3.2e+120)) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	tmp = 0
	if NaChar <= -2.7e-80:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	elif NaChar <= -9.8e-172:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif NaChar <= -2.15e-197:
		tmp = t_0
	elif NaChar <= 7.5e-84:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0))
	elif (NaChar <= 1.4e+62) or not (NaChar <= 3.2e+120):
		tmp = t_0
	else:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))
	tmp = 0.0
	if (NaChar <= -2.7e-80)
		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 (NaChar <= -9.8e-172)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (NaChar <= -2.15e-197)
		tmp = t_0;
	elseif (NaChar <= 7.5e-84)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(Float64(Vef / KbT) + 2.0)));
	elseif ((NaChar <= 1.4e+62) || !(NaChar <= 3.2e+120))
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	tmp = 0.0;
	if (NaChar <= -2.7e-80)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NaChar <= -9.8e-172)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (NaChar <= -2.15e-197)
		tmp = t_0;
	elseif (NaChar <= 7.5e-84)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	elseif ((NaChar <= 1.4e+62) || ~((NaChar <= 3.2e+120)))
		tmp = t_0;
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -2.7e-80], 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[NaChar, -9.8e-172], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -2.15e-197], t$95$0, If[LessEqual[NaChar, 7.5e-84], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, 1.4e+62], N[Not[LessEqual[NaChar, 3.2e+120]], $MachinePrecision]], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 5 regimes

2. if NaChar < -2.7000000000000002e-80

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 82.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 67.9%

      \[\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.7000000000000002e-80 < NaChar < -9.8000000000000001e-172

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 70.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 EAccept around inf 65.6%

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

   if -9.8000000000000001e-172 < NaChar < -2.15e-197 or 7.50000000000000026e-84 < NaChar < 1.40000000000000007e62 or 3.19999999999999982e120 < 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 EDonor around inf 70.9%

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

   6. Taylor expanded in EDonor around 0 55.0%

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

   7. Taylor expanded in NdChar around 0 80.1%

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

      1. associate--l+ 80.1%

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

      2. sub-neg 80.1%

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

      3. associate-+r+ 80.1%

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

      4. mul-1-neg 80.1%

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

      5. mul-1-neg 80.1%

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

      6. associate-+r+ 80.1%

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

      7. sub-neg 80.1%

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

      8. associate--l+ 80.1%

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

      9. associate-+r+ 80.1%

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

   9. Simplified 80.1%

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

   if -2.15e-197 < NaChar < 7.50000000000000026e-84

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 77.3%

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

   6. Taylor expanded in Vef around 0 73.0%

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

   if 1.40000000000000007e62 < NaChar < 3.19999999999999982e120

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 100.0%

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

   6. Taylor expanded in Vef around inf 92.5%

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

4. Final simplification 73.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.7 \cdot 10^{-80}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq -9.8 \cdot 10^{-172}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -2.15 \cdot 10^{-197}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 7.5 \cdot 10^{-84}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq 1.4 \cdot 10^{+62} \lor \neg \left(NaChar \leq 3.2 \cdot 10^{+120}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 74.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_1 := t\_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_2 := t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;EDonor \leq -7.5 \cdot 10^{+170}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;EDonor \leq 4.5 \cdot 10^{-223}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;EDonor \leq 9.5 \cdot 10^{-85}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 7.8 \cdot 10^{+26}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT))))))
        (t_2 (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= EDonor -7.5e+170)
     t_2
     (if (<= EDonor 4.5e-223)
       t_1
       (if (<= EDonor 9.5e-85)
         (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
         (if (<= EDonor 7.8e+26) t_1 t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -7.5e+170) {
		tmp = t_2;
	} else if (EDonor <= 4.5e-223) {
		tmp = t_1;
	} else if (EDonor <= 9.5e-85) {
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else if (EDonor <= 7.8e+26) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    t_1 = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    t_2 = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    if (edonor <= (-7.5d+170)) then
        tmp = t_2
    else if (edonor <= 4.5d-223) then
        tmp = t_1
    else if (edonor <= 9.5d-85) then
        tmp = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
    else if (edonor <= 7.8d+26) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -7.5e+170) {
		tmp = t_2;
	} else if (EDonor <= 4.5e-223) {
		tmp = t_1;
	} else if (EDonor <= 9.5e-85) {
		tmp = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else if (EDonor <= 7.8e+26) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	t_1 = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	t_2 = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if EDonor <= -7.5e+170:
		tmp = t_2
	elif EDonor <= 4.5e-223:
		tmp = t_1
	elif EDonor <= 9.5e-85:
		tmp = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	elif EDonor <= 7.8e+26:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	t_2 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (EDonor <= -7.5e+170)
		tmp = t_2;
	elseif (EDonor <= 4.5e-223)
		tmp = t_1;
	elseif (EDonor <= 9.5e-85)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))));
	elseif (EDonor <= 7.8e+26)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	t_1 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	t_2 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (EDonor <= -7.5e+170)
		tmp = t_2;
	elseif (EDonor <= 4.5e-223)
		tmp = t_1;
	elseif (EDonor <= 9.5e-85)
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	elseif (EDonor <= 7.8e+26)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -7.5e+170], t$95$2, If[LessEqual[EDonor, 4.5e-223], t$95$1, If[LessEqual[EDonor, 9.5e-85], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 7.8e+26], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if EDonor < -7.5000000000000002e170 or 7.8e26 < 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 93.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}}} \]

   if -7.5000000000000002e170 < EDonor < 4.49999999999999968e-223 or 9.49999999999999964e-85 < EDonor < 7.8e26

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 80.0%

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

   if 4.49999999999999968e-223 < EDonor < 9.49999999999999964e-85

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in EDonor around inf 53.8%

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

   6. Taylor expanded in EDonor around 0 38.1%

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

   7. Taylor expanded in NdChar around 0 73.1%

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

      1. associate--l+ 73.1%

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

      2. sub-neg 73.1%

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

      3. associate-+r+ 73.1%

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

      4. mul-1-neg 73.1%

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

      5. mul-1-neg 73.1%

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

      6. associate-+r+ 73.1%

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

      7. sub-neg 73.1%

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

      8. associate--l+ 73.1%

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

      9. associate-+r+ 73.1%

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

   9. Simplified 73.1%

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

4. Final simplification 83.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EDonor \leq -7.5 \cdot 10^{+170}:\\ \;\;\;\;\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 4.5 \cdot 10^{-223}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 9.5 \cdot 10^{-85}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 7.8 \cdot 10^{+26}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 72.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ t_2 := t\_1 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -4.5 \cdot 10^{+117}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;mu \leq 1.3 \cdot 10^{+38}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + t\_0\\ \mathbf{elif}\;mu \leq 2.8 \cdot 10^{+156}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 5.8 \cdot 10^{+181}:\\ \;\;\;\;t\_0 + t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ mu (- KbT))))))
        (t_2 (+ t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -4.5e+117)
     t_2
     (if (<= mu 1.3e+38)
       (+ (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))) t_0)
       (if (<= mu 2.8e+156)
         (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
         (if (<= mu 5.8e+181) (+ t_0 t_1) t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((EDonor / KbT)));
	double t_1 = NaChar / (1.0 + exp((mu / -KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -4.5e+117) {
		tmp = t_2;
	} else if (mu <= 1.3e+38) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + t_0;
	} else if (mu <= 2.8e+156) {
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else if (mu <= 5.8e+181) {
		tmp = t_0 + t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((edonor / kbt)))
    t_1 = nachar / (1.0d0 + exp((mu / -kbt)))
    t_2 = t_1 + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-4.5d+117)) then
        tmp = t_2
    else if (mu <= 1.3d+38) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + t_0
    else if (mu <= 2.8d+156) then
        tmp = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
    else if (mu <= 5.8d+181) then
        tmp = t_0 + t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((mu / -KbT)));
	double t_2 = t_1 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -4.5e+117) {
		tmp = t_2;
	} else if (mu <= 1.3e+38) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + t_0;
	} else if (mu <= 2.8e+156) {
		tmp = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else if (mu <= 5.8e+181) {
		tmp = t_0 + t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((EDonor / KbT)))
	t_1 = NaChar / (1.0 + math.exp((mu / -KbT)))
	t_2 = t_1 + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -4.5e+117:
		tmp = t_2
	elif mu <= 1.3e+38:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + t_0
	elif mu <= 2.8e+156:
		tmp = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	elif mu <= 5.8e+181:
		tmp = t_0 + t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(mu / Float64(-KbT)))))
	t_2 = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -4.5e+117)
		tmp = t_2;
	elseif (mu <= 1.3e+38)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + t_0);
	elseif (mu <= 2.8e+156)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))));
	elseif (mu <= 5.8e+181)
		tmp = Float64(t_0 + t_1);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((EDonor / KbT)));
	t_1 = NaChar / (1.0 + exp((mu / -KbT)));
	t_2 = t_1 + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -4.5e+117)
		tmp = t_2;
	elseif (mu <= 1.3e+38)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + t_0;
	elseif (mu <= 2.8e+156)
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	elseif (mu <= 5.8e+181)
		tmp = t_0 + t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(mu / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -4.5e+117], t$95$2, If[LessEqual[mu, 1.3e+38], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[mu, 2.8e+156], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 5.8e+181], N[(t$95$0 + t$95$1), $MachinePrecision], t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if mu < -4.5e117 or 5.8e181 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 92.3%

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

   6. Taylor expanded in mu around inf 87.8%

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

      1. mul-1-neg 46.0%

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

      2. distribute-neg-frac2 46.0%

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

   8. Simplified 87.8%

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

   if -4.5e117 < mu < 1.3e38

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 78.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}}} \]

   if 1.3e38 < mu < 2.79999999999999988e156

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in EDonor around inf 57.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 44.1%

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

   7. Taylor expanded in NdChar around 0 83.3%

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

      1. associate--l+ 83.3%

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

      2. sub-neg 83.3%

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

      3. associate-+r+ 83.3%

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

      4. mul-1-neg 83.3%

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

      5. mul-1-neg 83.3%

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

      6. associate-+r+ 83.3%

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

      7. sub-neg 83.3%

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

      8. associate--l+ 83.3%

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

      9. associate-+r+ 83.3%

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

   9. Simplified 83.3%

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

   if 2.79999999999999988e156 < mu < 5.8e181

   1. Initial program 100.0%

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

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

      1. mul-1-neg 47.1%

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

      2. distribute-neg-frac2 47.1%

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

   8. Simplified 100.0%

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

4. Final simplification 81.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -4.5 \cdot 10^{+117}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.3 \cdot 10^{+38}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.8 \cdot 10^{+156}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 5.8 \cdot 10^{+181}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 75.1% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))))
   (if (<= NdChar -1.95e+70)
     (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (if (or (<= NdChar -5.8e-59) (not (<= NdChar 1e+128)))
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
        (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -1.95e+70) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if ((NdChar <= -5.8e-59) || !(NdChar <= 1e+128)) {
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	tmp = 0
	if NdChar <= -1.95e+70:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif (NdChar <= -5.8e-59) or not (NdChar <= 1e+128):
		tmp = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT))))
	else:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (NdChar <= -1.95e+70)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif ((NdChar <= -5.8e-59) || !(NdChar <= 1e+128))
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (NdChar <= -1.95e+70)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif ((NdChar <= -5.8e-59) || ~((NdChar <= 1e+128)))
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.95e+70], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NdChar, -5.8e-59], N[Not[LessEqual[NdChar, 1e+128]], $MachinePrecision]], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -1.94999999999999987e70

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 80.4%

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

   if -1.94999999999999987e70 < NdChar < -5.80000000000000033e-59 or 1.0000000000000001e128 < 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 Vef around inf 85.4%

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

   if -5.80000000000000033e-59 < NdChar < 1.0000000000000001e128

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 81.3%

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

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

Alternative 8: 75.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.15 \cdot 10^{-78} \lor \neg \left(NaChar \leq 1.4 \cdot 10^{+16}\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 + e^{\frac{mu}{-KbT}}}\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.1500000000000001e-78 or 1.4e16 < 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 EDonor around inf 82.2%

      \[\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.1500000000000001e-78 < NaChar < 1.4e16

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 81.0%

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

      1. mul-1-neg 30.7%

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

      2. distribute-neg-frac2 30.7%

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

   7. Simplified 81.0%

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

4. Final simplification 81.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.15 \cdot 10^{-78} \lor \neg \left(NaChar \leq 1.4 \cdot 10^{+16}\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 + e^{\frac{mu}{-KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 63.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -7 \cdot 10^{-80}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq -4.2 \cdot 10^{-171}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -2.15 \cdot 10^{-197} \lor \neg \left(NaChar \leq 1.1 \cdot 10^{-84} \lor \neg \left(NaChar \leq 4 \cdot 10^{+63}\right) \land NaChar \leq 2.65 \cdot 10^{+110}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -7e-80)
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar (+ (/ EDonor KbT) 2.0)))
   (if (<= NaChar -4.2e-171)
     (+
      (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
      (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
     (if (or (<= NaChar -2.15e-197)
             (not
              (or (<= NaChar 1.1e-84)
                  (and (not (<= NaChar 4e+63)) (<= NaChar 2.65e+110)))))
       (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
       (+
        (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
        (/ NaChar (+ (/ Vef KbT) 2.0)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -7e-80) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NaChar <= -4.2e-171) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if ((NaChar <= -2.15e-197) || !((NaChar <= 1.1e-84) || (!(NaChar <= 4e+63) && (NaChar <= 2.65e+110)))) {
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (nachar <= (-7d-80)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (nachar <= (-4.2d-171)) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if ((nachar <= (-2.15d-197)) .or. (.not. (nachar <= 1.1d-84) .or. (.not. (nachar <= 4d+63)) .and. (nachar <= 2.65d+110))) then
        tmp = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
    else
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / ((vef / kbt) + 2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -7e-80) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NaChar <= -4.2e-171) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if ((NaChar <= -2.15e-197) || !((NaChar <= 1.1e-84) || (!(NaChar <= 4e+63) && (NaChar <= 2.65e+110)))) {
		tmp = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -7e-80:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	elif NaChar <= -4.2e-171:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif (NaChar <= -2.15e-197) or not ((NaChar <= 1.1e-84) or (not (NaChar <= 4e+63) and (NaChar <= 2.65e+110))):
		tmp = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	else:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -7e-80)
		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 (NaChar <= -4.2e-171)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif ((NaChar <= -2.15e-197) || !((NaChar <= 1.1e-84) || (!(NaChar <= 4e+63) && (NaChar <= 2.65e+110))))
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(Float64(Vef / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -7e-80)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NaChar <= -4.2e-171)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif ((NaChar <= -2.15e-197) || ~(((NaChar <= 1.1e-84) || (~((NaChar <= 4e+63)) && (NaChar <= 2.65e+110)))))
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	else
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -7e-80], 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[NaChar, -4.2e-171], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, -2.15e-197], N[Not[Or[LessEqual[NaChar, 1.1e-84], And[N[Not[LessEqual[NaChar, 4e+63]], $MachinePrecision], LessEqual[NaChar, 2.65e+110]]]], $MachinePrecision]], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -7.00000000000000029e-80

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 82.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 67.9%

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

   if -7.00000000000000029e-80 < NaChar < -4.2e-171

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 70.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 EAccept around inf 65.6%

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

   if -4.2e-171 < NaChar < -2.15e-197 or 1.0999999999999999e-84 < NaChar < 4.00000000000000023e63 or 2.6499999999999999e110 < 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 EDonor around inf 72.0%

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

   6. Taylor expanded in EDonor around 0 54.2%

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

   7. Taylor expanded in NdChar around 0 79.6%

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

      1. associate--l+ 79.6%

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

      2. sub-neg 79.6%

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

      3. associate-+r+ 79.6%

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

      4. mul-1-neg 79.6%

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

      5. mul-1-neg 79.6%

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

      6. associate-+r+ 79.6%

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

      7. sub-neg 79.6%

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

      8. associate--l+ 79.6%

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

      9. associate-+r+ 79.6%

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

   9. Simplified 79.6%

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

   if -2.15e-197 < NaChar < 1.0999999999999999e-84 or 4.00000000000000023e63 < NaChar < 2.6499999999999999e110

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 80.2%

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

   6. Taylor expanded in Vef around 0 75.1%

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

4. Final simplification 73.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -7 \cdot 10^{-80}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq -4.2 \cdot 10^{-171}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -2.15 \cdot 10^{-197} \lor \neg \left(NaChar \leq 1.1 \cdot 10^{-84} \lor \neg \left(NaChar \leq 4 \cdot 10^{+63}\right) \land NaChar \leq 2.65 \cdot 10^{+110}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 63.0% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -2.4 \cdot 10^{-88}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;NaChar \leq -2.7 \cdot 10^{-177} \lor \neg \left(NaChar \leq -2.05 \cdot 10^{-197}\right) \land \left(NaChar \leq 1.75 \cdot 10^{-84} \lor \neg \left(NaChar \leq 6.6 \cdot 10^{+63}\right) \land NaChar \leq 2.65 \cdot 10^{+110}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -2.4e-88)
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar 2.0))
   (if (or (<= NaChar -2.7e-177)
           (and (not (<= NaChar -2.05e-197))
                (or (<= NaChar 1.75e-84)
                    (and (not (<= NaChar 6.6e+63)) (<= NaChar 2.65e+110)))))
     (+
      (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
      (/ NaChar (+ (/ Vef KbT) 2.0)))
     (/ 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) {
	double tmp;
	if (NaChar <= -2.4e-88) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	} else if ((NaChar <= -2.7e-177) || (!(NaChar <= -2.05e-197) && ((NaChar <= 1.75e-84) || (!(NaChar <= 6.6e+63) && (NaChar <= 2.65e+110))))) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else {
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - 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 (nachar <= (-2.4d-88)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / 2.0d0)
    else if ((nachar <= (-2.7d-177)) .or. (.not. (nachar <= (-2.05d-197))) .and. (nachar <= 1.75d-84) .or. (.not. (nachar <= 6.6d+63)) .and. (nachar <= 2.65d+110)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / ((vef / kbt) + 2.0d0))
    else
        tmp = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - 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 (NaChar <= -2.4e-88) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	} else if ((NaChar <= -2.7e-177) || (!(NaChar <= -2.05e-197) && ((NaChar <= 1.75e-84) || (!(NaChar <= 6.6e+63) && (NaChar <= 2.65e+110))))) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else {
		tmp = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -2.4e-88:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0)
	elif (NaChar <= -2.7e-177) or (not (NaChar <= -2.05e-197) and ((NaChar <= 1.75e-84) or (not (NaChar <= 6.6e+63) and (NaChar <= 2.65e+110)))):
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0))
	else:
		tmp = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -2.4e-88)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / 2.0));
	elseif ((NaChar <= -2.7e-177) || (!(NaChar <= -2.05e-197) && ((NaChar <= 1.75e-84) || (!(NaChar <= 6.6e+63) && (NaChar <= 2.65e+110)))))
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(Float64(Vef / KbT) + 2.0)));
	else
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -2.4e-88)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	elseif ((NaChar <= -2.7e-177) || (~((NaChar <= -2.05e-197)) && ((NaChar <= 1.75e-84) || (~((NaChar <= 6.6e+63)) && (NaChar <= 2.65e+110)))))
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	else
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -2.4e-88], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, -2.7e-177], And[N[Not[LessEqual[NaChar, -2.05e-197]], $MachinePrecision], Or[LessEqual[NaChar, 1.75e-84], And[N[Not[LessEqual[NaChar, 6.6e+63]], $MachinePrecision], LessEqual[NaChar, 2.65e+110]]]]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.4e-88

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 67.7%

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

   if -2.4e-88 < NaChar < -2.7000000000000002e-177 or -2.05e-197 < NaChar < 1.7500000000000001e-84 or 6.6000000000000003e63 < NaChar < 2.6499999999999999e110

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 77.5%

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

   6. Taylor expanded in Vef around 0 72.7%

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

   if -2.7000000000000002e-177 < NaChar < -2.05e-197 or 1.7500000000000001e-84 < NaChar < 6.6000000000000003e63 or 2.6499999999999999e110 < 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 EDonor around inf 73.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 55.4%

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

   7. Taylor expanded in NdChar around 0 80.3%

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

      1. associate--l+ 80.3%

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

      2. sub-neg 80.3%

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

      3. associate-+r+ 80.3%

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

      4. mul-1-neg 80.3%

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

      5. mul-1-neg 80.3%

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

      6. associate-+r+ 80.3%

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

      7. sub-neg 80.3%

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

      8. associate--l+ 80.3%

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

      9. associate-+r+ 80.3%

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

   9. Simplified 80.3%

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

4. Final simplification 73.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.4 \cdot 10^{-88}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;NaChar \leq -2.7 \cdot 10^{-177} \lor \neg \left(NaChar \leq -2.05 \cdot 10^{-197}\right) \land \left(NaChar \leq 1.75 \cdot 10^{-84} \lor \neg \left(NaChar \leq 6.6 \cdot 10^{+63}\right) \land NaChar \leq 2.65 \cdot 10^{+110}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 64.7% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -3.3 \cdot 10^{-85}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq -2.85 \cdot 10^{-177} \lor \neg \left(NaChar \leq -1.95 \cdot 10^{-197}\right) \land \left(NaChar \leq 7 \cdot 10^{-84} \lor \neg \left(NaChar \leq 2.6 \cdot 10^{+63}\right) \land NaChar \leq 2.7 \cdot 10^{+110}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -3.3e-85)
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar (+ (/ EDonor KbT) 2.0)))
   (if (or (<= NaChar -2.85e-177)
           (and (not (<= NaChar -1.95e-197))
                (or (<= NaChar 7e-84)
                    (and (not (<= NaChar 2.6e+63)) (<= NaChar 2.7e+110)))))
     (+
      (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
      (/ NaChar (+ (/ Vef KbT) 2.0)))
     (/ 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) {
	double tmp;
	if (NaChar <= -3.3e-85) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if ((NaChar <= -2.85e-177) || (!(NaChar <= -1.95e-197) && ((NaChar <= 7e-84) || (!(NaChar <= 2.6e+63) && (NaChar <= 2.7e+110))))) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else {
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - 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 (nachar <= (-3.3d-85)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
    else if ((nachar <= (-2.85d-177)) .or. (.not. (nachar <= (-1.95d-197))) .and. (nachar <= 7d-84) .or. (.not. (nachar <= 2.6d+63)) .and. (nachar <= 2.7d+110)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / ((vef / kbt) + 2.0d0))
    else
        tmp = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - 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 (NaChar <= -3.3e-85) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else if ((NaChar <= -2.85e-177) || (!(NaChar <= -1.95e-197) && ((NaChar <= 7e-84) || (!(NaChar <= 2.6e+63) && (NaChar <= 2.7e+110))))) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	} else {
		tmp = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -3.3e-85:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	elif (NaChar <= -2.85e-177) or (not (NaChar <= -1.95e-197) and ((NaChar <= 7e-84) or (not (NaChar <= 2.6e+63) and (NaChar <= 2.7e+110)))):
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0))
	else:
		tmp = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -3.3e-85)
		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 ((NaChar <= -2.85e-177) || (!(NaChar <= -1.95e-197) && ((NaChar <= 7e-84) || (!(NaChar <= 2.6e+63) && (NaChar <= 2.7e+110)))))
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(Float64(Vef / KbT) + 2.0)));
	else
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -3.3e-85)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	elseif ((NaChar <= -2.85e-177) || (~((NaChar <= -1.95e-197)) && ((NaChar <= 7e-84) || (~((NaChar <= 2.6e+63)) && (NaChar <= 2.7e+110)))))
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / ((Vef / KbT) + 2.0));
	else
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -3.3e-85], 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[Or[LessEqual[NaChar, -2.85e-177], And[N[Not[LessEqual[NaChar, -1.95e-197]], $MachinePrecision], Or[LessEqual[NaChar, 7e-84], And[N[Not[LessEqual[NaChar, 2.6e+63]], $MachinePrecision], LessEqual[NaChar, 2.7e+110]]]]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -3.29999999999999973e-85

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 82.8%

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

   6. Taylor expanded in EDonor around 0 68.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 -3.29999999999999973e-85 < NaChar < -2.8499999999999999e-177 or -1.95e-197 < NaChar < 7.0000000000000002e-84 or 2.6000000000000001e63 < NaChar < 2.7000000000000001e110

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 77.5%

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

   6. Taylor expanded in Vef around 0 72.7%

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

   if -2.8499999999999999e-177 < NaChar < -1.95e-197 or 7.0000000000000002e-84 < NaChar < 2.6000000000000001e63 or 2.7000000000000001e110 < 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 EDonor around inf 73.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 55.4%

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

   7. Taylor expanded in NdChar around 0 80.3%

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

      1. associate--l+ 80.3%

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

      2. sub-neg 80.3%

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

      3. associate-+r+ 80.3%

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

      4. mul-1-neg 80.3%

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

      5. mul-1-neg 80.3%

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

      6. associate-+r+ 80.3%

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

      7. sub-neg 80.3%

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

      8. associate--l+ 80.3%

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

      9. associate-+r+ 80.3%

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

   9. Simplified 80.3%

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

4. Final simplification 73.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3.3 \cdot 10^{-85}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NaChar \leq -2.85 \cdot 10^{-177} \lor \neg \left(NaChar \leq -1.95 \cdot 10^{-197}\right) \land \left(NaChar \leq 7 \cdot 10^{-84} \lor \neg \left(NaChar \leq 2.6 \cdot 10^{+63}\right) \land NaChar \leq 2.7 \cdot 10^{+110}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 60.6% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -5.2 \cdot 10^{-79}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;NaChar \leq -4.9 \cdot 10^{-177} \lor \neg \left(NaChar \leq -1.15 \cdot 10^{-199}\right) \land NaChar \leq 1.32 \cdot 10^{-67}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -5.2e-79)
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar 2.0))
   (if (or (<= NaChar -4.9e-177)
           (and (not (<= NaChar -1.15e-199)) (<= NaChar 1.32e-67)))
     (+
      (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
      (* NaChar 0.5))
     (/ 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) {
	double tmp;
	if (NaChar <= -5.2e-79) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	} else if ((NaChar <= -4.9e-177) || (!(NaChar <= -1.15e-199) && (NaChar <= 1.32e-67))) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	} else {
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - 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 (nachar <= (-5.2d-79)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / 2.0d0)
    else if ((nachar <= (-4.9d-177)) .or. (.not. (nachar <= (-1.15d-199))) .and. (nachar <= 1.32d-67)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar * 0.5d0)
    else
        tmp = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - 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 (NaChar <= -5.2e-79) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	} else if ((NaChar <= -4.9e-177) || (!(NaChar <= -1.15e-199) && (NaChar <= 1.32e-67))) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	} else {
		tmp = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -5.2e-79:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0)
	elif (NaChar <= -4.9e-177) or (not (NaChar <= -1.15e-199) and (NaChar <= 1.32e-67)):
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar * 0.5)
	else:
		tmp = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -5.2e-79)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / 2.0));
	elseif ((NaChar <= -4.9e-177) || (!(NaChar <= -1.15e-199) && (NaChar <= 1.32e-67)))
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar * 0.5));
	else
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -5.2e-79)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / 2.0);
	elseif ((NaChar <= -4.9e-177) || (~((NaChar <= -1.15e-199)) && (NaChar <= 1.32e-67)))
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	else
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -5.2e-79], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, -4.9e-177], And[N[Not[LessEqual[NaChar, -1.15e-199]], $MachinePrecision], LessEqual[NaChar, 1.32e-67]]], 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 * 0.5), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -5.19999999999999987e-79

   1. Initial program 100.0%

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

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

   if -5.19999999999999987e-79 < NaChar < -4.89999999999999987e-177 or -1.1500000000000001e-199 < NaChar < 1.3199999999999999e-67

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 72.8%

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

   6. Taylor expanded in Vef around 0 64.6%

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

   if -4.89999999999999987e-177 < NaChar < -1.1500000000000001e-199 or 1.3199999999999999e-67 < 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 EDonor around inf 74.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 54.3%

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

   7. Taylor expanded in NdChar around 0 76.6%

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

      1. associate--l+ 76.6%

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

      2. sub-neg 76.6%

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

      3. associate-+r+ 76.6%

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

      4. mul-1-neg 76.6%

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

      5. mul-1-neg 76.6%

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

      6. associate-+r+ 76.6%

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

      7. sub-neg 76.6%

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

      8. associate--l+ 76.6%

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

      9. associate-+r+ 76.6%

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

   9. Simplified 76.6%

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

4. Final simplification 69.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -5.2 \cdot 10^{-79}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;NaChar \leq -4.9 \cdot 10^{-177} \lor \neg \left(NaChar \leq -1.15 \cdot 10^{-199}\right) \land NaChar \leq 1.32 \cdot 10^{-67}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 63.1% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -2.4 \cdot 10^{-198} \lor \neg \left(NaChar \leq 2.4 \cdot 10^{-84}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{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-198) (not (<= NaChar 2.4e-84)))
   (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
   (+ (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) 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-198) || !(NaChar <= 2.4e-84)) {
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else {
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / 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-198)) .or. (.not. (nachar <= 2.4d-84))) then
        tmp = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
    else
        tmp = (ndchar / (1.0d0 + exp((((mu + vef) - ec) / 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-198) || !(NaChar <= 2.4e-84)) {
		tmp = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else {
		tmp = (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)))) + (NaChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -2.4e-198) or not (NaChar <= 2.4e-84):
		tmp = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))
	else:
		tmp = (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / 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-198) || !(NaChar <= 2.4e-84))
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / 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-198) || ~((NaChar <= 2.4e-84)))
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	else
		tmp = (NdChar / (1.0 + exp((((mu + Vef) - Ec) / 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-198], N[Not[LessEqual[NaChar, 2.4e-84]], $MachinePrecision]], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.39999999999999986e-198 or 2.40000000000000017e-84 < 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 EDonor around inf 76.8%

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

   6. Taylor expanded in EDonor around 0 58.4%

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

   7. Taylor expanded in NdChar around 0 68.5%

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

      1. associate--l+ 68.5%

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

      2. sub-neg 68.5%

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

      3. associate-+r+ 68.5%

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

      4. mul-1-neg 68.5%

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

      5. mul-1-neg 68.5%

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

      6. associate-+r+ 68.5%

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

      7. sub-neg 68.5%

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

      8. associate--l+ 68.5%

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

      9. associate-+r+ 68.5%

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

   9. Simplified 68.5%

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

   if -2.39999999999999986e-198 < NaChar < 2.40000000000000017e-84

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 77.0%

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

   6. Taylor expanded in Vef around 0 66.8%

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

   7. Taylor expanded in EDonor around 0 64.5%

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

4. Final simplification 67.4%

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

Alternative 14: 60.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.8 \cdot 10^{-198} \lor \neg \left(NaChar \leq 3.4 \cdot 10^{-233}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{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 -1.8e-198) (not (<= NaChar 3.4e-233)))
   (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
   (+ (/ NdChar (+ 1.0 (exp (/ mu 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 <= -1.8e-198) || !(NaChar <= 3.4e-233)) {
		tmp = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else {
		tmp = (NdChar / (1.0 + exp((mu / 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 <= (-1.8d-198)) .or. (.not. (nachar <= 3.4d-233))) then
        tmp = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
    else
        tmp = (ndchar / (1.0d0 + exp((mu / 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 <= -1.8e-198) || !(NaChar <= 3.4e-233)) {
		tmp = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
	} else {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar * 0.5);
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.79999999999999999e-198 or 3.4000000000000002e-233 < 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 EDonor around inf 74.2%

      \[\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 55.2%

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

   7. Taylor expanded in NdChar around 0 66.2%

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

      1. associate--l+ 66.2%

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

      2. sub-neg 66.2%

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

      3. associate-+r+ 66.2%

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

      4. mul-1-neg 66.2%

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

      5. mul-1-neg 66.2%

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

      6. associate-+r+ 66.2%

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

      7. sub-neg 66.2%

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

      8. associate--l+ 66.2%

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

      9. associate-+r+ 66.2%

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

   9. Simplified 66.2%

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

   if -1.79999999999999999e-198 < NaChar < 3.4000000000000002e-233

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 82.5%

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

   6. Taylor expanded in Vef around 0 74.2%

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

   7. Taylor expanded in mu around inf 62.8%

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

4. Final simplification 65.7%

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

Alternative 15: 38.9% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.04999999999999997e-79

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 44.7%

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

   if -2.04999999999999997e-79 < NaChar < 5.7999999999999998e-64

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 69.0%

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

   6. Taylor expanded in Vef around 0 59.6%

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

   7. Taylor expanded in EDonor around inf 43.7%

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

   if 5.7999999999999998e-64 < 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 52.5%

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

   6. Taylor expanded in mu around inf 41.9%

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

      1. mul-1-neg 41.9%

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

      2. distribute-neg-frac2 41.9%

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

   8. Simplified 41.9%

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

4. Final simplification 43.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.05 \cdot 10^{-79}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;NaChar \leq 5.8 \cdot 10^{-64}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}} + \frac{NdChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 39.0% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -3e-79

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 44.7%

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

   if -3e-79 < NaChar < 3.0000000000000001e-59

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 69.0%

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

   6. Taylor expanded in Vef around 0 59.6%

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

   7. Taylor expanded in EDonor around inf 43.7%

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

   if 3.0000000000000001e-59 < 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 52.5%

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

   6. Taylor expanded in Vef around inf 38.8%

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

4. Final simplification 42.7%

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

Alternative 17: 37.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 1.9 \cdot 10^{+80}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 1.9e+80)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
   (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if EAccept <= 1.9e+80:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (EAccept <= 1.9e+80)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 1.89999999999999999e80

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 36.5%

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

   if 1.89999999999999999e80 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 52.4%

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

   6. Taylor expanded in EAccept around inf 44.8%

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

4. Final simplification 38.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 1.9 \cdot 10^{+80}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 35.8% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2} \end{array} \]

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NaChar / (1.0 + exp((EAccept / KbT)))) + (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 / (1.0d0 + exp((eaccept / kbt)))) + (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 / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 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 49.3%

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

6. Taylor expanded in EAccept around inf 34.9%

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

7. Final simplification 34.9%

   \[\leadsto \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2} \]
8. Add Preprocessing

Alternative 19: 28.3% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in EDonor around inf 72.4%

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

6. Taylor expanded in EDonor around 0 52.9%

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

7. Taylor expanded in KbT around inf 28.2%

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

   1. distribute-lft-out 28.2%

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

9. Simplified 28.2%

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

10. Final simplification 28.2%

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

Reproduce

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