Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 24.9s

Alternatives: 30

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -2.7272760902018922e+110
  2. Ec = -5.2282589578427425e-238
  3. Vef = -1.1075131905977338e+289
  4. EDonor = 2.3192010143170966e-216
  5. mu = -6.998764955105523e+248
  6. KbT = 1.7513239730650296e+264
  7. NaChar = 6.809701856458013e+110
  8. Ev = 4.554634835748695e+244
  9. EAccept = 4.532446526326622e-81

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

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / 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(Float64(Ec - Vef) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef - Float64(Float64(mu - EAccept) - Ev)) / KbT)))))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / 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[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $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(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} \]
6. Add Preprocessing

Alternative 2: 63.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}}\\ t_3 := t\_2 + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{if}\;mu \leq -2.2 \cdot 10^{+113}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq -7.2 \cdot 10^{-70}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;mu \leq -6.2 \cdot 10^{-112}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq -8.2 \cdot 10^{-156}:\\ \;\;\;\;t\_2 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;mu \leq 1.3 \cdot 10^{-250}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 5.2 \cdot 10^{-155}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;mu \leq 7 \cdot 10^{+165}:\\ \;\;\;\;t\_0 + \frac{NaChar}{1 + \left(\left(1 - EAccept \cdot \left(\frac{-1}{KbT} - \left(\frac{Ev}{KbT \cdot EAccept} + \frac{Vef}{KbT \cdot EAccept}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT)))))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ mu (- KbT)))))))
        (t_2 (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT)))))
        (t_3 (+ t_2 (/ NdChar (- 2.0 (/ Ec KbT))))))
   (if (<= mu -2.2e+113)
     t_1
     (if (<= mu -7.2e-70)
       t_3
       (if (<= mu -6.2e-112)
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (if (<= mu -8.2e-156)
           (+ t_2 (/ NdChar (+ (/ Vef KbT) 2.0)))
           (if (<= mu 1.3e-250)
             (+
              t_0
              (/
               NaChar
               (+
                1.0
                (*
                 mu
                 (+
                  (/ (+ (+ 1.0 (/ EAccept KbT)) (+ (/ Ev KbT) (/ Vef KbT))) mu)
                  (/ -1.0 KbT))))))
             (if (<= mu 5.2e-155)
               t_3
               (if (<= mu 7e+165)
                 (+
                  t_0
                  (/
                   NaChar
                   (+
                    1.0
                    (-
                     (-
                      1.0
                      (*
                       EAccept
                       (-
                        (/ -1.0 KbT)
                        (+ (/ Ev (* KbT EAccept)) (/ Vef (* KbT EAccept))))))
                     (/ mu KbT)))))
                 t_1)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((mu / -KbT))));
	double t_2 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_3 = t_2 + (NdChar / (2.0 - (Ec / KbT)));
	double tmp;
	if (mu <= -2.2e+113) {
		tmp = t_1;
	} else if (mu <= -7.2e-70) {
		tmp = t_3;
	} else if (mu <= -6.2e-112) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= -8.2e-156) {
		tmp = t_2 + (NdChar / ((Vef / KbT) + 2.0));
	} else if (mu <= 1.3e-250) {
		tmp = t_0 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	} else if (mu <= 5.2e-155) {
		tmp = t_3;
	} else if (mu <= 7e+165) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 - (EAccept * ((-1.0 / KbT) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept)))))) - (mu / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor - ((ec - vef) - mu)) / kbt)))
    t_1 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((mu / -kbt))))
    t_2 = nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))
    t_3 = t_2 + (ndchar / (2.0d0 - (ec / kbt)))
    if (mu <= (-2.2d+113)) then
        tmp = t_1
    else if (mu <= (-7.2d-70)) then
        tmp = t_3
    else if (mu <= (-6.2d-112)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= (-8.2d-156)) then
        tmp = t_2 + (ndchar / ((vef / kbt) + 2.0d0))
    else if (mu <= 1.3d-250) then
        tmp = t_0 + (nachar / (1.0d0 + (mu * ((((1.0d0 + (eaccept / kbt)) + ((ev / kbt) + (vef / kbt))) / mu) + ((-1.0d0) / kbt)))))
    else if (mu <= 5.2d-155) then
        tmp = t_3
    else if (mu <= 7d+165) then
        tmp = t_0 + (nachar / (1.0d0 + ((1.0d0 - (eaccept * (((-1.0d0) / kbt) - ((ev / (kbt * eaccept)) + (vef / (kbt * eaccept)))))) - (mu / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_1 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((mu / -KbT))));
	double t_2 = NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_3 = t_2 + (NdChar / (2.0 - (Ec / KbT)));
	double tmp;
	if (mu <= -2.2e+113) {
		tmp = t_1;
	} else if (mu <= -7.2e-70) {
		tmp = t_3;
	} else if (mu <= -6.2e-112) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= -8.2e-156) {
		tmp = t_2 + (NdChar / ((Vef / KbT) + 2.0));
	} else if (mu <= 1.3e-250) {
		tmp = t_0 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	} else if (mu <= 5.2e-155) {
		tmp = t_3;
	} else if (mu <= 7e+165) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 - (EAccept * ((-1.0 / KbT) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept)))))) - (mu / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))
	t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((mu / -KbT))))
	t_2 = NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))
	t_3 = t_2 + (NdChar / (2.0 - (Ec / KbT)))
	tmp = 0
	if mu <= -2.2e+113:
		tmp = t_1
	elif mu <= -7.2e-70:
		tmp = t_3
	elif mu <= -6.2e-112:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= -8.2e-156:
		tmp = t_2 + (NdChar / ((Vef / KbT) + 2.0))
	elif mu <= 1.3e-250:
		tmp = t_0 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))))
	elif mu <= 5.2e-155:
		tmp = t_3
	elif mu <= 7e+165:
		tmp = t_0 + (NaChar / (1.0 + ((1.0 - (EAccept * ((-1.0 / KbT) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept)))))) - (mu / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(mu / Float64(-KbT))))))
	t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef - Float64(Float64(mu - EAccept) - Ev)) / KbT))))
	t_3 = Float64(t_2 + Float64(NdChar / Float64(2.0 - Float64(Ec / KbT))))
	tmp = 0.0
	if (mu <= -2.2e+113)
		tmp = t_1;
	elseif (mu <= -7.2e-70)
		tmp = t_3;
	elseif (mu <= -6.2e-112)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= -8.2e-156)
		tmp = Float64(t_2 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0)));
	elseif (mu <= 1.3e-250)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(mu * Float64(Float64(Float64(Float64(1.0 + Float64(EAccept / KbT)) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT))) / mu) + Float64(-1.0 / KbT))))));
	elseif (mu <= 5.2e-155)
		tmp = t_3;
	elseif (mu <= 7e+165)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 - Float64(EAccept * Float64(Float64(-1.0 / KbT) - Float64(Float64(Ev / Float64(KbT * EAccept)) + Float64(Vef / Float64(KbT * EAccept)))))) - Float64(mu / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((mu / -KbT))));
	t_2 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	t_3 = t_2 + (NdChar / (2.0 - (Ec / KbT)));
	tmp = 0.0;
	if (mu <= -2.2e+113)
		tmp = t_1;
	elseif (mu <= -7.2e-70)
		tmp = t_3;
	elseif (mu <= -6.2e-112)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= -8.2e-156)
		tmp = t_2 + (NdChar / ((Vef / KbT) + 2.0));
	elseif (mu <= 1.3e-250)
		tmp = t_0 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	elseif (mu <= 5.2e-155)
		tmp = t_3;
	elseif (mu <= 7e+165)
		tmp = t_0 + (NaChar / (1.0 + ((1.0 - (EAccept * ((-1.0 / KbT) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept)))))) - (mu / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor - N[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(mu / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NdChar / N[(2.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.2e+113], t$95$1, If[LessEqual[mu, -7.2e-70], t$95$3, If[LessEqual[mu, -6.2e-112], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -8.2e-156], N[(t$95$2 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.3e-250], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(mu * N[(N[(N[(N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 5.2e-155], t$95$3, If[LessEqual[mu, 7e+165], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(1.0 - N[(EAccept * N[(N[(-1.0 / KbT), $MachinePrecision] - N[(N[(Ev / N[(KbT * EAccept), $MachinePrecision]), $MachinePrecision] + N[(Vef / N[(KbT * EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if mu < -2.2000000000000001e113 or 6.99999999999999991e165 < 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 89.1%

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

   6. Taylor expanded in mu around inf 81.0%

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

      1. associate-*r/ 81.0%

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

      2. mul-1-neg 81.0%

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

   8. Simplified 81.0%

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

   if -2.2000000000000001e113 < mu < -7.2000000000000004e-70 or 1.30000000000000004e-250 < mu < 5.20000000000000016e-155

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 70.9%

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

      1. associate-*r/ 70.9%

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

      2. mul-1-neg 70.9%

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

   7. Simplified 70.9%

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

   8. Taylor expanded in Ec around 0 74.8%

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

      1. mul-1-neg 74.8%

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

      2. unsub-neg 74.8%

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

   10. Simplified 74.8%

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

   if -7.2000000000000004e-70 < mu < -6.1999999999999995e-112

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 93.5%

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

   6. Taylor expanded in EAccept around inf 75.1%

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

   if -6.1999999999999995e-112 < mu < -8.2000000000000004e-156

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Vef around 0 74.0%

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

   if -8.2000000000000004e-156 < mu < 1.30000000000000004e-250

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 63.4%

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

   6. Taylor expanded in mu around -inf 75.7%

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

      1. mul-1-neg 75.7%

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

      2. distribute-rgt-neg-in 75.7%

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

      3. +-commutative 75.7%

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

      4. mul-1-neg 75.7%

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

      5. unsub-neg 75.7%

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

      6. associate-+r+ 75.7%

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

      7. +-commutative 75.7%

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

   8. Simplified 75.7%

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

   if 5.20000000000000016e-155 < mu < 6.99999999999999991e165

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EAccept around inf 75.8%

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

      1. *-commutative 75.8%

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

      2. *-commutative 75.8%

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

   8. Simplified 75.8%

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

4. Final simplification 76.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -2.2 \cdot 10^{+113}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ \mathbf{elif}\;mu \leq -7.2 \cdot 10^{-70}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq -6.2 \cdot 10^{-112}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq -8.2 \cdot 10^{-156}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;mu \leq 1.3 \cdot 10^{-250}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 5.2 \cdot 10^{-155}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 7 \cdot 10^{+165}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(1 - EAccept \cdot \left(\frac{-1}{KbT} - \left(\frac{Ev}{KbT \cdot EAccept} + \frac{Vef}{KbT \cdot EAccept}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 64.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \mathbf{if}\;Ec \leq -4.5 \cdot 10^{+170}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Ec \leq -1.62 \cdot 10^{-28}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Ec \leq -9.8 \cdot 10^{-148}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \mathbf{elif}\;Ec \leq -1.9 \cdot 10^{-234}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Ec \leq -1.4 \cdot 10^{-286}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 - \frac{mu}{KbT}}\\ \mathbf{elif}\;Ec \leq 4.3 \cdot 10^{+215}:\\ \;\;\;\;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 (/ Ev KbT))))
          (/ NdChar (+ 1.0 (exp (/ Ec (- KbT)))))))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) KbT)))))))
   (if (<= Ec -4.5e+170)
     t_0
     (if (<= Ec -1.62e-28)
       t_1
       (if (<= Ec -9.8e-148)
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (+ Vef Ev) KbT)))))
         (if (<= Ec -1.9e-234)
           t_1
           (if (<= Ec -1.4e-286)
             (+
              (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT))))
              (/ NaChar (- 1.0 (/ mu KbT))))
             (if (<= Ec 4.3e+215) 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((Ev / KbT)))) + (NdChar / (1.0 + exp((Ec / -KbT))));
	double t_1 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
	double tmp;
	if (Ec <= -4.5e+170) {
		tmp = t_0;
	} else if (Ec <= -1.62e-28) {
		tmp = t_1;
	} else if (Ec <= -9.8e-148) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(((Vef + Ev) / KbT))));
	} else if (Ec <= -1.9e-234) {
		tmp = t_1;
	} else if (Ec <= -1.4e-286) {
		tmp = (NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 - (mu / KbT)));
	} else if (Ec <= 4.3e+215) {
		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((ev / kbt)))) + (ndchar / (1.0d0 + exp((ec / -kbt))))
    t_1 = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt))))
    if (ec <= (-4.5d+170)) then
        tmp = t_0
    else if (ec <= (-1.62d-28)) then
        tmp = t_1
    else if (ec <= (-9.8d-148)) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp(((vef + ev) / kbt))))
    else if (ec <= (-1.9d-234)) then
        tmp = t_1
    else if (ec <= (-1.4d-286)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor - ((ec - vef) - mu)) / kbt)))) + (nachar / (1.0d0 - (mu / kbt)))
    else if (ec <= 4.3d+215) 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((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((Ec / -KbT))));
	double t_1 = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT))));
	double tmp;
	if (Ec <= -4.5e+170) {
		tmp = t_0;
	} else if (Ec <= -1.62e-28) {
		tmp = t_1;
	} else if (Ec <= -9.8e-148) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + Ev) / KbT))));
	} else if (Ec <= -1.9e-234) {
		tmp = t_1;
	} else if (Ec <= -1.4e-286) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 - (mu / KbT)));
	} else if (Ec <= 4.3e+215) {
		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((Ev / KbT)))) + (NdChar / (1.0 + math.exp((Ec / -KbT))))
	t_1 = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT))))
	tmp = 0
	if Ec <= -4.5e+170:
		tmp = t_0
	elif Ec <= -1.62e-28:
		tmp = t_1
	elif Ec <= -9.8e-148:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp(((Vef + Ev) / KbT))))
	elif Ec <= -1.9e-234:
		tmp = t_1
	elif Ec <= -1.4e-286:
		tmp = (NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 - (mu / KbT)))
	elif Ec <= 4.3e+215:
		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(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-KbT))))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT)))))
	tmp = 0.0
	if (Ec <= -4.5e+170)
		tmp = t_0;
	elseif (Ec <= -1.62e-28)
		tmp = t_1;
	elseif (Ec <= -9.8e-148)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Ev) / KbT)))));
	elseif (Ec <= -1.9e-234)
		tmp = t_1;
	elseif (Ec <= -1.4e-286)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 - Float64(mu / KbT))));
	elseif (Ec <= 4.3e+215)
		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((Ev / KbT)))) + (NdChar / (1.0 + exp((Ec / -KbT))));
	t_1 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
	tmp = 0.0;
	if (Ec <= -4.5e+170)
		tmp = t_0;
	elseif (Ec <= -1.62e-28)
		tmp = t_1;
	elseif (Ec <= -9.8e-148)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(((Vef + Ev) / KbT))));
	elseif (Ec <= -1.9e-234)
		tmp = t_1;
	elseif (Ec <= -1.4e-286)
		tmp = (NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 - (mu / KbT)));
	elseif (Ec <= 4.3e+215)
		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[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ec, -4.5e+170], t$95$0, If[LessEqual[Ec, -1.62e-28], t$95$1, If[LessEqual[Ec, -9.8e-148], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + Ev), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, -1.9e-234], t$95$1, If[LessEqual[Ec, -1.4e-286], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor - N[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, 4.3e+215], t$95$1, t$95$0]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if Ec < -4.50000000000000022e170 or 4.3000000000000003e215 < Ec

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 94.2%

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

      1. associate-*r/ 94.2%

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

      2. mul-1-neg 94.2%

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

   7. Simplified 94.2%

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

   8. Taylor expanded in Ev around inf 72.3%

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

   if -4.50000000000000022e170 < Ec < -1.62e-28 or -9.8000000000000001e-148 < Ec < -1.89999999999999992e-234 or -1.4e-286 < Ec < 4.3000000000000003e215

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around 0 71.3%

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

      1. +-commutative 71.3%

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

   8. Simplified 71.3%

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

   if -1.62e-28 < Ec < -9.8000000000000001e-148

   1. Initial program 100.0%

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

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

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

   if -1.89999999999999992e-234 < Ec < -1.4e-286

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.4%

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

   6. Taylor expanded in mu around inf 90.3%

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

      1. neg-mul-1 90.3%

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

      2. distribute-frac-neg2 90.3%

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

   8. Simplified 90.3%

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

