Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 32.3s

Alternatives: 23

Speedup: 1.0×

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Final simplification 100.0%

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

Alternative 2: 70.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;NdChar \leq -1.55 \cdot 10^{+96}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -2.05 \cdot 10^{-29}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq -4.7 \cdot 10^{-90}:\\ \;\;\;\;t_0 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 5.3 \cdot 10^{-84}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq 0.092:\\ \;\;\;\;t_0 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.2 \cdot 10^{+57}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ (- Vef Ec) (+ EDonor mu)) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ Vef mu)) Ec) KbT)))))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= NdChar -1.55e+96)
     t_1
     (if (<= NdChar -2.05e-29)
       t_2
       (if (<= NdChar -4.7e-90)
         (+
          t_0
          (/ NaChar (- (+ 2.0 (+ (/ EAccept KbT) (/ Vef KbT))) (/ mu KbT))))
         (if (<= NdChar 5.3e-84)
           t_2
           (if (<= NdChar 0.092)
             (+
              t_0
              (/
               NaChar
               (-
                (+
                 2.0
                 (+
                  (/ EAccept KbT)
                  (/ (/ (+ (* KbT Ev) (* Vef KbT)) KbT) KbT)))
                (/ mu KbT))))
             (if (<= NdChar 2.2e+57) t_2 t_1))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((Vef - Ec) + (EDonor + mu)) / KbT)));
	double t_1 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double t_2 = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (NdChar <= -1.55e+96) {
		tmp = t_1;
	} else if (NdChar <= -2.05e-29) {
		tmp = t_2;
	} else if (NdChar <= -4.7e-90) {
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	} else if (NdChar <= 5.3e-84) {
		tmp = t_2;
	} else if (NdChar <= 0.092) {
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (NdChar <= 2.2e+57) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((vef - ec) + (edonor + mu)) / kbt)))
    t_1 = ndchar / (1.0d0 + exp((((edonor + (vef + mu)) - ec) / kbt)))
    t_2 = (nachar / (1.0d0 + exp((((eaccept - mu) + (vef + ev)) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (ndchar <= (-1.55d+96)) then
        tmp = t_1
    else if (ndchar <= (-2.05d-29)) then
        tmp = t_2
    else if (ndchar <= (-4.7d-90)) then
        tmp = t_0 + (nachar / ((2.0d0 + ((eaccept / kbt) + (vef / kbt))) - (mu / kbt)))
    else if (ndchar <= 5.3d-84) then
        tmp = t_2
    else if (ndchar <= 0.092d0) then
        tmp = t_0 + (nachar / ((2.0d0 + ((eaccept / kbt) + ((((kbt * ev) + (vef * kbt)) / kbt) / kbt))) - (mu / kbt)))
    else if (ndchar <= 2.2d+57) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((Vef - Ec) + (EDonor + mu)) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double t_2 = (NaChar / (1.0 + Math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (NdChar <= -1.55e+96) {
		tmp = t_1;
	} else if (NdChar <= -2.05e-29) {
		tmp = t_2;
	} else if (NdChar <= -4.7e-90) {
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	} else if (NdChar <= 5.3e-84) {
		tmp = t_2;
	} else if (NdChar <= 0.092) {
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (NdChar <= 2.2e+57) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((Vef - Ec) + (EDonor + mu)) / KbT)))
	t_1 = NdChar / (1.0 + math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)))
	t_2 = (NaChar / (1.0 + math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if NdChar <= -1.55e+96:
		tmp = t_1
	elif NdChar <= -2.05e-29:
		tmp = t_2
	elif NdChar <= -4.7e-90:
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)))
	elif NdChar <= 5.3e-84:
		tmp = t_2
	elif NdChar <= 0.092:
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)))
	elif NdChar <= 2.2e+57:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef - Ec) + Float64(EDonor + mu)) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(Vef + mu)) - Ec) / KbT))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept - mu) + Float64(Vef + Ev)) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (NdChar <= -1.55e+96)
		tmp = t_1;
	elseif (NdChar <= -2.05e-29)
		tmp = t_2;
	elseif (NdChar <= -4.7e-90)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Vef / KbT))) - Float64(mu / KbT))));
	elseif (NdChar <= 5.3e-84)
		tmp = t_2;
	elseif (NdChar <= 0.092)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Float64(Float64(KbT * Ev) + Float64(Vef * KbT)) / KbT) / KbT))) - Float64(mu / KbT))));
	elseif (NdChar <= 2.2e+57)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((Vef - Ec) + (EDonor + mu)) / KbT)));
	t_1 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	t_2 = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (NdChar <= -1.55e+96)
		tmp = t_1;
	elseif (NdChar <= -2.05e-29)
		tmp = t_2;
	elseif (NdChar <= -4.7e-90)
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	elseif (NdChar <= 5.3e-84)
		tmp = t_2;
	elseif (NdChar <= 0.092)
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	elseif (NdChar <= 2.2e+57)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef - Ec), $MachinePrecision] + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept - mu), $MachinePrecision] + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.55e+96], t$95$1, If[LessEqual[NdChar, -2.05e-29], t$95$2, If[LessEqual[NdChar, -4.7e-90], N[(t$95$0 + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 5.3e-84], t$95$2, If[LessEqual[NdChar, 0.092], N[(t$95$0 + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(N[(N[(KbT * Ev), $MachinePrecision] + N[(Vef * KbT), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.2e+57], t$95$2, t$95$1]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -1.5499999999999999e96 or 2.2000000000000001e57 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 63.9%

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

   5. Taylor expanded in Ev around inf 51.0%

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

   6. Taylor expanded in NdChar around inf 81.4%

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

   if -1.5499999999999999e96 < NdChar < -2.0499999999999999e-29 or -4.7e-90 < NdChar < 5.3000000000000004e-84 or 0.091999999999999998 < NdChar < 2.2000000000000001e57

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 82.6%

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

   if -2.0499999999999999e-29 < NdChar < -4.7e-90

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 86.4%

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

   5. Taylor expanded in Ev around 0 86.6%

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

   if 5.3000000000000004e-84 < NdChar < 0.091999999999999998

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 79.9%

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

      1. frac-add 77.8%

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

      2. associate-/r* 93.2%

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

      3. *-commutative 93.2%

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

   6. Applied egg-rr 93.2%

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

4. Final simplification 82.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -1.55 \cdot 10^{+96}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.05 \cdot 10^{-29}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -4.7 \cdot 10^{-90}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 5.3 \cdot 10^{-84}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 0.092:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.2 \cdot 10^{+57}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 3: 67.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{if}\;NdChar \leq -1.5 \cdot 10^{+39}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -2800000:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -7 \cdot 10^{-26}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.3 \cdot 10^{-150}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 1.6 \cdot 10^{-86}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NdChar \leq 4.6 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.35 \cdot 10^{+55}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT))))
          (/ NdChar (+ 2.0 (/ Vef KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ Vef mu)) Ec) KbT))))))
   (if (<= NdChar -1.5e+39)
     t_1
     (if (<= NdChar -2800000.0)
       (+
        (/ NdChar (+ 1.0 (exp (/ mu KbT))))
        (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
       (if (<= NdChar -7e-26)
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))
         (if (<= NdChar -2.3e-150)
           (+
            (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))
            (/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))
           (if (<= NdChar 1.6e-86)
             t_0
             (if (<= NdChar 4.6e+15)
               (+
                (/ NdChar (+ 1.0 (exp (/ (+ (- Vef Ec) (+ EDonor mu)) KbT))))
                (/
                 NaChar
                 (-
                  (+
                   2.0
                   (+
                    (/ EAccept KbT)
                    (/ (/ (+ (* KbT Ev) (* Vef KbT)) KbT) KbT)))
                  (/ mu KbT))))
               (if (<= NdChar 2.35e+55) t_0 t_1)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (2.0 + (Vef / KbT)));
	double t_1 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double tmp;
	if (NdChar <= -1.5e+39) {
		tmp = t_1;
	} else if (NdChar <= -2800000.0) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	} else if (NdChar <= -7e-26) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((Vef / KbT))));
	} else if (NdChar <= -2.3e-150) {
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	} else if (NdChar <= 1.6e-86) {
		tmp = t_0;
	} else if (NdChar <= 4.6e+15) {
		tmp = (NdChar / (1.0 + exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (NdChar <= 2.35e+55) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((((eaccept - mu) + (vef + ev)) / kbt)))) + (ndchar / (2.0d0 + (vef / kbt)))
    t_1 = ndchar / (1.0d0 + exp((((edonor + (vef + mu)) - ec) / kbt)))
    if (ndchar <= (-1.5d+39)) then
        tmp = t_1
    else if (ndchar <= (-2800000.0d0)) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    else if (ndchar <= (-7d-26)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((vef / kbt))))
    else if (ndchar <= (-2.3d-150)) then
        tmp = (ndchar / (1.0d0 + exp((-ec / kbt)))) + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
    else if (ndchar <= 1.6d-86) then
        tmp = t_0
    else if (ndchar <= 4.6d+15) then
        tmp = (ndchar / (1.0d0 + exp((((vef - ec) + (edonor + mu)) / kbt)))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((((kbt * ev) + (vef * kbt)) / kbt) / kbt))) - (mu / kbt)))
    else if (ndchar <= 2.35d+55) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (2.0 + (Vef / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double tmp;
	if (NdChar <= -1.5e+39) {
		tmp = t_1;
	} else if (NdChar <= -2800000.0) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	} else if (NdChar <= -7e-26) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	} else if (NdChar <= -2.3e-150) {
		tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
	} else if (NdChar <= 1.6e-86) {
		tmp = t_0;
	} else if (NdChar <= 4.6e+15) {
		tmp = (NdChar / (1.0 + Math.exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (NdChar <= 2.35e+55) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (2.0 + (Vef / KbT)))
	t_1 = NdChar / (1.0 + math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)))
	tmp = 0
	if NdChar <= -1.5e+39:
		tmp = t_1
	elif NdChar <= -2800000.0:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	elif NdChar <= -7e-26:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((Vef / KbT))))
	elif NdChar <= -2.3e-150:
		tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT))))
	elif NdChar <= 1.6e-86:
		tmp = t_0
	elif NdChar <= 4.6e+15:
		tmp = (NdChar / (1.0 + math.exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)))
	elif NdChar <= 2.35e+55:
		tmp = t_0
	else:
		tmp = t_1
	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(Float64(EAccept - mu) + Float64(Vef + Ev)) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(Vef / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(Vef + mu)) - Ec) / KbT))))
	tmp = 0.0
	if (NdChar <= -1.5e+39)
		tmp = t_1;
	elseif (NdChar <= -2800000.0)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))));
	elseif (NdChar <= -7e-26)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	elseif (NdChar <= -2.3e-150)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)))));
	elseif (NdChar <= 1.6e-86)
		tmp = t_0;
	elseif (NdChar <= 4.6e+15)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef - Ec) + Float64(EDonor + mu)) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Float64(Float64(KbT * Ev) + Float64(Vef * KbT)) / KbT) / KbT))) - Float64(mu / KbT))));
	elseif (NdChar <= 2.35e+55)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (2.0 + (Vef / KbT)));
	t_1 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	tmp = 0.0;
	if (NdChar <= -1.5e+39)
		tmp = t_1;
	elseif (NdChar <= -2800000.0)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	elseif (NdChar <= -7e-26)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((Vef / KbT))));
	elseif (NdChar <= -2.3e-150)
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	elseif (NdChar <= 1.6e-86)
		tmp = t_0;
	elseif (NdChar <= 4.6e+15)
		tmp = (NdChar / (1.0 + exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	elseif (NdChar <= 2.35e+55)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept - mu), $MachinePrecision] + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.5e+39], t$95$1, If[LessEqual[NdChar, -2800000.0], 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], If[LessEqual[NdChar, -7e-26], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2.3e-150], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.6e-86], t$95$0, If[LessEqual[NdChar, 4.6e+15], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef - Ec), $MachinePrecision] + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(N[(N[(KbT * Ev), $MachinePrecision] + N[(Vef * KbT), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.35e+55], t$95$0, t$95$1]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if NdChar < -1.5e39 or 2.35e55 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 65.9%

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

   5. Taylor expanded in Ev around inf 50.6%

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

   6. Taylor expanded in NdChar around inf 82.0%

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

   if -1.5e39 < NdChar < -2.8e6

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 83.8%

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

   5. Taylor expanded in mu around inf 83.8%

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

      1. associate-*r/ 83.8%

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

      2. mul-1-neg 83.8%

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

   7. Simplified 83.8%

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

   if -2.8e6 < NdChar < -6.9999999999999997e-26

   1. Initial program 99.7%

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

   3. Simplified 99.7%

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

   4. Taylor expanded in EAccept around inf 71.2%

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

   5. Taylor expanded in Vef around inf 69.6%

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

   if -6.9999999999999997e-26 < NdChar < -2.30000000000000003e-150

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ec around inf 83.3%

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

      1. mul-1-neg 83.3%

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

      2. distribute-neg-frac 83.3%

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

   6. Simplified 83.3%

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

   7. Taylor expanded in EAccept around 0 83.3%

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

   if -2.30000000000000003e-150 < NdChar < 1.60000000000000003e-86 or 4.6e15 < NdChar < 2.35e55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 73.7%

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

   5. Taylor expanded in Vef around 0 73.5%

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

   if 1.60000000000000003e-86 < NdChar < 4.6e15

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 78.1%

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

      1. frac-add 76.4%

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

      2. associate-/r* 88.9%

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

      3. *-commutative 88.9%

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

   6. Applied egg-rr 88.9%

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

4. Final simplification 79.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -1.5 \cdot 10^{+39}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2800000:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -7 \cdot 10^{-26}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.3 \cdot 10^{-150}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 1.6 \cdot 10^{-86}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq 4.6 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.35 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 4: 73.7% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -5.6e+19) (not (<= NdChar 6e+55)))
   (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ Vef mu)) Ec) KbT))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT))))
    (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -5.6e19 or 6.00000000000000033e55 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 65.7%

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

   5. Taylor expanded in Ev around inf 51.0%

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

   6. Taylor expanded in NdChar around inf 81.2%

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

   if -5.6e19 < NdChar < 6.00000000000000033e55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 73.1%

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

4. Final simplification 77.0%

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

Alternative 5: 76.9% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= mu -2.7e+55) (not (<= mu 6.6e+150)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT))))
    (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ (- Vef Ec) (+ EDonor mu)) KbT))))
    (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((mu <= -2.7e+55) || !(mu <= 6.6e+150)) {
		tmp = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else {
		tmp = (NdChar / (1.0 + exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((mu <= -2.7e+55) || !(mu <= 6.6e+150)) {
		tmp = (NaChar / (1.0 + Math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else {
		tmp = (NdChar / (1.0 + Math.exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((mu <= -2.7e+55) || ~((mu <= 6.6e+150)))
		tmp = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	else
		tmp = (NdChar / (1.0 + exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if mu < -2.69999999999999977e55 or 6.59999999999999962e150 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 88.0%

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

   if -2.69999999999999977e55 < mu < 6.59999999999999962e150

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 78.1%

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

4. Final simplification 81.7%

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

Alternative 6: 65.6% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}}\\ t_3 := t_2 + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{if}\;NdChar \leq -2.9 \cdot 10^{+17}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -8.5 \cdot 10^{-30}:\\ \;\;\;\;t_2 + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -8 \cdot 10^{-149}:\\ \;\;\;\;t_0 + NaChar \cdot \frac{1}{\left(\frac{EAccept}{KbT} + 2\right) + \left(\left(Vef + Ev\right) \cdot \frac{1}{KbT} - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 5.2 \cdot 10^{-87}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;NdChar \leq 6 \cdot 10^{+15}:\\ \;\;\;\;t_0 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 4.85 \cdot 10^{+55}:\\ \;\;\;\;t_3\\ \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 (/ (+ (- Vef Ec) (+ EDonor mu)) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ Vef mu)) Ec) KbT)))))
        (t_2 (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT)))))
        (t_3 (+ t_2 (/ NdChar (+ 2.0 (/ Vef KbT))))))
   (if (<= NdChar -2.9e+17)
     t_1
     (if (<= NdChar -8.5e-30)
       (+ t_2 (/ NdChar (+ (/ mu KbT) 2.0)))
       (if (<= NdChar -8e-149)
         (+
          t_0
          (*
           NaChar
           (/
            1.0
            (+
             (+ (/ EAccept KbT) 2.0)
             (- (* (+ Vef Ev) (/ 1.0 KbT)) (/ mu KbT))))))
         (if (<= NdChar 5.2e-87)
           t_3
           (if (<= NdChar 6e+15)
             (+
              t_0
              (/
               NaChar
               (-
                (+
                 2.0
                 (+
                  (/ EAccept KbT)
                  (/ (/ (+ (* KbT Ev) (* Vef KbT)) KbT) KbT)))
                (/ mu KbT))))
             (if (<= NdChar 4.85e+55) t_3 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((((Vef - Ec) + (EDonor + mu)) / KbT)));
	double t_1 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double t_2 = NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	double t_3 = t_2 + (NdChar / (2.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -2.9e+17) {
		tmp = t_1;
	} else if (NdChar <= -8.5e-30) {
		tmp = t_2 + (NdChar / ((mu / KbT) + 2.0));
	} else if (NdChar <= -8e-149) {
		tmp = t_0 + (NaChar * (1.0 / (((EAccept / KbT) + 2.0) + (((Vef + Ev) * (1.0 / KbT)) - (mu / KbT)))));
	} else if (NdChar <= 5.2e-87) {
		tmp = t_3;
	} else if (NdChar <= 6e+15) {
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (NdChar <= 4.85e+55) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((vef - ec) + (edonor + mu)) / kbt)))
    t_1 = ndchar / (1.0d0 + exp((((edonor + (vef + mu)) - ec) / kbt)))
    t_2 = nachar / (1.0d0 + exp((((eaccept - mu) + (vef + ev)) / kbt)))
    t_3 = t_2 + (ndchar / (2.0d0 + (vef / kbt)))
    if (ndchar <= (-2.9d+17)) then
        tmp = t_1
    else if (ndchar <= (-8.5d-30)) then
        tmp = t_2 + (ndchar / ((mu / kbt) + 2.0d0))
    else if (ndchar <= (-8d-149)) then
        tmp = t_0 + (nachar * (1.0d0 / (((eaccept / kbt) + 2.0d0) + (((vef + ev) * (1.0d0 / kbt)) - (mu / kbt)))))
    else if (ndchar <= 5.2d-87) then
        tmp = t_3
    else if (ndchar <= 6d+15) then
        tmp = t_0 + (nachar / ((2.0d0 + ((eaccept / kbt) + ((((kbt * ev) + (vef * kbt)) / kbt) / kbt))) - (mu / kbt)))
    else if (ndchar <= 4.85d+55) then
        tmp = t_3
    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((((Vef - Ec) + (EDonor + mu)) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double t_2 = NaChar / (1.0 + Math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	double t_3 = t_2 + (NdChar / (2.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -2.9e+17) {
		tmp = t_1;
	} else if (NdChar <= -8.5e-30) {
		tmp = t_2 + (NdChar / ((mu / KbT) + 2.0));
	} else if (NdChar <= -8e-149) {
		tmp = t_0 + (NaChar * (1.0 / (((EAccept / KbT) + 2.0) + (((Vef + Ev) * (1.0 / KbT)) - (mu / KbT)))));
	} else if (NdChar <= 5.2e-87) {
		tmp = t_3;
	} else if (NdChar <= 6e+15) {
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (NdChar <= 4.85e+55) {
		tmp = t_3;
	} 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((((Vef - Ec) + (EDonor + mu)) / KbT)))
	t_1 = NdChar / (1.0 + math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)))
	t_2 = NaChar / (1.0 + math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))
	t_3 = t_2 + (NdChar / (2.0 + (Vef / KbT)))
	tmp = 0
	if NdChar <= -2.9e+17:
		tmp = t_1
	elif NdChar <= -8.5e-30:
		tmp = t_2 + (NdChar / ((mu / KbT) + 2.0))
	elif NdChar <= -8e-149:
		tmp = t_0 + (NaChar * (1.0 / (((EAccept / KbT) + 2.0) + (((Vef + Ev) * (1.0 / KbT)) - (mu / KbT)))))
	elif NdChar <= 5.2e-87:
		tmp = t_3
	elif NdChar <= 6e+15:
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)))
	elif NdChar <= 4.85e+55:
		tmp = t_3
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef - Ec) + Float64(EDonor + mu)) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(Vef + mu)) - Ec) / KbT))))
	t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept - mu) + Float64(Vef + Ev)) / KbT))))
	t_3 = Float64(t_2 + Float64(NdChar / Float64(2.0 + Float64(Vef / KbT))))
	tmp = 0.0
	if (NdChar <= -2.9e+17)
		tmp = t_1;
	elseif (NdChar <= -8.5e-30)
		tmp = Float64(t_2 + Float64(NdChar / Float64(Float64(mu / KbT) + 2.0)));
	elseif (NdChar <= -8e-149)
		tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Float64(EAccept / KbT) + 2.0) + Float64(Float64(Float64(Vef + Ev) * Float64(1.0 / KbT)) - Float64(mu / KbT))))));
	elseif (NdChar <= 5.2e-87)
		tmp = t_3;
	elseif (NdChar <= 6e+15)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Float64(Float64(KbT * Ev) + Float64(Vef * KbT)) / KbT) / KbT))) - Float64(mu / KbT))));
	elseif (NdChar <= 4.85e+55)
		tmp = t_3;
	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((((Vef - Ec) + (EDonor + mu)) / KbT)));
	t_1 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	t_2 = NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	t_3 = t_2 + (NdChar / (2.0 + (Vef / KbT)));
	tmp = 0.0;
	if (NdChar <= -2.9e+17)
		tmp = t_1;
	elseif (NdChar <= -8.5e-30)
		tmp = t_2 + (NdChar / ((mu / KbT) + 2.0));
	elseif (NdChar <= -8e-149)
		tmp = t_0 + (NaChar * (1.0 / (((EAccept / KbT) + 2.0) + (((Vef + Ev) * (1.0 / KbT)) - (mu / KbT)))));
	elseif (NdChar <= 5.2e-87)
		tmp = t_3;
	elseif (NdChar <= 6e+15)
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	elseif (NdChar <= 4.85e+55)
		tmp = t_3;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef - Ec), $MachinePrecision] + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept - mu), $MachinePrecision] + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NdChar / N[(2.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -2.9e+17], t$95$1, If[LessEqual[NdChar, -8.5e-30], N[(t$95$2 + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -8e-149], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision] + N[(N[(N[(Vef + Ev), $MachinePrecision] * N[(1.0 / KbT), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 5.2e-87], t$95$3, If[LessEqual[NdChar, 6e+15], N[(t$95$0 + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(N[(N[(KbT * Ev), $MachinePrecision] + N[(Vef * KbT), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 4.85e+55], t$95$3, t$95$1]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if NdChar < -2.9e17 or 4.8500000000000003e55 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 65.9%

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

   5. Taylor expanded in Ev around inf 50.7%

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

   6. Taylor expanded in NdChar around inf 81.3%

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

   if -2.9e17 < NdChar < -8.49999999999999931e-30

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in mu around inf 89.9%

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

   5. Taylor expanded in mu around 0 71.1%

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

   if -8.49999999999999931e-30 < NdChar < -7.99999999999999983e-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{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) + \left(EAccept - mu\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 71.2%

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

      1. div-inv 71.2%

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

      2. *-commutative 71.2%

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

      3. associate-+r+ 71.2%

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

      4. associate--l+ 71.2%

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

      5. +-commutative 71.2%

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

      6. div-inv 71.2%

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

      7. div-inv 71.2%

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

      8. distribute-rgt-out 71.2%

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

   6. Applied egg-rr 71.2%

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

   if -7.99999999999999983e-149 < NdChar < 5.20000000000000005e-87 or 6e15 < NdChar < 4.8500000000000003e55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 73.7%

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

   5. Taylor expanded in Vef around 0 73.5%

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

   if 5.20000000000000005e-87 < NdChar < 6e15

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 78.1%

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

      1. frac-add 76.4%

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

      2. associate-/r* 88.9%

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

      3. *-commutative 88.9%

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

   6. Applied egg-rr 88.9%

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

4. Final simplification 77.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -2.9 \cdot 10^{+17}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -8.5 \cdot 10^{-30}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -8 \cdot 10^{-149}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + NaChar \cdot \frac{1}{\left(\frac{EAccept}{KbT} + 2\right) + \left(\left(Vef + Ev\right) \cdot \frac{1}{KbT} - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 5.2 \cdot 10^{-87}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq 6 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 4.85 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 7: 65.9% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}}\\ t_3 := t_2 + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{if}\;NdChar \leq -2.05 \cdot 10^{+15}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -6.5 \cdot 10^{-32}:\\ \;\;\;\;t_2 + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -3 \cdot 10^{-149}:\\ \;\;\;\;t_0 + NaChar \cdot \frac{1}{\left(\frac{EAccept}{KbT} + 2\right) + \left(\left(Vef + Ev\right) \cdot \frac{1}{KbT} - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 10^{-84}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;NdChar \leq 3.6 \cdot 10^{+15}:\\ \;\;\;\;t_0 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.7 \cdot 10^{+55}:\\ \;\;\;\;t_3\\ \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 (/ (+ (- Vef Ec) (+ EDonor mu)) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ Vef mu)) Ec) KbT)))))
        (t_2 (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT)))))
        (t_3 (+ t_2 (/ NdChar (+ 2.0 (/ Vef KbT))))))
   (if (<= NdChar -2.05e+15)
     t_1
     (if (<= NdChar -6.5e-32)
       (+ t_2 (/ NdChar (+ (/ mu KbT) 2.0)))
       (if (<= NdChar -3e-149)
         (+
          t_0
          (*
           NaChar
           (/
            1.0
            (+
             (+ (/ EAccept KbT) 2.0)
             (- (* (+ Vef Ev) (/ 1.0 KbT)) (/ mu KbT))))))
         (if (<= NdChar 1e-84)
           t_3
           (if (<= NdChar 3.6e+15)
             (+
              t_0
              (/
               NaChar
               (- (+ 2.0 (+ (/ EAccept KbT) (/ Vef KbT))) (/ mu KbT))))
             (if (<= NdChar 2.7e+55) t_3 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((((Vef - Ec) + (EDonor + mu)) / KbT)));
	double t_1 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double t_2 = NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	double t_3 = t_2 + (NdChar / (2.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -2.05e+15) {
		tmp = t_1;
	} else if (NdChar <= -6.5e-32) {
		tmp = t_2 + (NdChar / ((mu / KbT) + 2.0));
	} else if (NdChar <= -3e-149) {
		tmp = t_0 + (NaChar * (1.0 / (((EAccept / KbT) + 2.0) + (((Vef + Ev) * (1.0 / KbT)) - (mu / KbT)))));
	} else if (NdChar <= 1e-84) {
		tmp = t_3;
	} else if (NdChar <= 3.6e+15) {
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	} else if (NdChar <= 2.7e+55) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((vef - ec) + (edonor + mu)) / kbt)))
    t_1 = ndchar / (1.0d0 + exp((((edonor + (vef + mu)) - ec) / kbt)))
    t_2 = nachar / (1.0d0 + exp((((eaccept - mu) + (vef + ev)) / kbt)))
    t_3 = t_2 + (ndchar / (2.0d0 + (vef / kbt)))
    if (ndchar <= (-2.05d+15)) then
        tmp = t_1
    else if (ndchar <= (-6.5d-32)) then
        tmp = t_2 + (ndchar / ((mu / kbt) + 2.0d0))
    else if (ndchar <= (-3d-149)) then
        tmp = t_0 + (nachar * (1.0d0 / (((eaccept / kbt) + 2.0d0) + (((vef + ev) * (1.0d0 / kbt)) - (mu / kbt)))))
    else if (ndchar <= 1d-84) then
        tmp = t_3
    else if (ndchar <= 3.6d+15) then
        tmp = t_0 + (nachar / ((2.0d0 + ((eaccept / kbt) + (vef / kbt))) - (mu / kbt)))
    else if (ndchar <= 2.7d+55) then
        tmp = t_3
    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((((Vef - Ec) + (EDonor + mu)) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double t_2 = NaChar / (1.0 + Math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	double t_3 = t_2 + (NdChar / (2.0 + (Vef / KbT)));
	double tmp;
	if (NdChar <= -2.05e+15) {
		tmp = t_1;
	} else if (NdChar <= -6.5e-32) {
		tmp = t_2 + (NdChar / ((mu / KbT) + 2.0));
	} else if (NdChar <= -3e-149) {
		tmp = t_0 + (NaChar * (1.0 / (((EAccept / KbT) + 2.0) + (((Vef + Ev) * (1.0 / KbT)) - (mu / KbT)))));
	} else if (NdChar <= 1e-84) {
		tmp = t_3;
	} else if (NdChar <= 3.6e+15) {
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	} else if (NdChar <= 2.7e+55) {
		tmp = t_3;
	} 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((((Vef - Ec) + (EDonor + mu)) / KbT)))
	t_1 = NdChar / (1.0 + math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)))
	t_2 = NaChar / (1.0 + math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))
	t_3 = t_2 + (NdChar / (2.0 + (Vef / KbT)))
	tmp = 0
	if NdChar <= -2.05e+15:
		tmp = t_1
	elif NdChar <= -6.5e-32:
		tmp = t_2 + (NdChar / ((mu / KbT) + 2.0))
	elif NdChar <= -3e-149:
		tmp = t_0 + (NaChar * (1.0 / (((EAccept / KbT) + 2.0) + (((Vef + Ev) * (1.0 / KbT)) - (mu / KbT)))))
	elif NdChar <= 1e-84:
		tmp = t_3
	elif NdChar <= 3.6e+15:
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)))
	elif NdChar <= 2.7e+55:
		tmp = t_3
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef - Ec) + Float64(EDonor + mu)) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(Vef + mu)) - Ec) / KbT))))
	t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept - mu) + Float64(Vef + Ev)) / KbT))))
	t_3 = Float64(t_2 + Float64(NdChar / Float64(2.0 + Float64(Vef / KbT))))
	tmp = 0.0
	if (NdChar <= -2.05e+15)
		tmp = t_1;
	elseif (NdChar <= -6.5e-32)
		tmp = Float64(t_2 + Float64(NdChar / Float64(Float64(mu / KbT) + 2.0)));
	elseif (NdChar <= -3e-149)
		tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Float64(EAccept / KbT) + 2.0) + Float64(Float64(Float64(Vef + Ev) * Float64(1.0 / KbT)) - Float64(mu / KbT))))));
	elseif (NdChar <= 1e-84)
		tmp = t_3;
	elseif (NdChar <= 3.6e+15)
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Vef / KbT))) - Float64(mu / KbT))));
	elseif (NdChar <= 2.7e+55)
		tmp = t_3;
	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((((Vef - Ec) + (EDonor + mu)) / KbT)));
	t_1 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	t_2 = NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	t_3 = t_2 + (NdChar / (2.0 + (Vef / KbT)));
	tmp = 0.0;
	if (NdChar <= -2.05e+15)
		tmp = t_1;
	elseif (NdChar <= -6.5e-32)
		tmp = t_2 + (NdChar / ((mu / KbT) + 2.0));
	elseif (NdChar <= -3e-149)
		tmp = t_0 + (NaChar * (1.0 / (((EAccept / KbT) + 2.0) + (((Vef + Ev) * (1.0 / KbT)) - (mu / KbT)))));
	elseif (NdChar <= 1e-84)
		tmp = t_3;
	elseif (NdChar <= 3.6e+15)
		tmp = t_0 + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	elseif (NdChar <= 2.7e+55)
		tmp = t_3;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef - Ec), $MachinePrecision] + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept - mu), $MachinePrecision] + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NdChar / N[(2.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -2.05e+15], t$95$1, If[LessEqual[NdChar, -6.5e-32], N[(t$95$2 + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -3e-149], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision] + N[(N[(N[(Vef + Ev), $MachinePrecision] * N[(1.0 / KbT), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1e-84], t$95$3, If[LessEqual[NdChar, 3.6e+15], N[(t$95$0 + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.7e+55], t$95$3, t$95$1]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if NdChar < -2.05e15 or 2.69999999999999977e55 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 65.9%

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

   5. Taylor expanded in Ev around inf 50.7%

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

   6. Taylor expanded in NdChar around inf 81.3%

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

   if -2.05e15 < NdChar < -6.49999999999999988e-32

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in mu around inf 89.9%

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

   5. Taylor expanded in mu around 0 71.1%

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

   if -6.49999999999999988e-32 < NdChar < -3.0000000000000002e-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{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) + \left(EAccept - mu\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 71.2%

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

      1. div-inv 71.2%

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

      2. *-commutative 71.2%

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

      3. associate-+r+ 71.2%

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

      4. associate--l+ 71.2%

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

      5. +-commutative 71.2%

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

      6. div-inv 71.2%

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

      7. div-inv 71.2%

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

      8. distribute-rgt-out 71.2%

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

   6. Applied egg-rr 71.2%

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

   if -3.0000000000000002e-149 < NdChar < 1e-84 or 3.6e15 < NdChar < 2.69999999999999977e55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 73.7%

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

   5. Taylor expanded in Vef around 0 73.5%

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

   if 1e-84 < NdChar < 3.6e15

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 78.1%

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

   5. Taylor expanded in Ev around 0 75.1%

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

4. Final simplification 77.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -2.05 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -6.5 \cdot 10^{-32}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -3 \cdot 10^{-149}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + NaChar \cdot \frac{1}{\left(\frac{EAccept}{KbT} + 2\right) + \left(\left(Vef + Ev\right) \cdot \frac{1}{KbT} - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 10^{-84}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq 3.6 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.7 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 8: 65.8% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}}\\ t_2 := t_1 + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ t_3 := \frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{if}\;NdChar \leq -4.2 \cdot 10^{+15}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NdChar \leq -1.6 \cdot 10^{-30}:\\ \;\;\;\;t_1 + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -3.2 \cdot 10^{-143}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;NdChar \leq 1.05 \cdot 10^{-87}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq 6.6 \cdot 10^{+15}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;NdChar \leq 3.6 \cdot 10^{+55}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ Vef mu)) Ec) KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT)))))
        (t_2 (+ t_1 (/ NdChar (+ 2.0 (/ Vef KbT)))))
        (t_3
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ (- Vef Ec) (+ EDonor mu)) KbT))))
          (/ NaChar (- (+ 2.0 (+ (/ EAccept KbT) (/ Vef KbT))) (/ mu KbT))))))
   (if (<= NdChar -4.2e+15)
     t_0
     (if (<= NdChar -1.6e-30)
       (+ t_1 (/ NdChar (+ (/ mu KbT) 2.0)))
       (if (<= NdChar -3.2e-143)
         t_3
         (if (<= NdChar 1.05e-87)
           t_2
           (if (<= NdChar 6.6e+15) t_3 (if (<= NdChar 3.6e+55) t_2 t_0))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double t_1 = NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	double t_2 = t_1 + (NdChar / (2.0 + (Vef / KbT)));
	double t_3 = (NdChar / (1.0 + exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	double tmp;
	if (NdChar <= -4.2e+15) {
		tmp = t_0;
	} else if (NdChar <= -1.6e-30) {
		tmp = t_1 + (NdChar / ((mu / KbT) + 2.0));
	} else if (NdChar <= -3.2e-143) {
		tmp = t_3;
	} else if (NdChar <= 1.05e-87) {
		tmp = t_2;
	} else if (NdChar <= 6.6e+15) {
		tmp = t_3;
	} else if (NdChar <= 3.6e+55) {
		tmp = t_2;
	} 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) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (vef + mu)) - ec) / kbt)))
    t_1 = nachar / (1.0d0 + exp((((eaccept - mu) + (vef + ev)) / kbt)))
    t_2 = t_1 + (ndchar / (2.0d0 + (vef / kbt)))
    t_3 = (ndchar / (1.0d0 + exp((((vef - ec) + (edonor + mu)) / kbt)))) + (nachar / ((2.0d0 + ((eaccept / kbt) + (vef / kbt))) - (mu / kbt)))
    if (ndchar <= (-4.2d+15)) then
        tmp = t_0
    else if (ndchar <= (-1.6d-30)) then
        tmp = t_1 + (ndchar / ((mu / kbt) + 2.0d0))
    else if (ndchar <= (-3.2d-143)) then
        tmp = t_3
    else if (ndchar <= 1.05d-87) then
        tmp = t_2
    else if (ndchar <= 6.6d+15) then
        tmp = t_3
    else if (ndchar <= 3.6d+55) then
        tmp = t_2
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	double t_2 = t_1 + (NdChar / (2.0 + (Vef / KbT)));
	double t_3 = (NdChar / (1.0 + Math.exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	double tmp;
	if (NdChar <= -4.2e+15) {
		tmp = t_0;
	} else if (NdChar <= -1.6e-30) {
		tmp = t_1 + (NdChar / ((mu / KbT) + 2.0));
	} else if (NdChar <= -3.2e-143) {
		tmp = t_3;
	} else if (NdChar <= 1.05e-87) {
		tmp = t_2;
	} else if (NdChar <= 6.6e+15) {
		tmp = t_3;
	} else if (NdChar <= 3.6e+55) {
		tmp = t_2;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)))
	t_1 = NaChar / (1.0 + math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))
	t_2 = t_1 + (NdChar / (2.0 + (Vef / KbT)))
	t_3 = (NdChar / (1.0 + math.exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)))
	tmp = 0
	if NdChar <= -4.2e+15:
		tmp = t_0
	elif NdChar <= -1.6e-30:
		tmp = t_1 + (NdChar / ((mu / KbT) + 2.0))
	elif NdChar <= -3.2e-143:
		tmp = t_3
	elif NdChar <= 1.05e-87:
		tmp = t_2
	elif NdChar <= 6.6e+15:
		tmp = t_3
	elif NdChar <= 3.6e+55:
		tmp = t_2
	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(EDonor + Float64(Vef + mu)) - Ec) / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept - mu) + Float64(Vef + Ev)) / KbT))))
	t_2 = Float64(t_1 + Float64(NdChar / Float64(2.0 + Float64(Vef / KbT))))
	t_3 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef - Ec) + Float64(EDonor + mu)) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Vef / KbT))) - Float64(mu / KbT))))
	tmp = 0.0
	if (NdChar <= -4.2e+15)
		tmp = t_0;
	elseif (NdChar <= -1.6e-30)
		tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(mu / KbT) + 2.0)));
	elseif (NdChar <= -3.2e-143)
		tmp = t_3;
	elseif (NdChar <= 1.05e-87)
		tmp = t_2;
	elseif (NdChar <= 6.6e+15)
		tmp = t_3;
	elseif (NdChar <= 3.6e+55)
		tmp = t_2;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	t_1 = NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	t_2 = t_1 + (NdChar / (2.0 + (Vef / KbT)));
	t_3 = (NdChar / (1.0 + exp((((Vef - Ec) + (EDonor + mu)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + (Vef / KbT))) - (mu / KbT)));
	tmp = 0.0;
	if (NdChar <= -4.2e+15)
		tmp = t_0;
	elseif (NdChar <= -1.6e-30)
		tmp = t_1 + (NdChar / ((mu / KbT) + 2.0));
	elseif (NdChar <= -3.2e-143)
		tmp = t_3;
	elseif (NdChar <= 1.05e-87)
		tmp = t_2;
	elseif (NdChar <= 6.6e+15)
		tmp = t_3;
	elseif (NdChar <= 3.6e+55)
		tmp = t_2;
	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[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept - mu), $MachinePrecision] + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(2.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef - Ec), $MachinePrecision] + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -4.2e+15], t$95$0, If[LessEqual[NdChar, -1.6e-30], N[(t$95$1 + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -3.2e-143], t$95$3, If[LessEqual[NdChar, 1.05e-87], t$95$2, If[LessEqual[NdChar, 6.6e+15], t$95$3, If[LessEqual[NdChar, 3.6e+55], t$95$2, t$95$0]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -4.2e15 or 3.59999999999999987e55 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 65.9%

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

   5. Taylor expanded in Ev around inf 50.7%

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

   6. Taylor expanded in NdChar around inf 81.3%

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

   if -4.2e15 < NdChar < -1.6e-30

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in mu around inf 89.9%

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

   5. Taylor expanded in mu around 0 71.1%

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

   if -1.6e-30 < NdChar < -3.1999999999999998e-143 or 1.05000000000000004e-87 < NdChar < 6.6e15

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 73.5%

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

   5. Taylor expanded in Ev around 0 72.2%

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

   if -3.1999999999999998e-143 < NdChar < 1.05000000000000004e-87 or 6.6e15 < NdChar < 3.59999999999999987e55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 72.9%

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

   5. Taylor expanded in Vef around 0 72.7%

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

4. Final simplification 76.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -4.2 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -1.6 \cdot 10^{-30}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -3.2 \cdot 10^{-143}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 1.05 \cdot 10^{-87}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NdChar \leq 6.6 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 3.6 \cdot 10^{+55}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 9: 67.4% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -4.2e-71)
         (not
          (or (<= NdChar 7.2e-51)
              (and (not (<= NdChar 7.2e+15)) (<= NdChar 2.9e+55)))))
   (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ Vef mu)) Ec) KbT))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT))))
    (/ NdChar (+ 2.0 (/ Vef KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -4.2e-71) || !((NdChar <= 7.2e-51) || (!(NdChar <= 7.2e+15) && (NdChar <= 2.9e+55)))) {
		tmp = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (2.0 + (Vef / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((ndchar <= (-4.2d-71)) .or. (.not. (ndchar <= 7.2d-51) .or. (.not. (ndchar <= 7.2d+15)) .and. (ndchar <= 2.9d+55))) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (vef + mu)) - ec) / kbt)))
    else
        tmp = (nachar / (1.0d0 + exp((((eaccept - mu) + (vef + ev)) / kbt)))) + (ndchar / (2.0d0 + (vef / kbt)))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -4.2e-71) || !((NdChar <= 7.2e-51) || (!(NdChar <= 7.2e+15) && (NdChar <= 2.9e+55)))) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (2.0 + (Vef / KbT)));
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -4.2e-71) || !((NdChar <= 7.2e-51) || (!(NdChar <= 7.2e+15) && (NdChar <= 2.9e+55))))
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(Vef + mu)) - Ec) / KbT))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept - mu) + Float64(Vef + Ev)) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(Vef / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -4.2e-71) || ~(((NdChar <= 7.2e-51) || (~((NdChar <= 7.2e+15)) && (NdChar <= 2.9e+55)))))
		tmp = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	else
		tmp = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar / (2.0 + (Vef / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -4.2e-71], N[Not[Or[LessEqual[NdChar, 7.2e-51], And[N[Not[LessEqual[NdChar, 7.2e+15]], $MachinePrecision], LessEqual[NdChar, 2.9e+55]]]], $MachinePrecision]], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept - mu), $MachinePrecision] + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -4.2000000000000002e-71 or 7.2000000000000001e-51 < NdChar < 7.2e15 or 2.8999999999999999e55 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 65.5%

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

   5. Taylor expanded in Ev around inf 45.9%

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

   6. Taylor expanded in NdChar around inf 76.5%

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

   if -4.2000000000000002e-71 < NdChar < 7.2000000000000001e-51 or 7.2e15 < NdChar < 2.8999999999999999e55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 73.3%

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

   5. Taylor expanded in Vef around 0 72.1%

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

