Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 31.8s

Alternatives: 19

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -5.099467401844775e+133
  2. Ec = -1.430448110835693e-51
  3. Vef = -1.0012223155229063e+218
  4. EDonor = -2.4783265747306655e+182
  5. mu = 8.855785003289961e+94
  6. KbT = 1.6942392620669794e+196
  7. NaChar = 2.0111370349876435e+133
  8. Ev = -1.671470888099552e-256
  9. EAccept = 3.681282177431161e+139

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Final simplification 100.0%

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

Alternative 2: 59.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;NaChar \leq -3 \cdot 10^{+226}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NaChar \leq -2.2 \cdot 10^{+208}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq -5.6 \cdot 10^{+156}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NaChar \leq -1.65 \cdot 10^{+128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\frac{EAccept}{KbT} + \left(1 + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}\right)\right)}\\ \mathbf{elif}\;NaChar \leq -2.45 \cdot 10^{-95}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NaChar \leq 6.2 \cdot 10^{-142}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq 5.6 \cdot 10^{-28}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq 3.4 \cdot 10^{+56}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq 7.2 \cdot 10^{+175}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq 1.1 \cdot 10^{+191}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= NaChar -3e+226)
     t_2
     (if (<= NaChar -2.2e+208)
       t_0
       (if (<= NaChar -5.6e+156)
         t_2
         (if (<= NaChar -1.65e+128)
           (+
            (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
            (/
             NaChar
             (+
              1.0
              (+
               (/ EAccept KbT)
               (+ 1.0 (* 0.5 (/ (* EAccept EAccept) (* KbT KbT))))))))
           (if (<= NaChar -2.45e-95)
             t_2
             (if (<= NaChar 6.2e-142)
               t_0
               (if (<= NaChar 5.6e-28)
                 t_1
                 (if (<= NaChar 3.4e+56)
                   t_0
                   (if (<= NaChar 7.2e+175)
                     t_1
                     (if (<= NaChar 1.1e+191) t_0 t_2))))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double t_2 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -3e+226) {
		tmp = t_2;
	} else if (NaChar <= -2.2e+208) {
		tmp = t_0;
	} else if (NaChar <= -5.6e+156) {
		tmp = t_2;
	} else if (NaChar <= -1.65e+128) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((EAccept / KbT) + (1.0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))))));
	} else if (NaChar <= -2.45e-95) {
		tmp = t_2;
	} else if (NaChar <= 6.2e-142) {
		tmp = t_0;
	} else if (NaChar <= 5.6e-28) {
		tmp = t_1;
	} else if (NaChar <= 3.4e+56) {
		tmp = t_0;
	} else if (NaChar <= 7.2e+175) {
		tmp = t_1;
	} else if (NaChar <= 1.1e+191) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))
    t_1 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    t_2 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (nachar <= (-3d+226)) then
        tmp = t_2
    else if (nachar <= (-2.2d+208)) then
        tmp = t_0
    else if (nachar <= (-5.6d+156)) then
        tmp = t_2
    else if (nachar <= (-1.65d+128)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + ((eaccept / kbt) + (1.0d0 + (0.5d0 * ((eaccept * eaccept) / (kbt * kbt)))))))
    else if (nachar <= (-2.45d-95)) then
        tmp = t_2
    else if (nachar <= 6.2d-142) then
        tmp = t_0
    else if (nachar <= 5.6d-28) then
        tmp = t_1
    else if (nachar <= 3.4d+56) then
        tmp = t_0
    else if (nachar <= 7.2d+175) then
        tmp = t_1
    else if (nachar <= 1.1d+191) then
        tmp = t_0
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double t_2 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -3e+226) {
		tmp = t_2;
	} else if (NaChar <= -2.2e+208) {
		tmp = t_0;
	} else if (NaChar <= -5.6e+156) {
		tmp = t_2;
	} else if (NaChar <= -1.65e+128) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((EAccept / KbT) + (1.0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))))));
	} else if (NaChar <= -2.45e-95) {
		tmp = t_2;
	} else if (NaChar <= 6.2e-142) {
		tmp = t_0;
	} else if (NaChar <= 5.6e-28) {
		tmp = t_1;
	} else if (NaChar <= 3.4e+56) {
		tmp = t_0;
	} else if (NaChar <= 7.2e+175) {
		tmp = t_1;
	} else if (NaChar <= 1.1e+191) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	t_2 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if NaChar <= -3e+226:
		tmp = t_2
	elif NaChar <= -2.2e+208:
		tmp = t_0
	elif NaChar <= -5.6e+156:
		tmp = t_2
	elif NaChar <= -1.65e+128:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((EAccept / KbT) + (1.0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))))))
	elif NaChar <= -2.45e-95:
		tmp = t_2
	elif NaChar <= 6.2e-142:
		tmp = t_0
	elif NaChar <= 5.6e-28:
		tmp = t_1
	elif NaChar <= 3.4e+56:
		tmp = t_0
	elif NaChar <= 7.2e+175:
		tmp = t_1
	elif NaChar <= 1.1e+191:
		tmp = t_0
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (NaChar <= -3e+226)
		tmp = t_2;
	elseif (NaChar <= -2.2e+208)
		tmp = t_0;
	elseif (NaChar <= -5.6e+156)
		tmp = t_2;
	elseif (NaChar <= -1.65e+128)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(1.0 + Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT))))))));
	elseif (NaChar <= -2.45e-95)
		tmp = t_2;
	elseif (NaChar <= 6.2e-142)
		tmp = t_0;
	elseif (NaChar <= 5.6e-28)
		tmp = t_1;
	elseif (NaChar <= 3.4e+56)
		tmp = t_0;
	elseif (NaChar <= 7.2e+175)
		tmp = t_1;
	elseif (NaChar <= 1.1e+191)
		tmp = t_0;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	t_2 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (NaChar <= -3e+226)
		tmp = t_2;
	elseif (NaChar <= -2.2e+208)
		tmp = t_0;
	elseif (NaChar <= -5.6e+156)
		tmp = t_2;
	elseif (NaChar <= -1.65e+128)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((EAccept / KbT) + (1.0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))))));
	elseif (NaChar <= -2.45e-95)
		tmp = t_2;
	elseif (NaChar <= 6.2e-142)
		tmp = t_0;
	elseif (NaChar <= 5.6e-28)
		tmp = t_1;
	elseif (NaChar <= 3.4e+56)
		tmp = t_0;
	elseif (NaChar <= 7.2e+175)
		tmp = t_1;
	elseif (NaChar <= 1.1e+191)
		tmp = t_0;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -3e+226], t$95$2, If[LessEqual[NaChar, -2.2e+208], t$95$0, If[LessEqual[NaChar, -5.6e+156], t$95$2, If[LessEqual[NaChar, -1.65e+128], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(1.0 + N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -2.45e-95], t$95$2, If[LessEqual[NaChar, 6.2e-142], t$95$0, If[LessEqual[NaChar, 5.6e-28], t$95$1, If[LessEqual[NaChar, 3.4e+56], t$95$0, If[LessEqual[NaChar, 7.2e+175], t$95$1, If[LessEqual[NaChar, 1.1e+191], t$95$0, t$95$2]]]]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -2.99999999999999975e226 or -2.20000000000000014e208 < NaChar < -5.59999999999999975e156 or -1.65e128 < NaChar < -2.45e-95 or 1.1e191 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 75.6%

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

   if -2.99999999999999975e226 < NaChar < -2.20000000000000014e208 or -2.45e-95 < NaChar < 6.2e-142 or 5.5999999999999996e-28 < NaChar < 3.40000000000000001e56 or 7.20000000000000067e175 < NaChar < 1.1e191

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 63.1%

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

   5. Taylor expanded in Ev around inf 51.2%

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

      1. associate-/l* 48.0%

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

   7. Simplified 48.0%

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

   8. Taylor expanded in NdChar around inf 85.5%

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

   if -5.59999999999999975e156 < NaChar < -1.65e128

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 68.4%

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

   5. Taylor expanded in EAccept around 0 59.1%

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

      1. unpow2 59.1%

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

      2. unpow2 59.1%

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

   7. Simplified 59.1%

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

   if 6.2e-142 < NaChar < 5.5999999999999996e-28 or 3.40000000000000001e56 < NaChar < 7.20000000000000067e175

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 74.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}}}} \]

   5. Taylor expanded in EDonor around inf 65.8%

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