4. Final simplification 72.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ec \leq -4.5 \cdot 10^{+170}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;Ec \leq -1.62 \cdot 10^{-28}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \mathbf{elif}\;Ec \leq -9.8 \cdot 10^{-148}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}}\\ \mathbf{elif}\;Ec \leq -1.9 \cdot 10^{-234}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \mathbf{elif}\;Ec \leq -1.4 \cdot 10^{-286}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 - \frac{mu}{KbT}}\\ \mathbf{elif}\;Ec \leq 4.3 \cdot 10^{+215}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 64.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}}\\ t_3 := t\_2 + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{if}\;NdChar \leq -1.12 \cdot 10^{-18}:\\ \;\;\;\;t\_2 + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq -1.85 \cdot 10^{-88}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;NdChar \leq -6.6 \cdot 10^{-252}:\\ \;\;\;\;t\_1 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -2.1 \cdot 10^{-275}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;NdChar \leq 1.05 \cdot 10^{-78}:\\ \;\;\;\;t\_1 + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.4 \cdot 10^{-19}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT)))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT)))))
        (t_3
         (+
          t_2
          (/
           NaChar
           (+
            1.0
            (*
             mu
             (+
              (/ (+ (+ 1.0 (/ EAccept KbT)) (+ (/ Ev KbT) (/ Vef KbT))) mu)
              (/ -1.0 KbT))))))))
   (if (<= NdChar -1.12e-18)
     (+ t_2 (/ NaChar (+ 1.0 (/ Vef KbT))))
     (if (<= NdChar -1.85e-88)
       t_3
       (if (<= NdChar -6.6e-252)
         (+ t_1 (/ NdChar (+ (/ Vef KbT) 2.0)))
         (if (<= NdChar -2.1e-275)
           (+ t_0 (/ NdChar (+ 1.0 (exp (/ Ec (- KbT))))))
           (if (<= NdChar 1.05e-78)
             (+ t_1 (/ NdChar (- 2.0 (/ Ec KbT))))
             (if (<= NdChar 2.4e-19)
               (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
               t_3))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((Ev / KbT)));
	double t_1 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_2 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	double tmp;
	if (NdChar <= -1.12e-18) {
		tmp = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	} else if (NdChar <= -1.85e-88) {
		tmp = t_3;
	} else if (NdChar <= -6.6e-252) {
		tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0));
	} else if (NdChar <= -2.1e-275) {
		tmp = t_0 + (NdChar / (1.0 + exp((Ec / -KbT))));
	} else if (NdChar <= 1.05e-78) {
		tmp = t_1 + (NdChar / (2.0 - (Ec / KbT)));
	} else if (NdChar <= 2.4e-19) {
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((ev / kbt)))
    t_1 = nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))
    t_2 = ndchar / (1.0d0 + exp(((edonor - ((ec - vef) - mu)) / kbt)))
    t_3 = t_2 + (nachar / (1.0d0 + (mu * ((((1.0d0 + (eaccept / kbt)) + ((ev / kbt) + (vef / kbt))) / mu) + ((-1.0d0) / kbt)))))
    if (ndchar <= (-1.12d-18)) then
        tmp = t_2 + (nachar / (1.0d0 + (vef / kbt)))
    else if (ndchar <= (-1.85d-88)) then
        tmp = t_3
    else if (ndchar <= (-6.6d-252)) then
        tmp = t_1 + (ndchar / ((vef / kbt) + 2.0d0))
    else if (ndchar <= (-2.1d-275)) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((ec / -kbt))))
    else if (ndchar <= 1.05d-78) then
        tmp = t_1 + (ndchar / (2.0d0 - (ec / kbt)))
    else if (ndchar <= 2.4d-19) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((Ev / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_2 = NdChar / (1.0 + Math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	double tmp;
	if (NdChar <= -1.12e-18) {
		tmp = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	} else if (NdChar <= -1.85e-88) {
		tmp = t_3;
	} else if (NdChar <= -6.6e-252) {
		tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0));
	} else if (NdChar <= -2.1e-275) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((Ec / -KbT))));
	} else if (NdChar <= 1.05e-78) {
		tmp = t_1 + (NdChar / (2.0 - (Ec / KbT)));
	} else if (NdChar <= 2.4e-19) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((Ev / KbT)))
	t_1 = NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))
	t_2 = NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))
	t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))))
	tmp = 0
	if NdChar <= -1.12e-18:
		tmp = t_2 + (NaChar / (1.0 + (Vef / KbT)))
	elif NdChar <= -1.85e-88:
		tmp = t_3
	elif NdChar <= -6.6e-252:
		tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0))
	elif NdChar <= -2.1e-275:
		tmp = t_0 + (NdChar / (1.0 + math.exp((Ec / -KbT))))
	elif NdChar <= 1.05e-78:
		tmp = t_1 + (NdChar / (2.0 - (Ec / KbT)))
	elif NdChar <= 2.4e-19:
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = t_3
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef - Float64(Float64(mu - EAccept) - Ev)) / KbT))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT))))
	t_3 = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(mu * Float64(Float64(Float64(Float64(1.0 + Float64(EAccept / KbT)) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT))) / mu) + Float64(-1.0 / KbT))))))
	tmp = 0.0
	if (NdChar <= -1.12e-18)
		tmp = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(Vef / KbT))));
	elseif (NdChar <= -1.85e-88)
		tmp = t_3;
	elseif (NdChar <= -6.6e-252)
		tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0)));
	elseif (NdChar <= -2.1e-275)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-KbT))))));
	elseif (NdChar <= 1.05e-78)
		tmp = Float64(t_1 + Float64(NdChar / Float64(2.0 - Float64(Ec / KbT))));
	elseif (NdChar <= 2.4e-19)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((Ev / KbT)));
	t_1 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	t_2 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	tmp = 0.0;
	if (NdChar <= -1.12e-18)
		tmp = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	elseif (NdChar <= -1.85e-88)
		tmp = t_3;
	elseif (NdChar <= -6.6e-252)
		tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0));
	elseif (NdChar <= -2.1e-275)
		tmp = t_0 + (NdChar / (1.0 + exp((Ec / -KbT))));
	elseif (NdChar <= 1.05e-78)
		tmp = t_1 + (NdChar / (2.0 - (Ec / KbT)));
	elseif (NdChar <= 2.4e-19)
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor - N[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NaChar / N[(1.0 + N[(mu * N[(N[(N[(N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.12e-18], N[(t$95$2 + N[(NaChar / N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -1.85e-88], t$95$3, If[LessEqual[NdChar, -6.6e-252], N[(t$95$1 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2.1e-275], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.05e-78], N[(t$95$1 + N[(NdChar / N[(2.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.4e-19], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if NdChar < -1.12000000000000001e-18

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.4%

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

   6. Taylor expanded in Vef around inf 72.8%

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

   if -1.12000000000000001e-18 < NdChar < -1.8499999999999999e-88 or 2.40000000000000023e-19 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 68.4%

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

   6. Taylor expanded in mu around -inf 76.0%

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

      1. mul-1-neg 76.0%

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

      2. distribute-rgt-neg-in 76.0%

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

      3. +-commutative 76.0%

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

      4. mul-1-neg 76.0%

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

      5. unsub-neg 76.0%

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

      6. associate-+r+ 76.0%

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

      7. +-commutative 76.0%

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

   8. Simplified 76.0%

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

   if -1.8499999999999999e-88 < NdChar < -6.60000000000000018e-252

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Vef around 0 88.0%

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

   if -6.60000000000000018e-252 < NdChar < -2.09999999999999988e-275

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 100.0%

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

      1. associate-*r/ 100.0%

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

      2. mul-1-neg 100.0%

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

   7. Simplified 100.0%

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

   8. Taylor expanded in Ev around inf 100.0%

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

   if -2.09999999999999988e-275 < NdChar < 1.05e-78

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 76.0%

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

      1. associate-*r/ 76.0%

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

      2. mul-1-neg 76.0%

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

   7. Simplified 76.0%

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

   8. Taylor expanded in Ec around 0 73.8%

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

      1. mul-1-neg 73.8%

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

      2. unsub-neg 73.8%

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

   10. Simplified 73.8%

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

   if 1.05e-78 < NdChar < 2.40000000000000023e-19

   1. Initial program 100.0%

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

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

4. Final simplification 77.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -1.12 \cdot 10^{-18}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq -1.85 \cdot 10^{-88}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq -6.6 \cdot 10^{-252}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -2.1 \cdot 10^{-275}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;NdChar \leq 1.05 \cdot 10^{-78}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.4 \cdot 10^{-19}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 63.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}}\\ t_2 := t\_1 + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ t_3 := t\_1 + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{if}\;NdChar \leq -1.7 \cdot 10^{-18}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;NdChar \leq -1.25 \cdot 10^{-70}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;NdChar \leq 3.7 \cdot 10^{-193}:\\ \;\;\;\;t\_0 + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 3.5 \cdot 10^{-46}:\\ \;\;\;\;t\_0 + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 1.02 \cdot 10^{+15}:\\ \;\;\;\;t\_1 + \frac{NaChar}{1 - EAccept \cdot \left(\frac{\frac{mu}{EAccept}}{KbT} + \left(\left(\frac{-1}{KbT} + \frac{-1}{EAccept}\right) - \left(\frac{Ev}{KbT \cdot EAccept} + \frac{Vef}{KbT \cdot EAccept}\right)\right)\right)}\\ \mathbf{elif}\;NdChar \leq 2 \cdot 10^{+56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 2.6 \cdot 10^{+115}:\\ \;\;\;\;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 (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT)))))
        (t_2
         (+
          t_1
          (/
           NaChar
           (+
            1.0
            (*
             mu
             (+
              (/ (+ (+ 1.0 (/ EAccept KbT)) (+ (/ Ev KbT) (/ Vef KbT))) mu)
              (/ -1.0 KbT)))))))
        (t_3 (+ t_1 (/ NaChar (+ 1.0 (/ Vef KbT))))))
   (if (<= NdChar -1.7e-18)
     t_3
     (if (<= NdChar -1.25e-70)
       t_2
       (if (<= NdChar 3.7e-193)
         (+ t_0 (/ NdChar (- 2.0 (/ Ec KbT))))
         (if (<= NdChar 3.5e-46)
           (+ t_0 (/ NdChar (+ (/ EDonor KbT) 2.0)))
           (if (<= NdChar 1.02e+15)
             (+
              t_1
              (/
               NaChar
               (-
                1.0
                (*
                 EAccept
                 (+
                  (/ (/ mu EAccept) KbT)
                  (-
                   (+ (/ -1.0 KbT) (/ -1.0 EAccept))
                   (+ (/ Ev (* KbT EAccept)) (/ Vef (* KbT EAccept)))))))))
             (if (<= NdChar 2e+56)
               (+
                (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
                (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
               (if (<= NdChar 2.6e+115) 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 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_1 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_2 = t_1 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	double t_3 = t_1 + (NaChar / (1.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -1.7e-18) {
		tmp = t_3;
	} else if (NdChar <= -1.25e-70) {
		tmp = t_2;
	} else if (NdChar <= 3.7e-193) {
		tmp = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	} else if (NdChar <= 3.5e-46) {
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 1.02e+15) {
		tmp = t_1 + (NaChar / (1.0 - (EAccept * (((mu / EAccept) / KbT) + (((-1.0 / KbT) + (-1.0 / EAccept)) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept))))))));
	} else if (NdChar <= 2e+56) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (NdChar <= 2.6e+115) {
		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 = nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))
    t_1 = ndchar / (1.0d0 + exp(((edonor - ((ec - vef) - mu)) / kbt)))
    t_2 = t_1 + (nachar / (1.0d0 + (mu * ((((1.0d0 + (eaccept / kbt)) + ((ev / kbt) + (vef / kbt))) / mu) + ((-1.0d0) / kbt)))))
    t_3 = t_1 + (nachar / (1.0d0 + (vef / kbt)))
    if (ndchar <= (-1.7d-18)) then
        tmp = t_3
    else if (ndchar <= (-1.25d-70)) then
        tmp = t_2
    else if (ndchar <= 3.7d-193) then
        tmp = t_0 + (ndchar / (2.0d0 - (ec / kbt)))
    else if (ndchar <= 3.5d-46) then
        tmp = t_0 + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (ndchar <= 1.02d+15) then
        tmp = t_1 + (nachar / (1.0d0 - (eaccept * (((mu / eaccept) / kbt) + ((((-1.0d0) / kbt) + ((-1.0d0) / eaccept)) - ((ev / (kbt * eaccept)) + (vef / (kbt * eaccept))))))))
    else if (ndchar <= 2d+56) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (ndchar <= 2.6d+115) 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 = NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_2 = t_1 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	double t_3 = t_1 + (NaChar / (1.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -1.7e-18) {
		tmp = t_3;
	} else if (NdChar <= -1.25e-70) {
		tmp = t_2;
	} else if (NdChar <= 3.7e-193) {
		tmp = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	} else if (NdChar <= 3.5e-46) {
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 1.02e+15) {
		tmp = t_1 + (NaChar / (1.0 - (EAccept * (((mu / EAccept) / KbT) + (((-1.0 / KbT) + (-1.0 / EAccept)) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept))))))));
	} else if (NdChar <= 2e+56) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (NdChar <= 2.6e+115) {
		tmp = t_3;
	} 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 - ((mu - EAccept) - Ev)) / KbT)))
	t_1 = NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))
	t_2 = t_1 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))))
	t_3 = t_1 + (NaChar / (1.0 + (Vef / KbT)))
	tmp = 0
	if NdChar <= -1.7e-18:
		tmp = t_3
	elif NdChar <= -1.25e-70:
		tmp = t_2
	elif NdChar <= 3.7e-193:
		tmp = t_0 + (NdChar / (2.0 - (Ec / KbT)))
	elif NdChar <= 3.5e-46:
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0))
	elif NdChar <= 1.02e+15:
		tmp = t_1 + (NaChar / (1.0 - (EAccept * (((mu / EAccept) / KbT) + (((-1.0 / KbT) + (-1.0 / EAccept)) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept))))))))
	elif NdChar <= 2e+56:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif NdChar <= 2.6e+115:
		tmp = t_3
	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(Float64(mu - EAccept) - Ev)) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT))))
	t_2 = Float64(t_1 + Float64(NaChar / Float64(1.0 + Float64(mu * Float64(Float64(Float64(Float64(1.0 + Float64(EAccept / KbT)) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT))) / mu) + Float64(-1.0 / KbT))))))
	t_3 = Float64(t_1 + Float64(NaChar / Float64(1.0 + Float64(Vef / KbT))))
	tmp = 0.0
	if (NdChar <= -1.7e-18)
		tmp = t_3;
	elseif (NdChar <= -1.25e-70)
		tmp = t_2;
	elseif (NdChar <= 3.7e-193)
		tmp = Float64(t_0 + Float64(NdChar / Float64(2.0 - Float64(Ec / KbT))));
	elseif (NdChar <= 3.5e-46)
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	elseif (NdChar <= 1.02e+15)
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 - Float64(EAccept * Float64(Float64(Float64(mu / EAccept) / KbT) + Float64(Float64(Float64(-1.0 / KbT) + Float64(-1.0 / EAccept)) - Float64(Float64(Ev / Float64(KbT * EAccept)) + Float64(Vef / Float64(KbT * EAccept)))))))));
	elseif (NdChar <= 2e+56)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (NdChar <= 2.6e+115)
		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 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	t_1 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	t_2 = t_1 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	t_3 = t_1 + (NaChar / (1.0 + (Vef / KbT)));
	tmp = 0.0;
	if (NdChar <= -1.7e-18)
		tmp = t_3;
	elseif (NdChar <= -1.25e-70)
		tmp = t_2;
	elseif (NdChar <= 3.7e-193)
		tmp = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	elseif (NdChar <= 3.5e-46)
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NdChar <= 1.02e+15)
		tmp = t_1 + (NaChar / (1.0 - (EAccept * (((mu / EAccept) / KbT) + (((-1.0 / KbT) + (-1.0 / EAccept)) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept))))))));
	elseif (NdChar <= 2e+56)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (NdChar <= 2.6e+115)
		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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor - N[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NaChar / N[(1.0 + N[(mu * N[(N[(N[(N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 + N[(NaChar / N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.7e-18], t$95$3, If[LessEqual[NdChar, -1.25e-70], t$95$2, If[LessEqual[NdChar, 3.7e-193], N[(t$95$0 + N[(NdChar / N[(2.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 3.5e-46], N[(t$95$0 + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.02e+15], N[(t$95$1 + N[(NaChar / N[(1.0 - N[(EAccept * N[(N[(N[(mu / EAccept), $MachinePrecision] / KbT), $MachinePrecision] + N[(N[(N[(-1.0 / KbT), $MachinePrecision] + N[(-1.0 / EAccept), $MachinePrecision]), $MachinePrecision] - N[(N[(Ev / N[(KbT * EAccept), $MachinePrecision]), $MachinePrecision] + N[(Vef / N[(KbT * EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2e+56], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.6e+115], t$95$3, t$95$2]]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if NdChar < -1.70000000000000001e-18 or 2.00000000000000018e56 < NdChar < 2.6e115

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.1%

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

   6. Taylor expanded in Vef around inf 75.3%

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

   if -1.70000000000000001e-18 < NdChar < -1.25e-70 or 2.6e115 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 72.2%

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

   6. Taylor expanded in mu around -inf 82.2%

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

      1. mul-1-neg 82.2%

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

      2. distribute-rgt-neg-in 82.2%

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

      3. +-commutative 82.2%

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

      4. mul-1-neg 82.2%

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

      5. unsub-neg 82.2%

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

      6. associate-+r+ 82.2%

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

      7. +-commutative 82.2%

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

   8. Simplified 82.2%

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

   if -1.25e-70 < NdChar < 3.7000000000000002e-193

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 81.0%

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

      1. associate-*r/ 81.0%

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

      2. mul-1-neg 81.0%

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

   7. Simplified 81.0%

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

   8. Taylor expanded in Ec around 0 75.2%

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

      1. mul-1-neg 75.2%

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

      2. unsub-neg 75.2%

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

   10. Simplified 75.2%

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

   if 3.7000000000000002e-193 < NdChar < 3.5000000000000002e-46

   1. Initial program 100.0%

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

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

   if 3.5000000000000002e-46 < NdChar < 1.02e15

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EAccept around inf 89.7%

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

      1. associate-+r+ 89.7%

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

      2. *-commutative 89.7%

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

      3. *-commutative 89.7%

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

      4. associate-/r* 89.7%

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

   8. Simplified 89.7%

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

   if 1.02e15 < NdChar < 2.00000000000000018e56

   1. Initial program 99.8%

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

   3. Simplified 99.8%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 77.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 EAccept around inf 55.2%

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

4. Final simplification 77.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -1.7 \cdot 10^{-18}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq -1.25 \cdot 10^{-70}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 3.7 \cdot 10^{-193}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 3.5 \cdot 10^{-46}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 1.02 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 - EAccept \cdot \left(\frac{\frac{mu}{EAccept}}{KbT} + \left(\left(\frac{-1}{KbT} + \frac{-1}{EAccept}\right) - \left(\frac{Ev}{KbT \cdot EAccept} + \frac{Vef}{KbT \cdot EAccept}\right)\right)\right)}\\ \mathbf{elif}\;NdChar \leq 2 \cdot 10^{+56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 2.6 \cdot 10^{+115}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 68.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + t\_0\\ \mathbf{if}\;Vef \leq -6 \cdot 10^{+164}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -5.8 \cdot 10^{-297}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;Vef \leq 4.6 \cdot 10^{-258}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(1 - \left(Ev \cdot \left(\frac{-1}{KbT} - \frac{Vef}{KbT \cdot Ev}\right) - \frac{EAccept}{KbT}\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;Vef \leq 10^{-162}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) KbT)))))
        (t_1 (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) t_0)))
   (if (<= Vef -6e+164)
     t_1
     (if (<= Vef -5.8e-297)
       (+ t_0 (/ NdChar (+ 1.0 (exp (/ Ec (- KbT))))))
       (if (<= Vef 4.6e-258)
         (+
          (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT))))
          (/
           NaChar
           (+
            1.0
            (-
             (-
              1.0
              (- (* Ev (- (/ -1.0 KbT) (/ Vef (* KbT Ev)))) (/ EAccept KbT)))
             (/ mu KbT)))))
         (if (<= Vef 1e-162)
           (+
            (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT))))
            (/ NdChar (- 2.0 (/ Ec KbT))))
           t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)));
	double t_1 = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0;
	double tmp;
	if (Vef <= -6e+164) {
		tmp = t_1;
	} else if (Vef <= -5.8e-297) {
		tmp = t_0 + (NdChar / (1.0 + exp((Ec / -KbT))));
	} else if (Vef <= 4.6e-258) {
		tmp = (NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + ((1.0 - ((Ev * ((-1.0 / KbT) - (Vef / (KbT * Ev)))) - (EAccept / KbT))) - (mu / KbT))));
	} else if (Vef <= 1e-162) {
		tmp = (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (2.0 - (Ec / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt)))
    t_1 = (ndchar / (1.0d0 + exp((vef / kbt)))) + t_0
    if (vef <= (-6d+164)) then
        tmp = t_1
    else if (vef <= (-5.8d-297)) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((ec / -kbt))))
    else if (vef <= 4.6d-258) then
        tmp = (ndchar / (1.0d0 + exp(((edonor - ((ec - vef) - mu)) / kbt)))) + (nachar / (1.0d0 + ((1.0d0 - ((ev * (((-1.0d0) / kbt) - (vef / (kbt * ev)))) - (eaccept / kbt))) - (mu / kbt))))
    else if (vef <= 1d-162) then
        tmp = (nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))) + (ndchar / (2.0d0 - (ec / kbt)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT)));
	double t_1 = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
	double tmp;
	if (Vef <= -6e+164) {
		tmp = t_1;
	} else if (Vef <= -5.8e-297) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((Ec / -KbT))));
	} else if (Vef <= 4.6e-258) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + ((1.0 - ((Ev * ((-1.0 / KbT) - (Vef / (KbT * Ev)))) - (EAccept / KbT))) - (mu / KbT))));
	} else if (Vef <= 1e-162) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (2.0 - (Ec / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT)))
	t_1 = (NdChar / (1.0 + math.exp((Vef / KbT)))) + t_0
	tmp = 0
	if Vef <= -6e+164:
		tmp = t_1
	elif Vef <= -5.8e-297:
		tmp = t_0 + (NdChar / (1.0 + math.exp((Ec / -KbT))))
	elif Vef <= 4.6e-258:
		tmp = (NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + ((1.0 - ((Ev * ((-1.0 / KbT) - (Vef / (KbT * Ev)))) - (EAccept / KbT))) - (mu / KbT))))
	elif Vef <= 1e-162:
		tmp = (NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (2.0 - (Ec / KbT)))
	else:
		tmp = t_1
	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 + EAccept) - mu) / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0)
	tmp = 0.0
	if (Vef <= -6e+164)
		tmp = t_1;
	elseif (Vef <= -5.8e-297)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-KbT))))));
	elseif (Vef <= 4.6e-258)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 - Float64(Float64(Ev * Float64(Float64(-1.0 / KbT) - Float64(Vef / Float64(KbT * Ev)))) - Float64(EAccept / KbT))) - Float64(mu / KbT)))));
	elseif (Vef <= 1e-162)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef - Float64(Float64(mu - EAccept) - Ev)) / KbT)))) + Float64(NdChar / Float64(2.0 - Float64(Ec / KbT))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)));
	t_1 = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0;
	tmp = 0.0;
	if (Vef <= -6e+164)
		tmp = t_1;
	elseif (Vef <= -5.8e-297)
		tmp = t_0 + (NdChar / (1.0 + exp((Ec / -KbT))));
	elseif (Vef <= 4.6e-258)
		tmp = (NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + ((1.0 - ((Ev * ((-1.0 / KbT) - (Vef / (KbT * Ev)))) - (EAccept / KbT))) - (mu / KbT))));
	elseif (Vef <= 1e-162)
		tmp = (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (2.0 - (Ec / KbT)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, If[LessEqual[Vef, -6e+164], t$95$1, If[LessEqual[Vef, -5.8e-297], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 4.6e-258], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor - N[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(1.0 - N[(N[(Ev * N[(N[(-1.0 / KbT), $MachinePrecision] - N[(Vef / N[(KbT * Ev), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1e-162], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -6.00000000000000001e164 or 9.99999999999999954e-163 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 82.6%

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

   6. Taylor expanded in Ev around 0 77.7%

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

      1. +-commutative 77.7%

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

   8. Simplified 77.7%

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

   if -6.00000000000000001e164 < Vef < -5.79999999999999979e-297

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 79.8%

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

      1. associate-*r/ 79.8%

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

      2. mul-1-neg 79.8%

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

   7. Simplified 79.8%

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

   8. Taylor expanded in Ev around 0 70.6%

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

      1. +-commutative 51.5%

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

   10. Simplified 70.6%

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

   if -5.79999999999999979e-297 < Vef < 4.59999999999999986e-258

   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 69.7%

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

   6. Taylor expanded in Ev around inf 75.8%

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

      1. *-commutative 75.8%

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

   8. Simplified 75.8%

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

   if 4.59999999999999986e-258 < Vef < 9.99999999999999954e-163

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 88.2%

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

      1. associate-*r/ 88.2%

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

      2. mul-1-neg 88.2%

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

   7. Simplified 88.2%

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

   8. Taylor expanded in Ec around 0 83.1%

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

      1. mul-1-neg 83.1%

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

      2. unsub-neg 83.1%

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

   10. Simplified 83.1%

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

4. Final simplification 75.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -6 \cdot 10^{+164}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq -5.8 \cdot 10^{-297}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;Vef \leq 4.6 \cdot 10^{-258}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(1 - \left(Ev \cdot \left(\frac{-1}{KbT} - \frac{Vef}{KbT \cdot Ev}\right) - \frac{EAccept}{KbT}\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;Vef \leq 10^{-162}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 77.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}}\\ t_1 := t\_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -5.8 \cdot 10^{+50}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -3.3 \cdot 10^{-163}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;Vef \leq 4.7 \cdot 10^{+81}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
   (if (<= Vef -5.8e+50)
     t_1
     (if (<= Vef -3.3e-163)
       (+
        (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT))))
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
       (if (<= Vef 4.7e+81)
         (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	double tmp;
	if (Vef <= -5.8e+50) {
		tmp = t_1;
	} else if (Vef <= -3.3e-163) {
		tmp = (NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (Vef <= 4.7e+81) {
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))
    t_1 = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
    if (vef <= (-5.8d+50)) then
        tmp = t_1
    else if (vef <= (-3.3d-163)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor - ((ec - vef) - mu)) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (vef <= 4.7d+81) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	double tmp;
	if (Vef <= -5.8e+50) {
		tmp = t_1;
	} else if (Vef <= -3.3e-163) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (Vef <= 4.7e+81) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))
	t_1 = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	tmp = 0
	if Vef <= -5.8e+50:
		tmp = t_1
	elif Vef <= -3.3e-163:
		tmp = (NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif Vef <= 4.7e+81:
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = t_1
	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(Float64(mu - EAccept) - Ev)) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	tmp = 0.0
	if (Vef <= -5.8e+50)
		tmp = t_1;
	elseif (Vef <= -3.3e-163)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (Vef <= 4.7e+81)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	tmp = 0.0;
	if (Vef <= -5.8e+50)
		tmp = t_1;
	elseif (Vef <= -3.3e-163)
		tmp = (NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (Vef <= 4.7e+81)
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -5.8e+50], t$95$1, If[LessEqual[Vef, -3.3e-163], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor - N[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 4.7e+81], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -5.8e50 or 4.7000000000000002e81 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 88.9%

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

   if -5.8e50 < Vef < -3.30000000000000001e-163

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 77.2%

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

   if -3.30000000000000001e-163 < Vef < 4.7000000000000002e81

   1. Initial program 100.0%

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

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

4. Final simplification 82.2%

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

Alternative 8: 75.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -7.2 \cdot 10^{+164}:\\ \;\;\;\;t\_2 + t\_0\\ \mathbf{elif}\;Vef \leq -2.8 \cdot 10^{-166}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;Vef \leq 2.12 \cdot 10^{+89}:\\ \;\;\;\;t\_1 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_1 + 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 EAccept) mu) KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT)))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -7.2e+164)
     (+ t_2 t_0)
     (if (<= Vef -2.8e-166)
       (+ t_0 (/ NdChar (+ 1.0 (exp (/ Ec (- KbT))))))
       (if (<= Vef 2.12e+89)
         (+ t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (+ 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 + EAccept) - mu) / KbT)));
	double t_1 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_2 = NdChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -7.2e+164) {
		tmp = t_2 + t_0;
	} else if (Vef <= -2.8e-166) {
		tmp = t_0 + (NdChar / (1.0 + exp((Ec / -KbT))));
	} else if (Vef <= 2.12e+89) {
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = t_1 + 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 + eaccept) - mu) / kbt)))
    t_1 = nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))
    t_2 = ndchar / (1.0d0 + exp((vef / kbt)))
    if (vef <= (-7.2d+164)) then
        tmp = t_2 + t_0
    else if (vef <= (-2.8d-166)) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((ec / -kbt))))
    else if (vef <= 2.12d+89) then
        tmp = t_1 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = t_1 + 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 + EAccept) - mu) / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_2 = NdChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (Vef <= -7.2e+164) {
		tmp = t_2 + t_0;
	} else if (Vef <= -2.8e-166) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((Ec / -KbT))));
	} else if (Vef <= 2.12e+89) {
		tmp = t_1 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = t_1 + t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT)))
	t_1 = NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))
	t_2 = NdChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if Vef <= -7.2e+164:
		tmp = t_2 + t_0
	elif Vef <= -2.8e-166:
		tmp = t_0 + (NdChar / (1.0 + math.exp((Ec / -KbT))))
	elif Vef <= 2.12e+89:
		tmp = t_1 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = t_1 + 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(Float64(Vef + EAccept) - mu) / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef - Float64(Float64(mu - EAccept) - Ev)) / KbT))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -7.2e+164)
		tmp = Float64(t_2 + t_0);
	elseif (Vef <= -2.8e-166)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-KbT))))));
	elseif (Vef <= 2.12e+89)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = Float64(t_1 + 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 + EAccept) - mu) / KbT)));
	t_1 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	t_2 = NdChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -7.2e+164)
		tmp = t_2 + t_0;
	elseif (Vef <= -2.8e-166)
		tmp = t_0 + (NdChar / (1.0 + exp((Ec / -KbT))));
	elseif (Vef <= 2.12e+89)
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = t_1 + 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[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -7.2e+164], N[(t$95$2 + t$95$0), $MachinePrecision], If[LessEqual[Vef, -2.8e-166], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2.12e+89], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + t$95$2), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -7.19999999999999981e164

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around 0 90.3%

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

      1. +-commutative 90.3%

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

   8. Simplified 90.3%

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

   if -7.19999999999999981e164 < Vef < -2.7999999999999999e-166

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 81.5%

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

      1. associate-*r/ 81.5%

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

      2. mul-1-neg 81.5%

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

   7. Simplified 81.5%

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

   8. Taylor expanded in Ev around 0 70.4%

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

      1. +-commutative 51.3%

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

   10. Simplified 70.4%

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

   if -2.7999999999999999e-166 < Vef < 2.11999999999999995e89

   1. Initial program 100.0%

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

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

   if 2.11999999999999995e89 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 91.5%

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