4. Final simplification 74.9%

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

Alternative 10: 63.7% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}}\\ \mathbf{if}\;NaChar \leq -8 \cdot 10^{+175}:\\ \;\;\;\;t_0 + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NaChar \leq 1.65 \cdot 10^{+24} \lor \neg \left(NaChar \leq 7.5 \cdot 10^{+219}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ (- EAccept mu) (+ Vef Ev)) KbT))))))
   (if (<= NaChar -8e+175)
     (+ t_0 (/ NdChar (+ 2.0 (/ Vef KbT))))
     (if (or (<= NaChar 1.65e+24) (not (<= NaChar 7.5e+219)))
       (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ Vef mu)) Ec) KbT))))
       (+ t_0 (/ NdChar (+ (/ mu KbT) 2.0)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	double tmp;
	if (NaChar <= -8e+175) {
		tmp = t_0 + (NdChar / (2.0 + (Vef / KbT)));
	} else if ((NaChar <= 1.65e+24) || !(NaChar <= 7.5e+219)) {
		tmp = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	} else {
		tmp = t_0 + (NdChar / ((mu / KbT) + 2.0));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))
	tmp = 0
	if NaChar <= -8e+175:
		tmp = t_0 + (NdChar / (2.0 + (Vef / KbT)))
	elif (NaChar <= 1.65e+24) or not (NaChar <= 7.5e+219):
		tmp = NdChar / (1.0 + math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)))
	else:
		tmp = t_0 + (NdChar / ((mu / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept - mu) + Float64(Vef + Ev)) / KbT))))
	tmp = 0.0
	if (NaChar <= -8e+175)
		tmp = Float64(t_0 + Float64(NdChar / Float64(2.0 + Float64(Vef / KbT))));
	elseif ((NaChar <= 1.65e+24) || !(NaChar <= 7.5e+219))
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(Vef + mu)) - Ec) / KbT))));
	else
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(mu / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)));
	tmp = 0.0;
	if (NaChar <= -8e+175)
		tmp = t_0 + (NdChar / (2.0 + (Vef / KbT)));
	elseif ((NaChar <= 1.65e+24) || ~((NaChar <= 7.5e+219)))
		tmp = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	else
		tmp = t_0 + (NdChar / ((mu / KbT) + 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept - mu), $MachinePrecision] + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -8e+175], N[(t$95$0 + N[(NdChar / N[(2.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, 1.65e+24], N[Not[LessEqual[NaChar, 7.5e+219]], $MachinePrecision]], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(Vef + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -7.9999999999999995e175

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 72.4%

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

   5. Taylor expanded in Vef around 0 72.5%

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

   if -7.9999999999999995e175 < NaChar < 1.6499999999999999e24 or 7.5000000000000006e219 < 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{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) + \left(EAccept - mu\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 62.4%

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

   5. Taylor expanded in Ev around inf 45.0%

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

   6. Taylor expanded in NdChar around inf 72.3%

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

   if 1.6499999999999999e24 < NaChar < 7.5000000000000006e219

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 87.4%

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

   5. Taylor expanded in mu around 0 75.0%

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

4. Final simplification 72.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -8 \cdot 10^{+175}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{2 + \frac{Vef}{KbT}}\\ \mathbf{elif}\;NaChar \leq 1.65 \cdot 10^{+24} \lor \neg \left(NaChar \leq 7.5 \cdot 10^{+219}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \end{array} \]

Alternative 11: 62.1% accurate, 1.9× speedup

Math

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -3.7e+175) or (not (NaChar <= 1.7e+24) and (NaChar <= 5e+214)):
		tmp = (NaChar / (1.0 + math.exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar * 0.5)
	else:
		tmp = NdChar / (1.0 + math.exp((((EDonor + (Vef + mu)) - Ec) / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NaChar <= -3.7e+175) || (!(NaChar <= 1.7e+24) && (NaChar <= 5e+214)))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept - mu) + Float64(Vef + Ev)) / KbT)))) + Float64(NdChar * 0.5));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(Vef + 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.7e+175) || (~((NaChar <= 1.7e+24)) && (NaChar <= 5e+214)))
		tmp = (NaChar / (1.0 + exp((((EAccept - mu) + (Vef + Ev)) / KbT)))) + (NdChar * 0.5);
	else
		tmp = NdChar / (1.0 + exp((((EDonor + (Vef + mu)) - Ec) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -3.69999999999999966e175 or 1.7e24 < NaChar < 4.99999999999999953e214

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Ec around inf 79.8%

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

      1. mul-1-neg 79.8%

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

      2. distribute-neg-frac 79.8%

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

   6. Simplified 79.8%

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

   7. Taylor expanded in Ec around 0 70.9%

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

      1. associate-*r/ 36.1%

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

      2. mul-1-neg 36.1%

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

   9. Simplified 70.9%

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

   10. Taylor expanded in Ec around 0 66.8%

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

   if -3.69999999999999966e175 < NaChar < 1.7e24 or 4.99999999999999953e214 < 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{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) + \left(EAccept - mu\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 62.4%

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

   5. Taylor expanded in Ev around inf 45.0%

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

   6. Taylor expanded in NdChar around inf 72.3%

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

4. Final simplification 71.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3.7 \cdot 10^{+175} \lor \neg \left(NaChar \leq 1.7 \cdot 10^{+24}\right) \land NaChar \leq 5 \cdot 10^{+214}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept - mu\right) + \left(Vef + Ev\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 12: 36.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -4.6 \cdot 10^{+132}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;Vef \leq -2.5 \cdot 10^{-70}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Vef \leq -5.4 \cdot 10^{-267}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;Vef \leq 2.8 \cdot 10^{-101}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Vef -4.6e+132)
   (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (/ NaChar 2.0))
   (if (<= Vef -2.5e-70)
     (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (if (<= Vef -5.4e-267)
       (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0))
       (if (<= Vef 2.8e-101)
         (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0))
         (+ (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))) (/ NaChar 2.0)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Vef <= -4.6e+132) {
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / 2.0);
	} else if (Vef <= -2.5e-70) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (Vef <= -5.4e-267) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	} else if (Vef <= 2.8e-101) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (vef <= (-4.6d+132)) then
        tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / 2.0d0)
    else if (vef <= (-2.5d-70)) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (vef <= (-5.4d-267)) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / 2.0d0)
    else if (vef <= 2.8d-101) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / 2.0d0)
    else
        tmp = (ndchar / (1.0d0 + exp((-ec / kbt)))) + (nachar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Vef <= -4.6e+132) {
		tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / 2.0);
	} else if (Vef <= -2.5e-70) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (Vef <= -5.4e-267) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 2.0);
	} else if (Vef <= 2.8e-101) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Vef <= -4.6e+132:
		tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / 2.0)
	elif Vef <= -2.5e-70:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif Vef <= -5.4e-267:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 2.0)
	elif Vef <= 2.8e-101:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0)
	else:
		tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Vef <= -4.6e+132)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / 2.0));
	elseif (Vef <= -2.5e-70)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (Vef <= -5.4e-267)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / 2.0));
	elseif (Vef <= 2.8e-101)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + Float64(NaChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Vef <= -4.6e+132)
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / 2.0);
	elseif (Vef <= -2.5e-70)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (Vef <= -5.4e-267)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	elseif (Vef <= 2.8e-101)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
	else
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Vef, -4.6e+132], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -2.5e-70], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -5.4e-267], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2.8e-101], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 5 regimes