4. Final simplification 77.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3 \cdot 10^{+226}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq -2.2 \cdot 10^{+208}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -5.6 \cdot 10^{+156}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq -1.65 \cdot 10^{+128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\frac{EAccept}{KbT} + \left(1 + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}\right)\right)}\\ \mathbf{elif}\;NaChar \leq -2.45 \cdot 10^{-95}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq 6.2 \cdot 10^{-142}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 5.6 \cdot 10^{-28}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 3.4 \cdot 10^{+56}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 7.2 \cdot 10^{+175}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 1.1 \cdot 10^{+191}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 3: 61.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_2 := 1 + e^{\frac{Vef}{KbT}}\\ t_3 := \frac{NaChar}{t_2} + \frac{NdChar}{t_2}\\ t_4 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;Vef \leq -7.8 \cdot 10^{+95}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;Vef \leq -2.2 \cdot 10^{+70}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq -3.2 \cdot 10^{+58}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(\frac{\frac{Ev \cdot Ev}{KbT \cdot KbT}}{\frac{Ev}{KbT} + \left(\left(-1 - \frac{Vef}{KbT}\right) - \frac{EAccept}{KbT}\right)} - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;Vef \leq -1200000000:\\ \;\;\;\;t_0 + \frac{NaChar}{\left(\frac{Ev}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;Vef \leq -1.35 \cdot 10^{-145}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq 1.02 \cdot 10^{-151}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;Vef \leq 1.9 \cdot 10^{-73}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq 2 \cdot 10^{+103}:\\ \;\;\;\;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 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_2 (+ 1.0 (exp (/ Vef KbT))))
        (t_3 (+ (/ NaChar t_2) (/ NdChar t_2)))
        (t_4
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= Vef -7.8e+95)
     t_3
     (if (<= Vef -2.2e+70)
       t_1
       (if (<= Vef -3.2e+58)
         (+
          t_0
          (/
           NaChar
           (+
            1.0
            (-
             (/
              (/ (* Ev Ev) (* KbT KbT))
              (+ (/ Ev KbT) (- (- -1.0 (/ Vef KbT)) (/ EAccept KbT))))
             (/ mu KbT)))))
         (if (<= Vef -1200000000.0)
           (+ t_0 (/ NaChar (- (+ (/ Ev KbT) (+ (/ Vef KbT) 2.0)) (/ mu KbT))))
           (if (<= Vef -1.35e-145)
             t_1
             (if (<= Vef 1.02e-151)
               t_4
               (if (<= Vef 1.9e-73)
                 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))
                 (if (<= Vef 2e+103) 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 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_2 = 1.0 + exp((Vef / KbT));
	double t_3 = (NaChar / t_2) + (NdChar / t_2);
	double t_4 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (Vef <= -7.8e+95) {
		tmp = t_3;
	} else if (Vef <= -2.2e+70) {
		tmp = t_1;
	} else if (Vef <= -3.2e+58) {
		tmp = t_0 + (NaChar / (1.0 + ((((Ev * Ev) / (KbT * KbT)) / ((Ev / KbT) + ((-1.0 - (Vef / KbT)) - (EAccept / KbT)))) - (mu / KbT))));
	} else if (Vef <= -1200000000.0) {
		tmp = t_0 + (NaChar / (((Ev / KbT) + ((Vef / KbT) + 2.0)) - (mu / KbT)));
	} else if (Vef <= -1.35e-145) {
		tmp = t_1;
	} else if (Vef <= 1.02e-151) {
		tmp = t_4;
	} else if (Vef <= 1.9e-73) {
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	} else if (Vef <= 2e+103) {
		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 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_2 = 1.0d0 + exp((vef / kbt))
    t_3 = (nachar / t_2) + (ndchar / t_2)
    t_4 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    if (vef <= (-7.8d+95)) then
        tmp = t_3
    else if (vef <= (-2.2d+70)) then
        tmp = t_1
    else if (vef <= (-3.2d+58)) then
        tmp = t_0 + (nachar / (1.0d0 + ((((ev * ev) / (kbt * kbt)) / ((ev / kbt) + (((-1.0d0) - (vef / kbt)) - (eaccept / kbt)))) - (mu / kbt))))
    else if (vef <= (-1200000000.0d0)) then
        tmp = t_0 + (nachar / (((ev / kbt) + ((vef / kbt) + 2.0d0)) - (mu / kbt)))
    else if (vef <= (-1.35d-145)) then
        tmp = t_1
    else if (vef <= 1.02d-151) then
        tmp = t_4
    else if (vef <= 1.9d-73) then
        tmp = ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))
    else if (vef <= 2d+103) 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 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_2 = 1.0 + Math.exp((Vef / KbT));
	double t_3 = (NaChar / t_2) + (NdChar / t_2);
	double t_4 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (Vef <= -7.8e+95) {
		tmp = t_3;
	} else if (Vef <= -2.2e+70) {
		tmp = t_1;
	} else if (Vef <= -3.2e+58) {
		tmp = t_0 + (NaChar / (1.0 + ((((Ev * Ev) / (KbT * KbT)) / ((Ev / KbT) + ((-1.0 - (Vef / KbT)) - (EAccept / KbT)))) - (mu / KbT))));
	} else if (Vef <= -1200000000.0) {
		tmp = t_0 + (NaChar / (((Ev / KbT) + ((Vef / KbT) + 2.0)) - (mu / KbT)));
	} else if (Vef <= -1.35e-145) {
		tmp = t_1;
	} else if (Vef <= 1.02e-151) {
		tmp = t_4;
	} else if (Vef <= 1.9e-73) {
		tmp = NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	} else if (Vef <= 2e+103) {
		tmp = t_4;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_2 = 1.0 + math.exp((Vef / KbT))
	t_3 = (NaChar / t_2) + (NdChar / t_2)
	t_4 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if Vef <= -7.8e+95:
		tmp = t_3
	elif Vef <= -2.2e+70:
		tmp = t_1
	elif Vef <= -3.2e+58:
		tmp = t_0 + (NaChar / (1.0 + ((((Ev * Ev) / (KbT * KbT)) / ((Ev / KbT) + ((-1.0 - (Vef / KbT)) - (EAccept / KbT)))) - (mu / KbT))))
	elif Vef <= -1200000000.0:
		tmp = t_0 + (NaChar / (((Ev / KbT) + ((Vef / KbT) + 2.0)) - (mu / KbT)))
	elif Vef <= -1.35e-145:
		tmp = t_1
	elif Vef <= 1.02e-151:
		tmp = t_4
	elif Vef <= 1.9e-73:
		tmp = NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))
	elif Vef <= 2e+103:
		tmp = t_4
	else:
		tmp = t_3
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_2 = Float64(1.0 + exp(Float64(Vef / KbT)))
	t_3 = Float64(Float64(NaChar / t_2) + Float64(NdChar / t_2))
	t_4 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (Vef <= -7.8e+95)
		tmp = t_3;
	elseif (Vef <= -2.2e+70)
		tmp = t_1;
	elseif (Vef <= -3.2e+58)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Float64(Ev * Ev) / Float64(KbT * KbT)) / Float64(Float64(Ev / KbT) + Float64(Float64(-1.0 - Float64(Vef / KbT)) - Float64(EAccept / KbT)))) - Float64(mu / KbT)))));
	elseif (Vef <= -1200000000.0)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(Vef / KbT) + 2.0)) - Float64(mu / KbT))));
	elseif (Vef <= -1.35e-145)
		tmp = t_1;
	elseif (Vef <= 1.02e-151)
		tmp = t_4;
	elseif (Vef <= 1.9e-73)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))));
	elseif (Vef <= 2e+103)
		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 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_2 = 1.0 + exp((Vef / KbT));
	t_3 = (NaChar / t_2) + (NdChar / t_2);
	t_4 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (Vef <= -7.8e+95)
		tmp = t_3;
	elseif (Vef <= -2.2e+70)
		tmp = t_1;
	elseif (Vef <= -3.2e+58)
		tmp = t_0 + (NaChar / (1.0 + ((((Ev * Ev) / (KbT * KbT)) / ((Ev / KbT) + ((-1.0 - (Vef / KbT)) - (EAccept / KbT)))) - (mu / KbT))));
	elseif (Vef <= -1200000000.0)
		tmp = t_0 + (NaChar / (((Ev / KbT) + ((Vef / KbT) + 2.0)) - (mu / KbT)));
	elseif (Vef <= -1.35e-145)
		tmp = t_1;
	elseif (Vef <= 1.02e-151)
		tmp = t_4;
	elseif (Vef <= 1.9e-73)
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	elseif (Vef <= 2e+103)
		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[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(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[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(NaChar / t$95$2), $MachinePrecision] + N[(NdChar / t$95$2), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = 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[Vef, -7.8e+95], t$95$3, If[LessEqual[Vef, -2.2e+70], t$95$1, If[LessEqual[Vef, -3.2e+58], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(N[(N[(Ev * Ev), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision] / N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(-1.0 - N[(Vef / KbT), $MachinePrecision]), $MachinePrecision] - N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -1200000000.0], N[(t$95$0 + N[(NaChar / N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -1.35e-145], t$95$1, If[LessEqual[Vef, 1.02e-151], t$95$4, If[LessEqual[Vef, 1.9e-73], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2e+103], t$95$4, t$95$3]]]]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if Vef < -7.7999999999999994e95 or 2e103 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 90.0%

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

   5. Taylor expanded in Vef around inf 82.0%

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

   if -7.7999999999999994e95 < Vef < -2.20000000000000001e70 or -1.2e9 < Vef < -1.35e-145

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 79.8%

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

      1. associate-*r/ 79.8%

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

      2. mul-1-neg 79.8%

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

   6. Simplified 79.8%

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

   7. Taylor expanded in mu around inf 71.4%

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

   if -2.20000000000000001e70 < Vef < -3.20000000000000015e58

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 63.1%

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

      1. flip-+ 63.1%

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

   6. Applied egg-rr 63.1%

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

   7. Taylor expanded in Ev around inf 55.2%

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

      1. unpow2 55.2%

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

      2. unpow2 55.2%

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

   9. Simplified 55.2%

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

   if -3.20000000000000015e58 < Vef < -1.2e9

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 73.2%

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

   5. Taylor expanded in EAccept around 0 82.3%

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

   if -1.35e-145 < Vef < 1.0200000000000001e-151 or 1.9000000000000001e-73 < Vef < 2e103

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 81.0%

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

   5. Taylor expanded in EDonor around inf 68.4%

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

   if 1.0200000000000001e-151 < Vef < 1.9000000000000001e-73

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 52.4%

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

   5. Taylor expanded in Ev around inf 32.2%

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

      1. associate-/l* 32.2%

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

   7. Simplified 32.2%

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

   8. Taylor expanded in NdChar around inf 80.4%

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

4. Final simplification 74.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -7.8 \cdot 10^{+95}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq -2.2 \cdot 10^{+70}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq -3.2 \cdot 10^{+58}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\frac{\frac{Ev \cdot Ev}{KbT \cdot KbT}}{\frac{Ev}{KbT} + \left(\left(-1 - \frac{Vef}{KbT}\right) - \frac{EAccept}{KbT}\right)} - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;Vef \leq -1200000000:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\left(\frac{Ev}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;Vef \leq -1.35 \cdot 10^{-145}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.02 \cdot 10^{-151}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.9 \cdot 10^{-73}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq 2 \cdot 10^{+103}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]

Alternative 4: 76.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;EAccept \leq -1.6 \cdot 10^{-70}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;EAccept \leq 6.2 \cdot 10^{-76}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 7600000000 \lor \neg \left(EAccept \leq 3.75 \cdot 10^{+115}\right) \land EAccept \leq 2.3 \cdot 10^{+147}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))
   (if (<= EAccept -1.6e-70)
     t_1
     (if (<= EAccept 6.2e-76)
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
       (if (or (<= EAccept 7600000000.0)
               (and (not (<= EAccept 3.75e+115)) (<= EAccept 2.3e+147)))
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	double tmp;
	if (EAccept <= -1.6e-70) {
		tmp = t_1;
	} else if (EAccept <= 6.2e-76) {
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	} else if ((EAccept <= 7600000000.0) || (!(EAccept <= 3.75e+115) && (EAccept <= 2.3e+147))) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))
    t_1 = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
    if (eaccept <= (-1.6d-70)) then
        tmp = t_1
    else if (eaccept <= 6.2d-76) then
        tmp = t_0 + (nachar / (1.0d0 + exp((vef / kbt))))
    else if ((eaccept <= 7600000000.0d0) .or. (.not. (eaccept <= 3.75d+115)) .and. (eaccept <= 2.3d+147)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	double tmp;
	if (EAccept <= -1.6e-70) {
		tmp = t_1;
	} else if (EAccept <= 6.2e-76) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
	} else if ((EAccept <= 7600000000.0) || (!(EAccept <= 3.75e+115) && (EAccept <= 2.3e+147))) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))
	t_1 = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	tmp = 0
	if EAccept <= -1.6e-70:
		tmp = t_1
	elif EAccept <= 6.2e-76:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT))))
	elif (EAccept <= 7600000000.0) or (not (EAccept <= 3.75e+115) and (EAccept <= 2.3e+147)):
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))))
	tmp = 0.0
	if (EAccept <= -1.6e-70)
		tmp = t_1;
	elseif (EAccept <= 6.2e-76)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	elseif ((EAccept <= 7600000000.0) || (!(EAccept <= 3.75e+115) && (EAccept <= 2.3e+147)))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)));
	t_1 = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	tmp = 0.0;
	if (EAccept <= -1.6e-70)
		tmp = t_1;
	elseif (EAccept <= 6.2e-76)
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	elseif ((EAccept <= 7600000000.0) || (~((EAccept <= 3.75e+115)) && (EAccept <= 2.3e+147)))
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -1.6e-70], t$95$1, If[LessEqual[EAccept, 6.2e-76], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EAccept, 7600000000.0], And[N[Not[LessEqual[EAccept, 3.75e+115]], $MachinePrecision], LessEqual[EAccept, 2.3e+147]]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if EAccept < -1.5999999999999999e-70 or 7.6e9 < EAccept < 3.7499999999999998e115 or 2.2999999999999999e147 < 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. Taylor expanded in EAccept around inf 84.4%

      \[\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 -1.5999999999999999e-70 < EAccept < 6.19999999999999939e-76

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 77.5%

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

   if 6.19999999999999939e-76 < EAccept < 7.6e9 or 3.7499999999999998e115 < EAccept < 2.2999999999999999e147

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 81.3%

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

4. Final simplification 81.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq -1.6 \cdot 10^{-70}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 6.2 \cdot 10^{-76}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 7600000000 \lor \neg \left(EAccept \leq 3.75 \cdot 10^{+115}\right) \land EAccept \leq 2.3 \cdot 10^{+147}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 5: 61.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ t_3 := \frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\ \mathbf{if}\;Vef \leq -3.9 \cdot 10^{+92}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;Vef \leq -5.1 \cdot 10^{-71}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;Vef \leq -4.2 \cdot 10^{-114}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;Vef \leq -1 \cdot 10^{-129}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;Vef \leq 3.2 \cdot 10^{-152}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq 5.3 \cdot 10^{-73}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;Vef \leq 2.4 \cdot 10^{+100}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 1.0 (exp (/ Vef KbT))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT)))))
        (t_3 (+ (/ NaChar t_0) (/ NdChar t_0))))
   (if (<= Vef -3.9e+92)
     t_3
     (if (<= Vef -5.1e-71)
       t_2
       (if (<= Vef -4.2e-114)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (* NdChar 0.5))
         (if (<= Vef -1e-129)
           (+
            (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
            (/ NaChar (+ 1.0 (/ Ev KbT))))
           (if (<= Vef 3.2e-152)
             t_1
             (if (<= Vef 5.3e-73) t_2 (if (<= Vef 2.4e+100) t_1 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 = 1.0 + exp((Vef / KbT));
	double t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double t_2 = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	double t_3 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -3.9e+92) {
		tmp = t_3;
	} else if (Vef <= -5.1e-71) {
		tmp = t_2;
	} else if (Vef <= -4.2e-114) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else if (Vef <= -1e-129) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (Ev / KbT)));
	} else if (Vef <= 3.2e-152) {
		tmp = t_1;
	} else if (Vef <= 5.3e-73) {
		tmp = t_2;
	} else if (Vef <= 2.4e+100) {
		tmp = t_1;
	} 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 = 1.0d0 + exp((vef / kbt))
    t_1 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    t_2 = ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))
    t_3 = (nachar / t_0) + (ndchar / t_0)
    if (vef <= (-3.9d+92)) then
        tmp = t_3
    else if (vef <= (-5.1d-71)) then
        tmp = t_2
    else if (vef <= (-4.2d-114)) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar * 0.5d0)
    else if (vef <= (-1d-129)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + (ev / kbt)))
    else if (vef <= 3.2d-152) then
        tmp = t_1
    else if (vef <= 5.3d-73) then
        tmp = t_2
    else if (vef <= 2.4d+100) then
        tmp = t_1
    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 = 1.0 + Math.exp((Vef / KbT));
	double t_1 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double t_2 = NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	double t_3 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -3.9e+92) {
		tmp = t_3;
	} else if (Vef <= -5.1e-71) {
		tmp = t_2;
	} else if (Vef <= -4.2e-114) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else if (Vef <= -1e-129) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (Ev / KbT)));
	} else if (Vef <= 3.2e-152) {
		tmp = t_1;
	} else if (Vef <= 5.3e-73) {
		tmp = t_2;
	} else if (Vef <= 2.4e+100) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	t_1 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	t_2 = NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))
	t_3 = (NaChar / t_0) + (NdChar / t_0)
	tmp = 0
	if Vef <= -3.9e+92:
		tmp = t_3
	elif Vef <= -5.1e-71:
		tmp = t_2
	elif Vef <= -4.2e-114:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5)
	elif Vef <= -1e-129:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (Ev / KbT)))
	elif Vef <= 3.2e-152:
		tmp = t_1
	elif Vef <= 5.3e-73:
		tmp = t_2
	elif Vef <= 2.4e+100:
		tmp = t_1
	else:
		tmp = t_3
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + exp(Float64(Vef / KbT)))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))))
	t_3 = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0))
	tmp = 0.0
	if (Vef <= -3.9e+92)
		tmp = t_3;
	elseif (Vef <= -5.1e-71)
		tmp = t_2;
	elseif (Vef <= -4.2e-114)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar * 0.5));
	elseif (Vef <= -1e-129)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Ev / KbT))));
	elseif (Vef <= 3.2e-152)
		tmp = t_1;
	elseif (Vef <= 5.3e-73)
		tmp = t_2;
	elseif (Vef <= 2.4e+100)
		tmp = t_1;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	t_2 = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	t_3 = (NaChar / t_0) + (NdChar / t_0);
	tmp = 0.0;
	if (Vef <= -3.9e+92)
		tmp = t_3;
	elseif (Vef <= -5.1e-71)
		tmp = t_2;
	elseif (Vef <= -4.2e-114)
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	elseif (Vef <= -1e-129)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + (Ev / KbT)));
	elseif (Vef <= 3.2e-152)
		tmp = t_1;
	elseif (Vef <= 5.3e-73)
		tmp = t_2;
	elseif (Vef <= 2.4e+100)
		tmp = t_1;
	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[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.9e+92], t$95$3, If[LessEqual[Vef, -5.1e-71], t$95$2, If[LessEqual[Vef, -4.2e-114], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -1e-129], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 3.2e-152], t$95$1, If[LessEqual[Vef, 5.3e-73], t$95$2, If[LessEqual[Vef, 2.4e+100], t$95$1, t$95$3]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if Vef < -3.90000000000000011e92 or 2.40000000000000012e100 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 90.0%

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

   5. Taylor expanded in Vef around inf 82.0%

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

   if -3.90000000000000011e92 < Vef < -5.1000000000000003e-71 or 3.20000000000000013e-152 < Vef < 5.29999999999999972e-73

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 49.5%

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

   5. Taylor expanded in Ev around inf 32.9%

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

      1. associate-/l* 30.5%

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

   7. Simplified 30.5%

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

   8. Taylor expanded in NdChar around inf 68.6%

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

   if -5.1000000000000003e-71 < Vef < -4.19999999999999985e-114

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 91.0%

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

   if -4.19999999999999985e-114 < Vef < -9.9999999999999993e-130

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.5%

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

   5. Taylor expanded in Ev around inf 81.0%

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

   if -9.9999999999999993e-130 < Vef < 3.20000000000000013e-152 or 5.29999999999999972e-73 < Vef < 2.40000000000000012e100

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 80.4%

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

   5. Taylor expanded in EDonor around inf 68.0%

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

4. Final simplification 73.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -3.9 \cdot 10^{+92}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq -5.1 \cdot 10^{-71}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq -4.2 \cdot 10^{-114}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;Vef \leq -1 \cdot 10^{-129}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;Vef \leq 3.2 \cdot 10^{-152}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 5.3 \cdot 10^{-73}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq 2.4 \cdot 10^{+100}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]