4. Final simplification 80.0%

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

Alternative 9: 74.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + t\_0\\ \mathbf{if}\;Vef \leq -6 \cdot 10^{+164}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -2.5 \cdot 10^{-166}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;Vef \leq 2.85 \cdot 10^{+85}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) KbT)))))
        (t_1 (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) t_0)))
   (if (<= Vef -6e+164)
     t_1
     (if (<= Vef -2.5e-166)
       (+ t_0 (/ NdChar (+ 1.0 (exp (/ Ec (- KbT))))))
       (if (<= Vef 2.85e+85)
         (+
          (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)));
	double t_1 = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0;
	double tmp;
	if (Vef <= -6e+164) {
		tmp = t_1;
	} else if (Vef <= -2.5e-166) {
		tmp = t_0 + (NdChar / (1.0 + exp((Ec / -KbT))));
	} else if (Vef <= 2.85e+85) {
		tmp = (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt)))
    t_1 = (ndchar / (1.0d0 + exp((vef / kbt)))) + t_0
    if (vef <= (-6d+164)) then
        tmp = t_1
    else if (vef <= (-2.5d-166)) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((ec / -kbt))))
    else if (vef <= 2.85d+85) then
        tmp = (nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT)));
	double t_1 = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
	double tmp;
	if (Vef <= -6e+164) {
		tmp = t_1;
	} else if (Vef <= -2.5e-166) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((Ec / -KbT))));
	} else if (Vef <= 2.85e+85) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT)))
	t_1 = (NdChar / (1.0 + math.exp((Vef / KbT)))) + t_0
	tmp = 0
	if Vef <= -6e+164:
		tmp = t_1
	elif Vef <= -2.5e-166:
		tmp = t_0 + (NdChar / (1.0 + math.exp((Ec / -KbT))))
	elif Vef <= 2.85e+85:
		tmp = (NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = t_1
	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 + EAccept) - mu) / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0)
	tmp = 0.0
	if (Vef <= -6e+164)
		tmp = t_1;
	elseif (Vef <= -2.5e-166)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-KbT))))));
	elseif (Vef <= 2.85e+85)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef - Float64(Float64(mu - EAccept) - Ev)) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)));
	t_1 = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0;
	tmp = 0.0;
	if (Vef <= -6e+164)
		tmp = t_1;
	elseif (Vef <= -2.5e-166)
		tmp = t_0 + (NdChar / (1.0 + exp((Ec / -KbT))));
	elseif (Vef <= 2.85e+85)
		tmp = (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, If[LessEqual[Vef, -6e+164], t$95$1, If[LessEqual[Vef, -2.5e-166], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2.85e+85], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -6.00000000000000001e164 or 2.8500000000000001e85 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 92.4%

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

   6. Taylor expanded in Ev around 0 86.6%

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

      1. +-commutative 86.6%

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

   8. Simplified 86.6%

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

   if -6.00000000000000001e164 < Vef < -2.5e-166

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 81.5%

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

      1. associate-*r/ 81.5%

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

      2. mul-1-neg 81.5%

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

   7. Simplified 81.5%

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

   8. Taylor expanded in Ev around 0 70.4%

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

      1. +-commutative 51.3%

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

   10. Simplified 70.4%

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

   if -2.5e-166 < Vef < 2.8500000000000001e85

   1. Initial program 100.0%

      \[\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\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 80.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}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 78.9%

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

Alternative 10: 72.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 1.5499999999999999e69

   1. Initial program 100.0%

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

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

   if 1.5499999999999999e69 < EAccept

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in EAccept around inf 81.7%

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

4. Final simplification 72.8%

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

Alternative 11: 63.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}}\\ t_1 := t\_0 + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}}\\ t_3 := t\_2 + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ t_4 := t\_2 + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{if}\;NdChar \leq -2.8 \cdot 10^{-18}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;NdChar \leq -2 \cdot 10^{-70}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;NdChar \leq 8.4 \cdot 10^{-193}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 8.6 \cdot 10^{-41}:\\ \;\;\;\;t\_0 + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 2500000000:\\ \;\;\;\;t\_2 + \frac{NaChar}{1 - EAccept \cdot \left(\frac{\frac{mu}{EAccept}}{KbT} + \left(\left(\frac{-1}{KbT} + \frac{-1}{EAccept}\right) - \left(\frac{Ev}{KbT \cdot EAccept} + \frac{Vef}{KbT \cdot EAccept}\right)\right)\right)}\\ \mathbf{elif}\;NdChar \leq 2.8 \cdot 10^{+53}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 3.6 \cdot 10^{+115}:\\ \;\;\;\;t\_4\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \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 (- (- mu EAccept) Ev)) KbT)))))
        (t_1 (+ t_0 (/ NdChar (- 2.0 (/ Ec KbT)))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT)))))
        (t_3
         (+
          t_2
          (/
           NaChar
           (+
            1.0
            (*
             mu
             (+
              (/ (+ (+ 1.0 (/ EAccept KbT)) (+ (/ Ev KbT) (/ Vef KbT))) mu)
              (/ -1.0 KbT)))))))
        (t_4 (+ t_2 (/ NaChar (+ 1.0 (/ Vef KbT))))))
   (if (<= NdChar -2.8e-18)
     t_4
     (if (<= NdChar -2e-70)
       t_3
       (if (<= NdChar 8.4e-193)
         t_1
         (if (<= NdChar 8.6e-41)
           (+ t_0 (/ NdChar (+ (/ EDonor KbT) 2.0)))
           (if (<= NdChar 2500000000.0)
             (+
              t_2
              (/
               NaChar
               (-
                1.0
                (*
                 EAccept
                 (+
                  (/ (/ mu EAccept) KbT)
                  (-
                   (+ (/ -1.0 KbT) (/ -1.0 EAccept))
                   (+ (/ Ev (* KbT EAccept)) (/ Vef (* KbT EAccept)))))))))
             (if (<= NdChar 2.8e+53)
               t_1
               (if (<= NdChar 3.6e+115) t_4 t_3)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_1 = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	double t_2 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	double t_4 = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -2.8e-18) {
		tmp = t_4;
	} else if (NdChar <= -2e-70) {
		tmp = t_3;
	} else if (NdChar <= 8.4e-193) {
		tmp = t_1;
	} else if (NdChar <= 8.6e-41) {
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 2500000000.0) {
		tmp = t_2 + (NaChar / (1.0 - (EAccept * (((mu / EAccept) / KbT) + (((-1.0 / KbT) + (-1.0 / EAccept)) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept))))))));
	} else if (NdChar <= 2.8e+53) {
		tmp = t_1;
	} else if (NdChar <= 3.6e+115) {
		tmp = t_4;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))
    t_1 = t_0 + (ndchar / (2.0d0 - (ec / kbt)))
    t_2 = ndchar / (1.0d0 + exp(((edonor - ((ec - vef) - mu)) / kbt)))
    t_3 = t_2 + (nachar / (1.0d0 + (mu * ((((1.0d0 + (eaccept / kbt)) + ((ev / kbt) + (vef / kbt))) / mu) + ((-1.0d0) / kbt)))))
    t_4 = t_2 + (nachar / (1.0d0 + (vef / kbt)))
    if (ndchar <= (-2.8d-18)) then
        tmp = t_4
    else if (ndchar <= (-2d-70)) then
        tmp = t_3
    else if (ndchar <= 8.4d-193) then
        tmp = t_1
    else if (ndchar <= 8.6d-41) then
        tmp = t_0 + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (ndchar <= 2500000000.0d0) then
        tmp = t_2 + (nachar / (1.0d0 - (eaccept * (((mu / eaccept) / kbt) + ((((-1.0d0) / kbt) + ((-1.0d0) / eaccept)) - ((ev / (kbt * eaccept)) + (vef / (kbt * eaccept))))))))
    else if (ndchar <= 2.8d+53) then
        tmp = t_1
    else if (ndchar <= 3.6d+115) then
        tmp = t_4
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_1 = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	double t_2 = NdChar / (1.0 + Math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	double t_4 = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -2.8e-18) {
		tmp = t_4;
	} else if (NdChar <= -2e-70) {
		tmp = t_3;
	} else if (NdChar <= 8.4e-193) {
		tmp = t_1;
	} else if (NdChar <= 8.6e-41) {
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 2500000000.0) {
		tmp = t_2 + (NaChar / (1.0 - (EAccept * (((mu / EAccept) / KbT) + (((-1.0 / KbT) + (-1.0 / EAccept)) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept))))))));
	} else if (NdChar <= 2.8e+53) {
		tmp = t_1;
	} else if (NdChar <= 3.6e+115) {
		tmp = t_4;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))
	t_1 = t_0 + (NdChar / (2.0 - (Ec / KbT)))
	t_2 = NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))
	t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))))
	t_4 = t_2 + (NaChar / (1.0 + (Vef / KbT)))
	tmp = 0
	if NdChar <= -2.8e-18:
		tmp = t_4
	elif NdChar <= -2e-70:
		tmp = t_3
	elif NdChar <= 8.4e-193:
		tmp = t_1
	elif NdChar <= 8.6e-41:
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0))
	elif NdChar <= 2500000000.0:
		tmp = t_2 + (NaChar / (1.0 - (EAccept * (((mu / EAccept) / KbT) + (((-1.0 / KbT) + (-1.0 / EAccept)) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept))))))))
	elif NdChar <= 2.8e+53:
		tmp = t_1
	elif NdChar <= 3.6e+115:
		tmp = t_4
	else:
		tmp = t_3
	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(Float64(mu - EAccept) - Ev)) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(2.0 - Float64(Ec / KbT))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT))))
	t_3 = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(mu * Float64(Float64(Float64(Float64(1.0 + Float64(EAccept / KbT)) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT))) / mu) + Float64(-1.0 / KbT))))))
	t_4 = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(Vef / KbT))))
	tmp = 0.0
	if (NdChar <= -2.8e-18)
		tmp = t_4;
	elseif (NdChar <= -2e-70)
		tmp = t_3;
	elseif (NdChar <= 8.4e-193)
		tmp = t_1;
	elseif (NdChar <= 8.6e-41)
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	elseif (NdChar <= 2500000000.0)
		tmp = Float64(t_2 + Float64(NaChar / Float64(1.0 - Float64(EAccept * Float64(Float64(Float64(mu / EAccept) / KbT) + Float64(Float64(Float64(-1.0 / KbT) + Float64(-1.0 / EAccept)) - Float64(Float64(Ev / Float64(KbT * EAccept)) + Float64(Vef / Float64(KbT * EAccept)))))))));
	elseif (NdChar <= 2.8e+53)
		tmp = t_1;
	elseif (NdChar <= 3.6e+115)
		tmp = t_4;
	else
		tmp = t_3;
	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 - ((mu - EAccept) - Ev)) / KbT)));
	t_1 = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	t_2 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	t_4 = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	tmp = 0.0;
	if (NdChar <= -2.8e-18)
		tmp = t_4;
	elseif (NdChar <= -2e-70)
		tmp = t_3;
	elseif (NdChar <= 8.4e-193)
		tmp = t_1;
	elseif (NdChar <= 8.6e-41)
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NdChar <= 2500000000.0)
		tmp = t_2 + (NaChar / (1.0 - (EAccept * (((mu / EAccept) / KbT) + (((-1.0 / KbT) + (-1.0 / EAccept)) - ((Ev / (KbT * EAccept)) + (Vef / (KbT * EAccept))))))));
	elseif (NdChar <= 2.8e+53)
		tmp = t_1;
	elseif (NdChar <= 3.6e+115)
		tmp = t_4;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(2.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor - N[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NaChar / N[(1.0 + N[(mu * N[(N[(N[(N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$2 + N[(NaChar / N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -2.8e-18], t$95$4, If[LessEqual[NdChar, -2e-70], t$95$3, If[LessEqual[NdChar, 8.4e-193], t$95$1, If[LessEqual[NdChar, 8.6e-41], N[(t$95$0 + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2500000000.0], N[(t$95$2 + N[(NaChar / N[(1.0 - N[(EAccept * N[(N[(N[(mu / EAccept), $MachinePrecision] / KbT), $MachinePrecision] + N[(N[(N[(-1.0 / KbT), $MachinePrecision] + N[(-1.0 / EAccept), $MachinePrecision]), $MachinePrecision] - N[(N[(Ev / N[(KbT * EAccept), $MachinePrecision]), $MachinePrecision] + N[(Vef / N[(KbT * EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.8e+53], t$95$1, If[LessEqual[NdChar, 3.6e+115], t$95$4, t$95$3]]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if NdChar < -2.80000000000000012e-18 or 2.8e53 < NdChar < 3.6000000000000001e115

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.6%

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

   6. Taylor expanded in Vef around inf 74.4%

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

   if -2.80000000000000012e-18 < NdChar < -1.99999999999999999e-70 or 3.6000000000000001e115 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 72.2%

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

   6. Taylor expanded in mu around -inf 82.2%

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

      1. mul-1-neg 82.2%

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

      2. distribute-rgt-neg-in 82.2%

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

      3. +-commutative 82.2%

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

      4. mul-1-neg 82.2%

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

      5. unsub-neg 82.2%

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

      6. associate-+r+ 82.2%

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

      7. +-commutative 82.2%

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

   8. Simplified 82.2%

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

   if -1.99999999999999999e-70 < NdChar < 8.3999999999999997e-193 or 2.5e9 < NdChar < 2.8e53

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 81.6%

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

      1. associate-*r/ 81.6%

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

      2. mul-1-neg 81.6%

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

   7. Simplified 81.6%

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

   8. Taylor expanded in Ec around 0 75.1%

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

      1. mul-1-neg 75.1%

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

      2. unsub-neg 75.1%

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

   10. Simplified 75.1%

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

   if 8.3999999999999997e-193 < NdChar < 8.5999999999999997e-41

   1. Initial program 100.0%

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

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

   if 8.5999999999999997e-41 < NdChar < 2.5e9

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EAccept around inf 89.7%

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

      1. associate-+r+ 89.7%

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

      2. *-commutative 89.7%

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

      3. *-commutative 89.7%

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

      4. associate-/r* 89.7%

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

   8. Simplified 89.7%

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

4. Final simplification 77.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -2.8 \cdot 10^{-18}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq -2 \cdot 10^{-70}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 8.4 \cdot 10^{-193}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 8.6 \cdot 10^{-41}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 2500000000:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 - EAccept \cdot \left(\frac{\frac{mu}{EAccept}}{KbT} + \left(\left(\frac{-1}{KbT} + \frac{-1}{EAccept}\right) - \left(\frac{Ev}{KbT \cdot EAccept} + \frac{Vef}{KbT \cdot EAccept}\right)\right)\right)}\\ \mathbf{elif}\;NdChar \leq 2.8 \cdot 10^{+53}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 3.6 \cdot 10^{+115}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 63.8% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}}\\ t_1 := t\_0 + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}}\\ t_3 := t\_2 + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ t_4 := t\_2 + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{if}\;NdChar \leq -1.6 \cdot 10^{-19}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;NdChar \leq -8 \cdot 10^{-71}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;NdChar \leq 1.35 \cdot 10^{-188}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 7 \cdot 10^{-19}:\\ \;\;\;\;t\_0 + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 7.4 \cdot 10^{+17}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;NdChar \leq 7.2 \cdot 10^{+53}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq 8 \cdot 10^{+115}:\\ \;\;\;\;t\_4\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \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 (- (- mu EAccept) Ev)) KbT)))))
        (t_1 (+ t_0 (/ NdChar (- 2.0 (/ Ec KbT)))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT)))))
        (t_3
         (+
          t_2
          (/
           NaChar
           (+
            1.0
            (*
             mu
             (+
              (/ (+ (+ 1.0 (/ EAccept KbT)) (+ (/ Ev KbT) (/ Vef KbT))) mu)
              (/ -1.0 KbT)))))))
        (t_4 (+ t_2 (/ NaChar (+ 1.0 (/ Vef KbT))))))
   (if (<= NdChar -1.6e-19)
     t_4
     (if (<= NdChar -8e-71)
       t_3
       (if (<= NdChar 1.35e-188)
         t_1
         (if (<= NdChar 7e-19)
           (+ t_0 (/ NdChar (+ (/ EDonor KbT) 2.0)))
           (if (<= NdChar 7.4e+17)
             t_3
             (if (<= NdChar 7.2e+53)
               t_1
               (if (<= NdChar 8e+115) t_4 t_3)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_1 = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	double t_2 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	double t_4 = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -1.6e-19) {
		tmp = t_4;
	} else if (NdChar <= -8e-71) {
		tmp = t_3;
	} else if (NdChar <= 1.35e-188) {
		tmp = t_1;
	} else if (NdChar <= 7e-19) {
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 7.4e+17) {
		tmp = t_3;
	} else if (NdChar <= 7.2e+53) {
		tmp = t_1;
	} else if (NdChar <= 8e+115) {
		tmp = t_4;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef - ((mu - eaccept) - ev)) / kbt)))
    t_1 = t_0 + (ndchar / (2.0d0 - (ec / kbt)))
    t_2 = ndchar / (1.0d0 + exp(((edonor - ((ec - vef) - mu)) / kbt)))
    t_3 = t_2 + (nachar / (1.0d0 + (mu * ((((1.0d0 + (eaccept / kbt)) + ((ev / kbt) + (vef / kbt))) / mu) + ((-1.0d0) / kbt)))))
    t_4 = t_2 + (nachar / (1.0d0 + (vef / kbt)))
    if (ndchar <= (-1.6d-19)) then
        tmp = t_4
    else if (ndchar <= (-8d-71)) then
        tmp = t_3
    else if (ndchar <= 1.35d-188) then
        tmp = t_1
    else if (ndchar <= 7d-19) then
        tmp = t_0 + (ndchar / ((edonor / kbt) + 2.0d0))
    else if (ndchar <= 7.4d+17) then
        tmp = t_3
    else if (ndchar <= 7.2d+53) then
        tmp = t_1
    else if (ndchar <= 8d+115) then
        tmp = t_4
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)));
	double t_1 = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	double t_2 = NdChar / (1.0 + Math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	double t_4 = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -1.6e-19) {
		tmp = t_4;
	} else if (NdChar <= -8e-71) {
		tmp = t_3;
	} else if (NdChar <= 1.35e-188) {
		tmp = t_1;
	} else if (NdChar <= 7e-19) {
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	} else if (NdChar <= 7.4e+17) {
		tmp = t_3;
	} else if (NdChar <= 7.2e+53) {
		tmp = t_1;
	} else if (NdChar <= 8e+115) {
		tmp = t_4;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))
	t_1 = t_0 + (NdChar / (2.0 - (Ec / KbT)))
	t_2 = NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))
	t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))))
	t_4 = t_2 + (NaChar / (1.0 + (Vef / KbT)))
	tmp = 0
	if NdChar <= -1.6e-19:
		tmp = t_4
	elif NdChar <= -8e-71:
		tmp = t_3
	elif NdChar <= 1.35e-188:
		tmp = t_1
	elif NdChar <= 7e-19:
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0))
	elif NdChar <= 7.4e+17:
		tmp = t_3
	elif NdChar <= 7.2e+53:
		tmp = t_1
	elif NdChar <= 8e+115:
		tmp = t_4
	else:
		tmp = t_3
	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(Float64(mu - EAccept) - Ev)) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(2.0 - Float64(Ec / KbT))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT))))
	t_3 = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(mu * Float64(Float64(Float64(Float64(1.0 + Float64(EAccept / KbT)) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT))) / mu) + Float64(-1.0 / KbT))))))
	t_4 = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(Vef / KbT))))
	tmp = 0.0
	if (NdChar <= -1.6e-19)
		tmp = t_4;
	elseif (NdChar <= -8e-71)
		tmp = t_3;
	elseif (NdChar <= 1.35e-188)
		tmp = t_1;
	elseif (NdChar <= 7e-19)
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	elseif (NdChar <= 7.4e+17)
		tmp = t_3;
	elseif (NdChar <= 7.2e+53)
		tmp = t_1;
	elseif (NdChar <= 8e+115)
		tmp = t_4;
	else
		tmp = t_3;
	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 - ((mu - EAccept) - Ev)) / KbT)));
	t_1 = t_0 + (NdChar / (2.0 - (Ec / KbT)));
	t_2 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	t_3 = t_2 + (NaChar / (1.0 + (mu * ((((1.0 + (EAccept / KbT)) + ((Ev / KbT) + (Vef / KbT))) / mu) + (-1.0 / KbT)))));
	t_4 = t_2 + (NaChar / (1.0 + (Vef / KbT)));
	tmp = 0.0;
	if (NdChar <= -1.6e-19)
		tmp = t_4;
	elseif (NdChar <= -8e-71)
		tmp = t_3;
	elseif (NdChar <= 1.35e-188)
		tmp = t_1;
	elseif (NdChar <= 7e-19)
		tmp = t_0 + (NdChar / ((EDonor / KbT) + 2.0));
	elseif (NdChar <= 7.4e+17)
		tmp = t_3;
	elseif (NdChar <= 7.2e+53)
		tmp = t_1;
	elseif (NdChar <= 8e+115)
		tmp = t_4;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(2.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor - N[(N[(Ec - Vef), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NaChar / N[(1.0 + N[(mu * N[(N[(N[(N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$2 + N[(NaChar / N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.6e-19], t$95$4, If[LessEqual[NdChar, -8e-71], t$95$3, If[LessEqual[NdChar, 1.35e-188], t$95$1, If[LessEqual[NdChar, 7e-19], N[(t$95$0 + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 7.4e+17], t$95$3, If[LessEqual[NdChar, 7.2e+53], t$95$1, If[LessEqual[NdChar, 8e+115], t$95$4, t$95$3]]]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -1.59999999999999991e-19 or 7.2e53 < NdChar < 8.0000000000000001e115

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.6%

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

   6. Taylor expanded in Vef around inf 74.4%

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

   if -1.59999999999999991e-19 < NdChar < -7.9999999999999993e-71 or 7.00000000000000031e-19 < NdChar < 7.4e17 or 8.0000000000000001e115 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 73.0%

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

   6. Taylor expanded in mu around -inf 83.8%

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

      1. mul-1-neg 83.8%

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

      2. distribute-rgt-neg-in 83.8%

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

      3. +-commutative 83.8%

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

      4. mul-1-neg 83.8%

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

      5. unsub-neg 83.8%

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

      6. associate-+r+ 83.8%

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

      7. +-commutative 83.8%

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

   8. Simplified 83.8%

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

   if -7.9999999999999993e-71 < NdChar < 1.35e-188 or 7.4e17 < NdChar < 7.2e53

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 81.6%

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

      1. associate-*r/ 81.6%

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

      2. mul-1-neg 81.6%

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

   7. Simplified 81.6%

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

   8. Taylor expanded in Ec around 0 75.1%

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

      1. mul-1-neg 75.1%

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

      2. unsub-neg 75.1%

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

   10. Simplified 75.1%

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

   if 1.35e-188 < NdChar < 7.00000000000000031e-19

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

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

4. Final simplification 77.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -1.6 \cdot 10^{-19}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq -8 \cdot 10^{-71}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 1.35 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 7 \cdot 10^{-19}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq 7.4 \cdot 10^{+17}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 7.2 \cdot 10^{+53}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + \frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 8 \cdot 10^{+115}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Vef}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor - \left(\left(Ec - Vef\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + mu \cdot \left(\frac{\left(1 + \frac{EAccept}{KbT}\right) + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)}{mu} + \frac{-1}{KbT}\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 63.1% accurate, 1.6× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT))))))
   (if (<= NdChar -8.2e-20)
     (+ t_0 (/ NaChar (+ 1.0 (/ Vef KbT))))
     (if (<= NdChar 1e+55)
       (+
        (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT))))
        (/ NdChar (- 2.0 (/ Ec KbT))))
       (+
        t_0
        (/
         1.0
         (/
          (- (+ (+ (/ Ev KbT) (/ Vef KbT)) (+ (/ EAccept KbT) 2.0)) (/ mu KbT))
          NaChar)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double tmp;
	if (NdChar <= -8.2e-20) {
		tmp = t_0 + (NaChar / (1.0 + (Vef / KbT)));
	} else if (NdChar <= 1e+55) {
		tmp = (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / (2.0 - (Ec / KbT)));
	} else {
		tmp = t_0 + (1.0 / (((((Ev / KbT) + (Vef / KbT)) + ((EAccept / KbT) + 2.0)) - (mu / KbT)) / NaChar));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -8.2000000000000002e-20

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.4%

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

   6. Taylor expanded in Vef around inf 72.8%

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

   if -8.2000000000000002e-20 < NdChar < 1.00000000000000001e55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 78.7%

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

      1. associate-*r/ 78.7%

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

      2. mul-1-neg 78.7%

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

   7. Simplified 78.7%

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

   8. Taylor expanded in Ec around 0 71.0%

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

      1. mul-1-neg 71.0%

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

      2. unsub-neg 71.0%

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

   10. Simplified 71.0%

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

   if 1.00000000000000001e55 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 78.5%

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

      1. clear-num 78.7%

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

      2. inv-pow 78.7%

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

      3. associate--l+ 78.7%

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

      4. +-commutative 78.7%

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

   7. Applied egg-rr 78.7%

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

      1. unpow-1 78.7%

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

      2. associate-+r+ 78.7%

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

      3. metadata-eval 78.7%

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

      4. +-commutative 78.7%

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

      5. associate--l+ 78.7%

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

      6. associate-+r+ 78.7%

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

      7. +-commutative 78.7%

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

   9. Simplified 78.7%

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

4. Final simplification 72.9%

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

Alternative 14: 64.1% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -9.5e-20) (not (<= NdChar 2.55e-18)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT))))
    (/ NaChar (+ 1.0 (/ Vef KbT))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT))))
    (/ NdChar (+ (/ EDonor KbT) 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -9.5e-20 or 2.54999999999999991e-18 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 66.1%

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

   6. Taylor expanded in Vef around inf 68.8%

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

   if -9.5e-20 < NdChar < 2.54999999999999991e-18

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EDonor around 0 72.4%

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

4. Final simplification 70.7%

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

Alternative 15: 60.6% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -6.8e-19) (not (<= NdChar 9e-119)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT))))
    (/ NaChar (+ 1.0 (/ Vef KbT))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT))))
    (* NdChar 0.5))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -6.8000000000000004e-19 or 9.0000000000000005e-119 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 63.4%

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

   6. Taylor expanded in Vef around inf 68.1%

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

   if -6.8000000000000004e-19 < NdChar < 9.0000000000000005e-119

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 63.9%

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

4. Final simplification 66.3%

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

Alternative 16: 59.6% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -1.0999999999999999e-18 or 45 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 65.3%

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

   6. Taylor expanded in Ev around inf 64.6%

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

   if -1.0999999999999999e-18 < NdChar < 45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.0%

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

4. Final simplification 63.3%

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

Alternative 17: 62.9% accurate, 1.7× speedup

Math

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor - ((Ec - Vef) - mu)) / KbT)));
	double tmp;
	if (NdChar <= -2.3e-18) {
		tmp = t_0 + (NaChar / (1.0 + (Vef / KbT)));
	} else if (NdChar <= 9.5e-19) {
		tmp = (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
	} else {
		tmp = t_0 + (NaChar / (1.0 - (mu / KbT)));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT)))
	tmp = 0
	if NdChar <= -2.3e-18:
		tmp = t_0 + (NaChar / (1.0 + (Vef / KbT)))
	elif NdChar <= 9.5e-19:
		tmp = (NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0))
	else:
		tmp = t_0 + (NaChar / (1.0 - (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(Float64(Ec - Vef) - mu)) / KbT))))
	tmp = 0.0
	if (NdChar <= -2.3e-18)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Vef / KbT))));
	elseif (NdChar <= 9.5e-19)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef - Float64(Float64(mu - EAccept) - Ev)) / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0)));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 - Float64(mu / KbT))));
	end
	return tmp