2. if Vef < -4.6000000000000003e132

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 52.3%

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

   5. Taylor expanded in Vef around inf 43.9%

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

   if -4.6000000000000003e132 < Vef < -2.4999999999999999e-70

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 71.3%

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

   5. Taylor expanded in KbT around inf 36.1%

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

   if -2.4999999999999999e-70 < Vef < -5.39999999999999975e-267

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 59.6%

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

   5. Taylor expanded in mu around inf 53.8%

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

   if -5.39999999999999975e-267 < Vef < 2.79999999999999989e-101

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 72.3%

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

   5. Taylor expanded in KbT around inf 46.2%

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

   if 2.79999999999999989e-101 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 57.2%

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

   5. Taylor expanded in Ec around inf 45.9%

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

      1. mul-1-neg 45.9%

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

   7. Simplified 45.9%

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

4. Final simplification 44.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -4.6 \cdot 10^{+132}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;Vef \leq -2.5 \cdot 10^{-70}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Vef \leq -5.4 \cdot 10^{-267}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;Vef \leq 2.8 \cdot 10^{-101}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]

Alternative 13: 38.6% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.1 \cdot 10^{-64} \lor \neg \left(NaChar \leq 1.7 \cdot 10^{+24}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.1e-64) (not (<= NaChar 1.7e+24)))
   (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0))
   (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (/ NaChar 2.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.1e-64], N[Not[LessEqual[NaChar, 1.7e+24]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.1e-64 or 1.7e24 < 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{\left(Vef - Ec\right) + \left(EDonor + mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) + \left(EAccept - mu\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 65.5%

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

   5. Taylor expanded in KbT around inf 42.9%

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

   if -1.1e-64 < NaChar < 1.7e24

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.4%

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

   5. Taylor expanded in Vef around inf 42.7%

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

4. Final simplification 42.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.1 \cdot 10^{-64} \lor \neg \left(NaChar \leq 1.7 \cdot 10^{+24}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]

Alternative 14: 38.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -2.4 \cdot 10^{-65}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;NdChar \leq 1.6 \cdot 10^{-57}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -2.4e-65)
   (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0))
   (if (<= NdChar 1.6e-57)
     (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NdChar <= -2.4e-65)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	elseif (NdChar <= 1.6e-57)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((Ev / KbT))));
	else
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -2.4e-65], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.6e-57], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -2.4000000000000002e-65

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 63.9%

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

   5. Taylor expanded in mu around inf 48.0%

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

   if -2.4000000000000002e-65 < NdChar < 1.6e-57

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 63.8%

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

   5. Taylor expanded in KbT around inf 36.9%

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

   if 1.6e-57 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.2%

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

   5. Taylor expanded in EDonor around inf 37.0%

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