Alternative 6: 71.8% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -3.2e-96)
         (not
          (or (<= NaChar 2.55e-149)
              (and (not (<= NaChar 5e-27)) (<= NaChar 1.6e+18)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
   (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -3.2e-96) || !((NaChar <= 2.55e-149) || (!(NaChar <= 5e-27) && (NaChar <= 1.6e+18)))) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((nachar <= (-3.2d-96)) .or. (.not. (nachar <= 2.55d-149) .or. (.not. (nachar <= 5d-27)) .and. (nachar <= 1.6d+18))) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -3.2e-96) || !((NaChar <= 2.55e-149) || (!(NaChar <= 5e-27) && (NaChar <= 1.6e+18)))) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -3.2e-96) or not ((NaChar <= 2.55e-149) or (not (NaChar <= 5e-27) and (NaChar <= 1.6e+18))):
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NaChar <= -3.2e-96) || !((NaChar <= 2.55e-149) || (!(NaChar <= 5e-27) && (NaChar <= 1.6e+18))))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -3.2e-96) || ~(((NaChar <= 2.55e-149) || (~((NaChar <= 5e-27)) && (NaChar <= 1.6e+18)))))
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -3.20000000000000012e-96 or 2.54999999999999991e-149 < NaChar < 5.0000000000000002e-27 or 1.6e18 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 83.2%

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

   if -3.20000000000000012e-96 < NaChar < 2.54999999999999991e-149 or 5.0000000000000002e-27 < NaChar < 1.6e18

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 66.7%

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

   5. Taylor expanded in Ev around inf 55.9%

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

      1. associate-/l* 51.5%

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

   7. Simplified 51.5%

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

   8. Taylor expanded in NdChar around inf 86.1%

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