end

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -2.3000000000000001e-18

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.4%

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

   6. Taylor expanded in Vef around inf 72.8%

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

   if -2.3000000000000001e-18 < NdChar < 9.4999999999999995e-19

   1. Initial program 100.0%

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

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

   6. Taylor expanded in EDonor around 0 72.4%

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

   if 9.4999999999999995e-19 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 72.9%

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

   6. Taylor expanded in mu around inf 65.1%

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

      1. neg-mul-1 65.1%

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

      2. distribute-frac-neg2 65.1%

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

   8. Simplified 65.1%

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

4. Final simplification 70.9%

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

Alternative 18: 56.0% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -5.20000000000000004e-70 or 1.9000000000000001e41 < 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. Step-by-step derivation

      1. clear-num 99.9%

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

      2. inv-pow 99.9%

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

      3. div-inv 99.9%

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

      4. associate-*r/ 99.9%

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

      5. *-commutative 99.9%

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

      6. *-un-lft-identity 99.9%

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

      7. +-commutative 99.9%

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

      8. associate-+l- 99.9%

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

   6. Applied egg-rr 99.9%

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

   8. Simplified 99.9%

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

   9. Taylor expanded in KbT around inf 57.1%

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

   if -5.20000000000000004e-70 < NdChar < 1.9000000000000001e41

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 63.4%

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