4. Final simplification 40.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -2.4 \cdot 10^{-65}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;NdChar \leq 1.6 \cdot 10^{-57}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \]

Alternative 15: 62.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -7.2 \cdot 10^{+154}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -7.2000000000000001e154

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 87.1%

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

   5. Taylor expanded in EDonor around inf 82.9%

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

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

   4. Taylor expanded in KbT around inf 53.6%

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

   5. Taylor expanded in Ev around inf 39.2%

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

   6. Taylor expanded in NdChar around inf 65.8%

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

4. Final simplification 68.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -7.2 \cdot 10^{+154}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 16: 33.9% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 2 + \frac{Ec}{KbT}\\ \mathbf{if}\;Vef \leq -5.5 \cdot 10^{+166}:\\ \;\;\;\;\frac{\frac{2}{NaChar} + \frac{t_0}{NdChar}}{\frac{\frac{2}{NaChar} \cdot t_0}{NdChar}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -5.50000000000000008e166

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 53.0%

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

   5. Taylor expanded in Ec around inf 31.9%

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

      1. mul-1-neg 31.9%

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

   7. Simplified 31.9%

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

   8. Taylor expanded in Ec around 0 15.8%

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

      1. associate-*r/ 15.8%

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

      2. mul-1-neg 15.8%

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

   10. Simplified 15.8%

       \[\leadsto \frac{NdChar}{\color{blue}{2 + \frac{-Ec}{KbT}}} + \frac{NaChar}{2} \]
   11. Step-by-step derivation

       1. clear-num 15.8%

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

       2. clear-num 15.8%

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

       3. frac-add 24.9%

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

       4. *-un-lft-identity 24.9%

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

       5. add-sqr-sqrt 13.4%

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

       6. sqrt-unprod 19.3%

          \[\leadsto \frac{\frac{2}{NaChar} + \frac{2 + \frac{\color{blue}{\sqrt{\left(-Ec\right) \cdot \left(-Ec\right)}}}{KbT}}{NdChar} \cdot 1}{\frac{2 + \frac{-Ec}{KbT}}{NdChar} \cdot \frac{2}{NaChar}} \]

       7. sqr-neg 19.3%

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

       8. sqrt-unprod 11.5%

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

       9. add-sqr-sqrt 24.4%

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

   12. Applied egg-rr 25.2%

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

       1. *-rgt-identity 25.2%

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

       2. associate-*l/ 30.5%

          \[\leadsto \frac{\frac{2}{NaChar} + \frac{2 + \frac{Ec}{KbT}}{NdChar}}{\color{blue}{\frac{\left(2 + \frac{Ec}{KbT}\right) \cdot \frac{2}{NaChar}}{NdChar}}} \]

   14. Simplified 30.5%

       \[\leadsto \color{blue}{\frac{\frac{2}{NaChar} + \frac{2 + \frac{Ec}{KbT}}{NdChar}}{\frac{\left(2 + \frac{Ec}{KbT}\right) \cdot \frac{2}{NaChar}}{NdChar}}} \]

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

   4. Taylor expanded in EAccept around inf 74.0%

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

   5. Taylor expanded in KbT around inf 40.5%

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

4. Final simplification 39.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -5.5 \cdot 10^{+166}:\\ \;\;\;\;\frac{\frac{2}{NaChar} + \frac{2 + \frac{Ec}{KbT}}{NdChar}}{\frac{\frac{2}{NaChar} \cdot \left(2 + \frac{Ec}{KbT}\right)}{NdChar}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 17: 34.9% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -1.0000000000000001e-290

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 76.6%

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

   5. Taylor expanded in KbT around inf 43.4%

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

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

   4. Taylor expanded in Ev around inf 71.5%

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

   5. Taylor expanded in KbT around inf 28.8%

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

4. Final simplification 35.6%

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

Alternative 18: 25.2% accurate, 5.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq -1.6 \cdot 10^{-173}:\\ \;\;\;\;\frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;EAccept \leq 1.6 \cdot 10^{+172}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < -1.6e-173

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 59.9%

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

      1. frac-add 50.2%

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

      2. associate-/r* 60.8%

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

      3. *-commutative 60.8%

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

   6. Applied egg-rr 60.8%

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

   7. Taylor expanded in KbT around inf 28.9%

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

   if -1.6e-173 < EAccept < 1.59999999999999993e172

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 54.8%

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

   5. Taylor expanded in Ec around inf 40.8%

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

      1. mul-1-neg 40.8%

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

   7. Simplified 40.8%

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

   8. Taylor expanded in Ec around 0 29.8%

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

      1. associate-*r/ 29.8%

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

      2. mul-1-neg 29.8%

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

   10. Simplified 29.8%

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

   11. Taylor expanded in Ec around 0 31.1%

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

       1. distribute-lft-out 31.1%

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

   13. Simplified 31.1%

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

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

   4. Taylor expanded in KbT around inf 32.1%

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

   5. Taylor expanded in Ec around inf 19.1%

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

      1. mul-1-neg 19.1%

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

   7. Simplified 19.1%

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

   8. Taylor expanded in Ec around 0 11.9%

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

      1. associate-*r/ 11.9%

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

      2. mul-1-neg 11.9%

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

   10. Simplified 11.9%

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

   11. Taylor expanded in NdChar around inf 18.4%

       \[\leadsto \color{blue}{\frac{NdChar}{2 + -1 \cdot \frac{Ec}{KbT}}} \]
   12. Step-by-step derivation

       1. associate-*r/ 18.4%

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

       2. mul-1-neg 18.4%

          \[\leadsto \frac{NdChar}{2 + \frac{\color{blue}{-Ec}}{KbT}} \]

   13. Simplified 18.4%

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

4. Final simplification 28.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq -1.6 \cdot 10^{-173}:\\ \;\;\;\;\frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;EAccept \leq 1.6 \cdot 10^{+172}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \end{array} \]

Alternative 19: 26.4% accurate, 5.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq -6.5 \cdot 10^{-167}:\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;EAccept \leq 3.8 \cdot 10^{+165}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (EAccept <= -6.5e-167)
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	elseif (EAccept <= 3.8e+165)
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NdChar / (2.0 - (Ec / KbT));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EAccept, -6.5e-167], N[(N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.8e+165], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(2.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if EAccept < -6.49999999999999973e-167

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 59.5%

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

   5. Taylor expanded in KbT around inf 31.8%

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

   if -6.49999999999999973e-167 < EAccept < 3.7999999999999999e165

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 54.7%

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

   5. Taylor expanded in Ec around inf 40.5%

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

      1. mul-1-neg 40.5%

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

   7. Simplified 40.5%

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

   8. Taylor expanded in Ec around 0 29.6%

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

      1. associate-*r/ 29.6%

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

      2. mul-1-neg 29.6%

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

   10. Simplified 29.6%

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

   11. Taylor expanded in Ec around 0 31.0%

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

       1. distribute-lft-out 31.0%

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

   13. Simplified 31.0%

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

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

   4. Taylor expanded in KbT around inf 32.1%

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

   5. Taylor expanded in Ec around inf 19.1%

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

      1. mul-1-neg 19.1%

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

   7. Simplified 19.1%

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

   8. Taylor expanded in Ec around 0 11.9%

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

      1. associate-*r/ 11.9%

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

      2. mul-1-neg 11.9%

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

   10. Simplified 11.9%

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

   11. Taylor expanded in NdChar around inf 18.4%

       \[\leadsto \color{blue}{\frac{NdChar}{2 + -1 \cdot \frac{Ec}{KbT}}} \]
   12. Step-by-step derivation

       1. associate-*r/ 18.4%

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

       2. mul-1-neg 18.4%

          \[\leadsto \frac{NdChar}{2 + \frac{\color{blue}{-Ec}}{KbT}} \]

   13. Simplified 18.4%

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

4. Final simplification 29.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq -6.5 \cdot 10^{-167}:\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;EAccept \leq 3.8 \cdot 10^{+165}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \end{array} \]

Alternative 20: 26.8% accurate, 9.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 2 + \frac{Ec}{KbT}\\ \mathbf{if}\;Vef \leq -3.85 \cdot 10^{+164}:\\ \;\;\;\;\frac{\frac{2}{NaChar} + \frac{t_0}{NdChar}}{\frac{\frac{2}{NaChar} \cdot t_0}{NdChar}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 2.0 (/ Ec KbT))))
   (if (<= Vef -3.85e+164)
     (/ (+ (/ 2.0 NaChar) (/ t_0 NdChar)) (/ (* (/ 2.0 NaChar) t_0) NdChar))
     (* 0.5 (+ NdChar NaChar)))))