4. Final simplification 84.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3.2 \cdot 10^{-96} \lor \neg \left(NaChar \leq 2.55 \cdot 10^{-149} \lor \neg \left(NaChar \leq 5 \cdot 10^{-27}\right) \land NaChar \leq 1.6 \cdot 10^{+18}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 7: 72.5% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= NaChar -1.35e-96)
     t_0
     (if (<= NaChar 5.3e-148)
       (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))
       (if (<= NaChar 4.2e+179)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
         t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (NaChar <= -1.35e-96) {
		tmp = t_0;
	} else if (NaChar <= 5.3e-148) {
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	} else if (NaChar <= 4.2e+179) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if NaChar <= -1.35e-96:
		tmp = t_0
	elif NaChar <= 5.3e-148:
		tmp = NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))
	elif NaChar <= 4.2e+179:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (NaChar <= -1.35e-96)
		tmp = t_0;
	elseif (NaChar <= 5.3e-148)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))));
	elseif (NaChar <= 4.2e+179)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (NaChar <= -1.35e-96)
		tmp = t_0;
	elseif (NaChar <= 5.3e-148)
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	elseif (NaChar <= 4.2e+179)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.35e-96 or 4.1999999999999997e179 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 85.9%

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

   if -1.35e-96 < NaChar < 5.29999999999999995e-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. Taylor expanded in KbT around inf 67.0%

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

   5. Taylor expanded in Ev around inf 59.6%

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

      1. associate-/l* 53.8%

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

   7. Simplified 53.8%

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

   8. Taylor expanded in NdChar around inf 86.6%

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

   if 5.29999999999999995e-148 < NaChar < 4.1999999999999997e179

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 71.1%

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