4. Final simplification 60.2%

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

Alternative 19: 56.0% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -5.20000000000000004e-70 or 2.2500000000000001e41 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 57.2%

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

   if -5.20000000000000004e-70 < NdChar < 2.2500000000000001e41

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 63.4%

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

4. Final simplification 60.2%

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

Alternative 20: 48.8% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -6 \cdot 10^{+116}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;NdChar \leq 2.7 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef - \left(\left(mu - EAccept\right) - Ev\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NdChar \leq 2.9 \cdot 10^{+122}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -6e+116)
   (+ (/ NdChar (+ 1.0 (exp (/ Ec (- KbT))))) (/ NaChar 2.0))
   (if (<= NdChar 2.7e+55)
     (+
      (/ NaChar (+ 1.0 (exp (/ (- Vef (- (- mu EAccept) Ev)) KbT))))
      (* NdChar 0.5))
     (if (<= NdChar 2.9e+122)
       (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
       (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (/ NaChar 2.0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NdChar <= -6e+116) {
		tmp = (NdChar / (1.0 + exp((Ec / -KbT)))) + (NaChar / 2.0);
	} else if (NdChar <= 2.7e+55) {
		tmp = (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar * 0.5);
	} else if (NdChar <= 2.9e+122) {
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	} else {
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NdChar <= -6e+116:
		tmp = (NdChar / (1.0 + math.exp((Ec / -KbT)))) + (NaChar / 2.0)
	elif NdChar <= 2.7e+55:
		tmp = (NaChar / (1.0 + math.exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar * 0.5)
	elif NdChar <= 2.9e+122:
		tmp = NdChar / (1.0 + math.exp((EDonor / KbT)))
	else:
		tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NdChar <= -6e+116)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-KbT))))) + Float64(NaChar / 2.0));
	elseif (NdChar <= 2.7e+55)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef - Float64(Float64(mu - EAccept) - Ev)) / KbT)))) + Float64(NdChar * 0.5));
	elseif (NdChar <= 2.9e+122)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NdChar <= -6e+116)
		tmp = (NdChar / (1.0 + exp((Ec / -KbT)))) + (NaChar / 2.0);
	elseif (NdChar <= 2.7e+55)
		tmp = (NaChar / (1.0 + exp(((Vef - ((mu - EAccept) - Ev)) / KbT)))) + (NdChar * 0.5);
	elseif (NdChar <= 2.9e+122)
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	else
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -6e+116], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.7e+55], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef - N[(N[(mu - EAccept), $MachinePrecision] - Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.9e+122], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -5.9999999999999997e116

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 67.9%

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

      1. associate-*r/ 67.9%

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

      2. mul-1-neg 67.9%

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

   7. Simplified 67.9%

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

   8. Taylor expanded in KbT around inf 52.5%

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

   if -5.9999999999999997e116 < NdChar < 2.69999999999999977e55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.9%

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

   if 2.69999999999999977e55 < NdChar < 2.9000000000000001e122

   1. Initial program 100.0%

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

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

   7. Taylor expanded in NdChar around inf 57.2%

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

   if 2.9000000000000001e122 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in Vef around inf 68.1%

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

   6. Taylor expanded in KbT around inf 49.1%

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

4. Final simplification 57.3%

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

Alternative 21: 38.7% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -0.005:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;NdChar \leq 2.75 \cdot 10^{-124}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NdChar \leq 1.32 \cdot 10^{+128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -0.005)
   (+ (/ NdChar (+ 1.0 (exp (/ Ec (- KbT))))) (/ NaChar 2.0))
   (if (<= NdChar 2.75e-124)
     (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
     (if (<= NdChar 1.32e+128)
       (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
       (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (/ NaChar 2.0))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -0.005], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.75e-124], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.32e+128], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -0.0050000000000000001

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ec around inf 65.2%

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

      1. associate-*r/ 65.2%

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

      2. mul-1-neg 65.2%

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

   7. Simplified 65.2%

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

   8. Taylor expanded in KbT around inf 48.4%

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

   if -0.0050000000000000001 < NdChar < 2.75000000000000008e-124

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 63.5%

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

   6. Taylor expanded in EAccept around inf 47.8%

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

   if 2.75000000000000008e-124 < NdChar < 1.31999999999999991e128

   1. Initial program 100.0%

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

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

   7. Taylor expanded in NdChar around inf 42.1%

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

   if 1.31999999999999991e128 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in Vef around inf 68.1%

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

   6. Taylor expanded in KbT around inf 49.1%

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

4. Final simplification 47.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -0.005:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;NdChar \leq 2.75 \cdot 10^{-124}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NdChar \leq 1.32 \cdot 10^{+128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 22: 40.8% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 2.72 \cdot 10^{+101}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;EAccept \leq 1.1 \cdot 10^{+202}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 2.72e+101)
   (+ (/ NaChar (+ 1.0 (exp (/ (+ Vef Ev) KbT)))) (* NdChar 0.5))
   (if (<= EAccept 1.1e+202)
     (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar (+ (/ EAccept KbT) 2.0)))
     (+
      (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
      (/ NdChar (+ (/ mu 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 (EAccept <= 2.72e+101) {
		tmp = (NaChar / (1.0 + exp(((Vef + Ev) / KbT)))) + (NdChar * 0.5);
	} else if (EAccept <= 1.1e+202) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / ((mu / 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 (eaccept <= 2.72d+101) then
        tmp = (nachar / (1.0d0 + exp(((vef + ev) / kbt)))) + (ndchar * 0.5d0)
    else if (eaccept <= 1.1d+202) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / ((mu / 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 (EAccept <= 2.72e+101) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + Ev) / KbT)))) + (NdChar * 0.5);
	} else if (EAccept <= 1.1e+202) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / ((mu / KbT) + 2.0));
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EAccept, 2.72e+101], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + Ev), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.1e+202], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if EAccept < 2.71999999999999995e101

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 45.9%

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

   if 2.71999999999999995e101 < EAccept < 1.09999999999999989e202

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in mu around inf 65.6%

      \[\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 EAccept around inf 43.6%

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

   7. Taylor expanded in EAccept around 0 43.1%

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

   if 1.09999999999999989e202 < 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 mu around inf 61.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 EAccept around inf 61.7%

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

   7. Taylor expanded in mu around 0 61.4%

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

4. Final simplification 46.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 2.72 \cdot 10^{+101}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;EAccept \leq 1.1 \cdot 10^{+202}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 23: 40.5% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 8.4 \cdot 10^{+101}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;EAccept \leq 3.6 \cdot 10^{+203}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < 8.4000000000000001e101

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 45.9%

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

   if 8.4000000000000001e101 < EAccept < 3.59999999999999982e203

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in mu around inf 65.6%

      \[\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 EAccept around inf 43.6%

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

   7. Taylor expanded in EAccept around 0 43.1%

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

   if 3.59999999999999982e203 < 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 50.6%

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

   6. Taylor expanded in EAccept around inf 50.6%

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

4. Final simplification 46.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 8.4 \cdot 10^{+101}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;EAccept \leq 3.6 \cdot 10^{+203}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 24: 39.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -4.7 \cdot 10^{-210} \lor \neg \left(NaChar \leq 7.5 \cdot 10^{-67}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -4.7e-210], N[Not[LessEqual[NaChar, 7.5e-67]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -4.69999999999999967e-210 or 7.5000000000000005e-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 KbT around inf 54.4%

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

   6. Taylor expanded in EAccept around inf 40.5%

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

   if -4.69999999999999967e-210 < NaChar < 7.5000000000000005e-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 EDonor around inf 65.3%

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

   6. Taylor expanded in KbT around inf 40.2%

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

   7. Taylor expanded in NdChar around inf 52.9%

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

4. Final simplification 43.4%

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

Alternative 25: 40.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 9.8 \cdot 10^{+98}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 9.8e+98)
   (+ (/ NaChar (+ 1.0 (exp (/ (+ Vef Ev) KbT)))) (* NdChar 0.5))
   (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 9.79999999999999958e98

   1. Initial program 100.0%

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

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

   6. Taylor expanded in Ev around inf 45.7%

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

   if 9.79999999999999958e98 < EAccept

   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 37.8%

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

   6. Taylor expanded in EAccept around inf 34.1%

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

4. Final simplification 43.9%

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

Alternative 26: 38.7% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -1.22e-60) (not (<= KbT 8e+149)))
   (+ (/ NdChar (+ (/ EDonor KbT) 2.0)) (/ NaChar 2.0))
   (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -1.22e-60 or 8.00000000000000039e149 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

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

   7. Taylor expanded in EDonor around 0 52.0%

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

   if -1.22e-60 < KbT < 8.00000000000000039e149

   1. Initial program 100.0%

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

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

   7. Taylor expanded in NdChar around inf 29.4%

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

4. Final simplification 39.8%

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

Alternative 27: 37.1% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 1.8e+90)
   (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))
   (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 1.8e90

   1. Initial program 100.0%

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

   6. Taylor expanded in Ev around inf 42.4%

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

   if 1.8e90 < EAccept

   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 36.1%

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

   6. Taylor expanded in EAccept around inf 32.2%

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

4. Final simplification 40.8%

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

Alternative 28: 26.2% accurate, 20.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

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

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

7. Taylor expanded in EDonor around 0 30.3%

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

8. Final simplification 30.3%

   \[\leadsto \frac{NdChar}{\frac{EDonor}{KbT} + 2} + \frac{NaChar}{2} \]
9. Add Preprocessing

Alternative 29: 27.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 67.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 KbT around inf 36.0%

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

7. Taylor expanded in EDonor around 0 30.3%

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

   1. +-commutative 30.3%

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

   2. distribute-lft-out 30.3%

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

9. Simplified 30.3%

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

Alternative 30: 18.6% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

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

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

7. Taylor expanded in NdChar around 0 21.5%

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

8. Final simplification 21.5%

   \[\leadsto NaChar \cdot 0.5 \]
9. Add Preprocessing

Reproduce

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