C

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

Fortran

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

Java

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(2.0 + Float64(Ec / KbT))
	tmp = 0.0
	if (Vef <= -3.85e+164)
		tmp = Float64(Float64(Float64(2.0 / NaChar) + Float64(t_0 / NdChar)) / Float64(Float64(Float64(2.0 / NaChar) * t_0) / NdChar));
	else
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 2.0 + (Ec / KbT);
	tmp = 0.0;
	if (Vef <= -3.85e+164)
		tmp = ((2.0 / NaChar) + (t_0 / NdChar)) / (((2.0 / NaChar) * t_0) / NdChar);
	else
		tmp = 0.5 * (NdChar + NaChar);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(2.0 + N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.85e+164], N[(N[(N[(2.0 / NaChar), $MachinePrecision] + N[(t$95$0 / NdChar), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(2.0 / NaChar), $MachinePrecision] * t$95$0), $MachinePrecision] / NdChar), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if Vef < -3.85e164

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 53.0%

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

   5. Taylor expanded in Ec around inf 31.9%

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

      1. mul-1-neg 31.9%

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

   7. Simplified 31.9%

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

   8. Taylor expanded in Ec around 0 15.8%

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

      1. associate-*r/ 15.8%

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

      2. mul-1-neg 15.8%

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

   10. Simplified 15.8%

       \[\leadsto \frac{NdChar}{\color{blue}{2 + \frac{-Ec}{KbT}}} + \frac{NaChar}{2} \]
   11. Step-by-step derivation

       1. clear-num 15.8%

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

       2. clear-num 15.8%

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

       3. frac-add 24.9%

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

       4. *-un-lft-identity 24.9%

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

       5. add-sqr-sqrt 13.4%

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

       6. sqrt-unprod 19.3%

          \[\leadsto \frac{\frac{2}{NaChar} + \frac{2 + \frac{\color{blue}{\sqrt{\left(-Ec\right) \cdot \left(-Ec\right)}}}{KbT}}{NdChar} \cdot 1}{\frac{2 + \frac{-Ec}{KbT}}{NdChar} \cdot \frac{2}{NaChar}} \]

       7. sqr-neg 19.3%

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

       8. sqrt-unprod 11.5%

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

       9. add-sqr-sqrt 24.4%

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

   12. Applied egg-rr 25.2%

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

       1. *-rgt-identity 25.2%

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

       2. associate-*l/ 30.5%

          \[\leadsto \frac{\frac{2}{NaChar} + \frac{2 + \frac{Ec}{KbT}}{NdChar}}{\color{blue}{\frac{\left(2 + \frac{Ec}{KbT}\right) \cdot \frac{2}{NaChar}}{NdChar}}} \]

   14. Simplified 30.5%

       \[\leadsto \color{blue}{\frac{\frac{2}{NaChar} + \frac{2 + \frac{Ec}{KbT}}{NdChar}}{\frac{\left(2 + \frac{Ec}{KbT}\right) \cdot \frac{2}{NaChar}}{NdChar}}} \]

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

   4. Taylor expanded in KbT around inf 50.1%

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

   5. Taylor expanded in Ec around inf 38.1%

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

      1. mul-1-neg 38.1%

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

   7. Simplified 38.1%

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

   8. Taylor expanded in Ec around 0 29.4%

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

      1. associate-*r/ 29.4%

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

      2. mul-1-neg 29.4%

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

   10. Simplified 29.4%

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

   11. Taylor expanded in Ec around 0 30.4%

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

       1. distribute-lft-out 30.4%

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

   13. Simplified 30.4%

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

4. Final simplification 30.4%

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

Alternative 21: 26.9% accurate, 25.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 6.2 \cdot 10^{+169}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 6.2e169

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 52.9%

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

   5. Taylor expanded in Ec around inf 39.6%

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

      1. mul-1-neg 39.6%

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

   7. Simplified 39.6%

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

   8. Taylor expanded in Ec around 0 29.5%

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

      1. associate-*r/ 29.5%

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

      2. mul-1-neg 29.5%

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

   10. Simplified 29.5%

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

   11. Taylor expanded in Ec around 0 30.7%

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

       1. distribute-lft-out 30.7%

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

   13. Simplified 30.7%

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

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

   4. Taylor expanded in KbT around inf 32.1%

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

   5. Taylor expanded in Ec around inf 19.1%

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

      1. mul-1-neg 19.1%

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

   7. Simplified 19.1%

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

   8. Taylor expanded in Ec around 0 11.9%

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

      1. associate-*r/ 11.9%

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

      2. mul-1-neg 11.9%

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

   10. Simplified 11.9%

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

   11. Taylor expanded in NdChar around inf 18.4%

       \[\leadsto \color{blue}{\frac{NdChar}{2 + -1 \cdot \frac{Ec}{KbT}}} \]
   12. Step-by-step derivation

       1. associate-*r/ 18.4%

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

       2. mul-1-neg 18.4%

          \[\leadsto \frac{NdChar}{2 + \frac{\color{blue}{-Ec}}{KbT}} \]

   13. Simplified 18.4%

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

4. Final simplification 29.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 6.2 \cdot 10^{+169}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2 - \frac{Ec}{KbT}}\\ \end{array} \]

Alternative 22: 27.0% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 50.5%

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

5. Taylor expanded in Ec around inf 37.2%

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

   1. mul-1-neg 37.2%

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

7. Simplified 37.2%

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

8. Taylor expanded in Ec around 0 27.5%

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

   1. associate-*r/ 27.5%

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

   2. mul-1-neg 27.5%

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

10. Simplified 27.5%

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

11. Taylor expanded in Ec around 0 28.7%

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

    1. distribute-lft-out 28.7%

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

13. Simplified 28.7%

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

14. Final simplification 28.7%

    \[\leadsto 0.5 \cdot \left(NdChar + NaChar\right) \]

Alternative 23: 17.7% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 50.5%

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

5. Taylor expanded in Ec around inf 37.2%

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

   1. mul-1-neg 37.2%

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

7. Simplified 37.2%

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

8. Taylor expanded in Ec around 0 27.5%

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

   1. associate-*r/ 27.5%

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

   2. mul-1-neg 27.5%

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

10. Simplified 27.5%

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

11. Taylor expanded in NdChar around 0 15.9%

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

12. Final simplification 15.9%

    \[\leadsto NaChar \cdot 0.5 \]

Reproduce

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