4. Final simplification 82.0%

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

Alternative 8: 72.3% accurate, 1.0× speedup

Math

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

FPCore

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	tmp = 0.0
	if (NaChar <= -2.95e-96)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (NaChar <= 3.1e-149)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))));
	else
		tmp = Float64(t_0 + 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)
	t_0 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	tmp = 0.0;
	if (NaChar <= -2.95e-96)
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (NaChar <= 3.1e-149)
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	else
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.94999999999999983e-96

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 84.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}}} \]

   if -2.94999999999999983e-96 < NaChar < 3.09999999999999987e-149

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 66.5%

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

   5. Taylor expanded in Ev around inf 59.1%

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

      1. associate-/l* 53.9%

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

   7. Simplified 53.9%

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

   8. Taylor expanded in NdChar around inf 86.4%

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

   if 3.09999999999999987e-149 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 78.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}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 83.0%

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

Alternative 9: 61.1% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;NaChar \leq -3.8 \cdot 10^{+226}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -2.6 \cdot 10^{+207}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq -2.7 \cdot 10^{+158}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -7 \cdot 10^{+128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\frac{EAccept}{KbT} + \left(1 + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}\right)\right)}\\ \mathbf{elif}\;NaChar \leq -4.2 \cdot 10^{-96} \lor \neg \left(NaChar \leq 2.8 \cdot 10^{+193}\right):\\ \;\;\;\;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 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= NaChar -3.8e+226)
     t_1
     (if (<= NaChar -2.6e+207)
       t_0
       (if (<= NaChar -2.7e+158)
         t_1
         (if (<= NaChar -7e+128)
           (+
            (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
            (/
             NaChar
             (+
              1.0
              (+
               (/ EAccept KbT)
               (+ 1.0 (* 0.5 (/ (* EAccept EAccept) (* KbT KbT))))))))
           (if (or (<= NaChar -4.2e-96) (not (<= NaChar 2.8e+193)))
             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 = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -3.8e+226) {
		tmp = t_1;
	} else if (NaChar <= -2.6e+207) {
		tmp = t_0;
	} else if (NaChar <= -2.7e+158) {
		tmp = t_1;
	} else if (NaChar <= -7e+128) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((EAccept / KbT) + (1.0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))))));
	} else if ((NaChar <= -4.2e-96) || !(NaChar <= 2.8e+193)) {
		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 = ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar * 0.5d0)
    if (nachar <= (-3.8d+226)) then
        tmp = t_1
    else if (nachar <= (-2.6d+207)) then
        tmp = t_0
    else if (nachar <= (-2.7d+158)) then
        tmp = t_1
    else if (nachar <= (-7d+128)) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + ((eaccept / kbt) + (1.0d0 + (0.5d0 * ((eaccept * eaccept) / (kbt * kbt)))))))
    else if ((nachar <= (-4.2d-96)) .or. (.not. (nachar <= 2.8d+193))) 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 = NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -3.8e+226) {
		tmp = t_1;
	} else if (NaChar <= -2.6e+207) {
		tmp = t_0;
	} else if (NaChar <= -2.7e+158) {
		tmp = t_1;
	} else if (NaChar <= -7e+128) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((EAccept / KbT) + (1.0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))))));
	} else if ((NaChar <= -4.2e-96) || !(NaChar <= 2.8e+193)) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if NaChar <= -3.8e+226:
		tmp = t_1
	elif NaChar <= -2.6e+207:
		tmp = t_0
	elif NaChar <= -2.7e+158:
		tmp = t_1
	elif NaChar <= -7e+128:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((EAccept / KbT) + (1.0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))))))
	elif (NaChar <= -4.2e-96) or not (NaChar <= 2.8e+193):
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (NaChar <= -3.8e+226)
		tmp = t_1;
	elseif (NaChar <= -2.6e+207)
		tmp = t_0;
	elseif (NaChar <= -2.7e+158)
		tmp = t_1;
	elseif (NaChar <= -7e+128)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(1.0 + Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT))))))));
	elseif ((NaChar <= -4.2e-96) || !(NaChar <= 2.8e+193))
		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 = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (NaChar <= -3.8e+226)
		tmp = t_1;
	elseif (NaChar <= -2.6e+207)
		tmp = t_0;
	elseif (NaChar <= -2.7e+158)
		tmp = t_1;
	elseif (NaChar <= -7e+128)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + ((EAccept / KbT) + (1.0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))))));
	elseif ((NaChar <= -4.2e-96) || ~((NaChar <= 2.8e+193)))
		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[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -3.8e+226], t$95$1, If[LessEqual[NaChar, -2.6e+207], t$95$0, If[LessEqual[NaChar, -2.7e+158], t$95$1, If[LessEqual[NaChar, -7e+128], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(1.0 + N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, -4.2e-96], N[Not[LessEqual[NaChar, 2.8e+193]], $MachinePrecision]], t$95$1, t$95$0]]]]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -3.79999999999999983e226 or -2.5999999999999998e207 < NaChar < -2.69999999999999979e158 or -6.99999999999999937e128 < NaChar < -4.20000000000000002e-96 or 2.79999999999999986e193 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 75.6%

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

   if -3.79999999999999983e226 < NaChar < -2.5999999999999998e207 or -4.20000000000000002e-96 < NaChar < 2.79999999999999986e193

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 59.4%

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

   5. Taylor expanded in Ev around inf 40.9%

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

      1. associate-/l* 38.6%

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

   7. Simplified 38.6%

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

   8. Taylor expanded in NdChar around inf 75.4%

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

   if -2.69999999999999979e158 < NaChar < -6.99999999999999937e128

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 68.4%

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

   5. Taylor expanded in EAccept around 0 59.1%

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

      1. unpow2 59.1%

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

      2. unpow2 59.1%

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

   7. Simplified 59.1%

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

4. Final simplification 74.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3.8 \cdot 10^{+226}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq -2.6 \cdot 10^{+207}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -2.7 \cdot 10^{+158}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq -7 \cdot 10^{+128}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\frac{EAccept}{KbT} + \left(1 + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}\right)\right)}\\ \mathbf{elif}\;NaChar \leq -4.2 \cdot 10^{-96} \lor \neg \left(NaChar \leq 2.8 \cdot 10^{+193}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 10: 61.5% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -2.5 \cdot 10^{+226} \lor \neg \left(NaChar \leq -3.6 \cdot 10^{+207} \lor \neg \left(NaChar \leq -9.2 \cdot 10^{-95}\right) \land NaChar \leq 1.95 \cdot 10^{+191}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -2.5e+226)
         (not
          (or (<= NaChar -3.6e+207)
              (and (not (<= NaChar -9.2e-95)) (<= NaChar 1.95e+191)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (* NdChar 0.5))
   (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -2.5e+226) || !((NaChar <= -3.6e+207) || (!(NaChar <= -9.2e-95) && (NaChar <= 1.95e+191)))) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((nachar <= (-2.5d+226)) .or. (.not. (nachar <= (-3.6d+207)) .or. (.not. (nachar <= (-9.2d-95))) .and. (nachar <= 1.95d+191))) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar * 0.5d0)
    else
        tmp = ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -2.5e+226) || !((NaChar <= -3.6e+207) || (!(NaChar <= -9.2e-95) && (NaChar <= 1.95e+191)))) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -2.5e+226) or not ((NaChar <= -3.6e+207) or (not (NaChar <= -9.2e-95) and (NaChar <= 1.95e+191))):
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5)
	else:
		tmp = NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NaChar <= -2.5e+226) || !((NaChar <= -3.6e+207) || (!(NaChar <= -9.2e-95) && (NaChar <= 1.95e+191))))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar * 0.5));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -2.5e+226) || ~(((NaChar <= -3.6e+207) || (~((NaChar <= -9.2e-95)) && (NaChar <= 1.95e+191)))))
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar * 0.5);
	else
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -2.5e+226], N[Not[Or[LessEqual[NaChar, -3.6e+207], And[N[Not[LessEqual[NaChar, -9.2e-95]], $MachinePrecision], LessEqual[NaChar, 1.95e+191]]]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.5000000000000002e226 or -3.60000000000000014e207 < NaChar < -9.19999999999999997e-95 or 1.95e191 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 71.1%

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

   if -2.5000000000000002e226 < NaChar < -3.60000000000000014e207 or -9.19999999999999997e-95 < NaChar < 1.95e191

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 59.4%

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

   5. Taylor expanded in Ev around inf 40.9%

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

      1. associate-/l* 38.6%

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

   7. Simplified 38.6%

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

   8. Taylor expanded in NdChar around inf 75.4%

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

4. Final simplification 73.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.5 \cdot 10^{+226} \lor \neg \left(NaChar \leq -3.6 \cdot 10^{+207} \lor \neg \left(NaChar \leq -9.2 \cdot 10^{-95}\right) \land NaChar \leq 1.95 \cdot 10^{+191}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 11: 61.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+209} \lor \neg \left(KbT \leq -2.95 \cdot 10^{+88}\right) \land KbT \leq -7.8 \cdot 10^{+54}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \end{array} \]

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -9.2e+209) or (not (KbT <= -2.95e+88) and (KbT <= -7.8e+54)):
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5)
	else:
		tmp = NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -9.2e+209) || (!(KbT <= -2.95e+88) && (KbT <= -7.8e+54)))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -9.2e+209) || (~((KbT <= -2.95e+88)) && (KbT <= -7.8e+54)))
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	else
		tmp = NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -9.2e+209], And[N[Not[LessEqual[KbT, -2.95e+88]], $MachinePrecision], LessEqual[KbT, -7.8e+54]]], 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[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -9.20000000000000038e209 or -2.94999999999999984e88 < KbT < -7.8000000000000005e54

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 78.6%

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

   5. Taylor expanded in KbT around inf 68.5%

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

   if -9.20000000000000038e209 < KbT < -2.94999999999999984e88 or -7.8000000000000005e54 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 49.3%

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

   5. Taylor expanded in Ev around inf 33.0%

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

      1. associate-/l* 31.4%

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

   7. Simplified 31.4%

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

   8. Taylor expanded in NdChar around inf 63.2%

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

4. Final simplification 63.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+209} \lor \neg \left(KbT \leq -2.95 \cdot 10^{+88}\right) \land KbT \leq -7.8 \cdot 10^{+54}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 12: 36.1% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq -2 \cdot 10^{-235}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 3 \cdot 10^{-81}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{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 -2e-235)
   (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
   (if (<= EAccept 3e-81)
     (+ (/ NaChar (+ 1.0 (exp (/ Vef 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 <= -2e-235) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (EAccept <= 3e-81) {
		tmp = (NaChar / (1.0 + exp((Vef / 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 <= (-2d-235)) then
        tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (eaccept <= 3d-81) then
        tmp = (nachar / (1.0d0 + exp((vef / 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 <= -2e-235) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (EAccept <= 3e-81) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / 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 <= -2e-235:
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif EAccept <= 3e-81:
		tmp = (NaChar / (1.0 + math.exp((Vef / 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 <= -2e-235)
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (EAccept <= 3e-81)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / 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 <= -2e-235)
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (EAccept <= 3e-81)
		tmp = (NaChar / (1.0 + exp((Vef / 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, -2e-235], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3e-81], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / 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 3 regimes

2. if EAccept < -1.9999999999999999e-235

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 40.3%

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

   5. Taylor expanded in Ev around inf 31.7%

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

   if -1.9999999999999999e-235 < EAccept < 2.9999999999999999e-81

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 53.4%

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

   5. Taylor expanded in Vef around inf 46.1%

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

   if 2.9999999999999999e-81 < 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. Taylor expanded in EAccept around inf 86.5%

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

   5. Taylor expanded in KbT around inf 51.0%

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

4. Final simplification 42.1%

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

Alternative 13: 36.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 2.15 \cdot 10^{-230}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.85 \cdot 10^{+39}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \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 2.15e-230)
   (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
   (if (<= EAccept 1.85e+39)
     (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 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 <= 2.15e-230) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (EAccept <= 1.85e+39) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 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 <= 2.15d-230) then
        tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (eaccept <= 1.85d+39) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar * 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 <= 2.15e-230) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (EAccept <= 1.85e+39) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar * 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 <= 2.15e-230:
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif EAccept <= 1.85e+39:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar * 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 <= 2.15e-230)
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (EAccept <= 1.85e+39)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar * 0.5));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(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 <= 2.15e-230)
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (EAccept <= 1.85e+39)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 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, 2.15e-230], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.85e+39], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if EAccept < 2.15e-230

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 42.6%

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

   5. Taylor expanded in Ev around inf 34.6%

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

   if 2.15e-230 < EAccept < 1.85000000000000006e39

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 64.5%

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

   5. Taylor expanded in EDonor around inf 54.1%

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

   6. Taylor expanded in EAccept around 0 40.8%

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

   if 1.85000000000000006e39 < 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. Taylor expanded in EAccept around inf 91.1%

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

   5. Taylor expanded in KbT around inf 53.5%

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

4. Final simplification 40.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 2.15 \cdot 10^{-230}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.85 \cdot 10^{+39}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 14: 36.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 1.25 \cdot 10^{-277}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.8 \cdot 10^{+46}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{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 1.25e-277)
   (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
   (if (<= EAccept 1.8e+46)
     (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 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 <= 1.25e-277) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (EAccept <= 1.8e+46) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 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 <= 1.25d-277) then
        tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (eaccept <= 1.8d+46) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / 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 <= 1.25e-277) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (EAccept <= 1.8e+46) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 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 <= 1.25e-277:
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif EAccept <= 1.8e+46:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 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 <= 1.25e-277)
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (EAccept <= 1.8e+46)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / 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 <= 1.25e-277)
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (EAccept <= 1.8e+46)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 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, 1.25e-277], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.8e+46], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $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 < 1.25e-277

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 40.6%

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

   5. Taylor expanded in Ev around inf 32.5%

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

   if 1.25e-277 < EAccept < 1.7999999999999999e46

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 84.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}}} \]

   5. Taylor expanded in KbT around inf 45.5%

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

   if 1.7999999999999999e46 < 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. Taylor expanded in EAccept around inf 91.0%

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

   5. Taylor expanded in KbT around inf 52.8%

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

4. Final simplification 41.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 1.25 \cdot 10^{-277}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.8 \cdot 10^{+46}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 15: 36.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 4.8 \cdot 10^{-112}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \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 4.8e-112)
   (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
   (+ (/ 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 <= 4.8e-112) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
	} 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 <= 4.8d-112) then
        tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((ev / kbt))))
    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 <= 4.8e-112) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} 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 <= 4.8e-112:
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	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 <= 4.8e-112)
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	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 <= 4.8e-112)
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
	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, 4.8e-112], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $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 2 regimes

2. if EAccept < 4.8000000000000001e-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. Taylor expanded in KbT around inf 45.1%

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

   5. Taylor expanded in Ev around inf 35.6%

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

   if 4.8000000000000001e-112 < 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. Taylor expanded in EAccept around inf 84.3%

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

   5. Taylor expanded in KbT around inf 50.0%

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

4. Final simplification 41.0%

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

Alternative 16: 35.2% accurate, 2.1× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+ (/ 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) {
	return (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in EAccept around inf 71.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}}}} \]

5. Taylor expanded in KbT around inf 38.1%

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

6. Final simplification 38.1%

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

Alternative 17: 27.0% accurate, 25.3× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -1.3499999999999999e225

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 48.2%

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

   5. Taylor expanded in mu around inf 47.9%

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

      1. mul-1-neg 47.9%

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

      2. associate-/l* 38.5%

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

   7. Simplified 38.5%

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

   8. Taylor expanded in KbT around inf 4.5%

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

   9. Taylor expanded in NdChar around 0 40.5%

      \[\leadsto \color{blue}{-1 \cdot \frac{NaChar \cdot KbT}{mu}} \]

   if -1.3499999999999999e225 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.4%

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

   5. Taylor expanded in Vef around inf 35.9%

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

   6. Taylor expanded in Vef around 0 29.7%

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

4. Final simplification 30.2%

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

Alternative 18: 7.0% accurate, 38.2× speedup

Math

\[\begin{array}{l} \\ KbT \cdot \frac{-NaChar}{mu} \end{array} \]

FPCore

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

C

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

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 = kbt * (-nachar / mu)
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 KbT * (-NaChar / mu);
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 51.2%

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

5. Taylor expanded in mu around inf 31.4%

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

   1. mul-1-neg 31.4%

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

   2. associate-/l* 30.2%

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

7. Simplified 30.2%

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

8. Taylor expanded in KbT around inf 8.8%

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

9. Taylor expanded in NdChar around 0 9.7%

   \[\leadsto \color{blue}{-1 \cdot \frac{NaChar \cdot KbT}{mu}} \]
10. Step-by-step derivation

    1. associate-*l/ 8.9%

       \[\leadsto -1 \cdot \color{blue}{\left(\frac{NaChar}{mu} \cdot KbT\right)} \]

    2. neg-mul-1 8.9%

       \[\leadsto \color{blue}{-\frac{NaChar}{mu} \cdot KbT} \]

    3. *-commutative 8.9%

       \[\leadsto -\color{blue}{KbT \cdot \frac{NaChar}{mu}} \]

    4. distribute-rgt-neg-in 8.9%

       \[\leadsto \color{blue}{KbT \cdot \left(-\frac{NaChar}{mu}\right)} \]

    5. distribute-frac-neg 8.9%

       \[\leadsto KbT \cdot \color{blue}{\frac{-NaChar}{mu}} \]

11. Simplified 8.9%

    \[\leadsto \color{blue}{KbT \cdot \frac{-NaChar}{mu}} \]

12. Final simplification 8.9%

    \[\leadsto KbT \cdot \frac{-NaChar}{mu} \]

Alternative 19: 7.6% accurate, 38.2× speedup

Math

\[\begin{array}{l} \\ \frac{KbT \cdot \left(-NaChar\right)}{mu} \end{array} \]

FPCore

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

C

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

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 = (kbt * -nachar) / mu
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 (KbT * -NaChar) / mu;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 51.2%

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

5. Taylor expanded in mu around inf 31.4%

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

   1. mul-1-neg 31.4%

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

   2. associate-/l* 30.2%

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

7. Simplified 30.2%

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

8. Taylor expanded in KbT around inf 8.8%

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

9. Taylor expanded in NdChar around 0 9.7%

   \[\leadsto \color{blue}{-1 \cdot \frac{NaChar \cdot KbT}{mu}} \]

10. Final simplification 9.7%

    \[\leadsto \frac{KbT \cdot \left(-NaChar\right)}{mu} \]

Reproduce

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