Bulmash initializePoisson

Percentage Accurate: 99.9% → 99.9%

Time: 26.4s

Alternatives: 20

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = 8.401324519057977e+293
  2. Ec = 2.3221463849215008e-17
  3. Vef = -2.0581111934993182e+111
  4. EDonor = -2.1559634767977076e-106
  5. mu = 6.540776458906748e-155
  6. KbT = 4.0416794351718143e-20
  7. NaChar = 7.326465478566867e+293
  8. Ev = 2.2914153527247297e-95
  9. EAccept = -1.270915669132451e+225

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: 99.9% 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: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

   1. clear-num 99.9%

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

   2. associate-/r/ 100.0%

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

   3. +-commutative 100.0%

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

   4. +-commutative 100.0%

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

   5. associate-+r- 100.0%

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

   6. associate-+l- 100.0%

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

6. Applied egg-rr 100.0%

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

7. Final simplification 100.0%

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

Alternative 2: 71.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}\\ t_1 := \frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} + \frac{NaChar}{t\_0 + 1}\\ t_2 := \frac{NdChar}{e^{\frac{mu}{KbT}} + 1} - \frac{NaChar}{-1 - t\_0}\\ \mathbf{if}\;mu \leq -2.25 \cdot 10^{+164}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;mu \leq 1.5 \cdot 10^{-137}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq 1.22 \cdot 10^{-68}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{Vef \cdot \left(\left(\frac{1}{KbT} + \frac{2}{Vef}\right) + \frac{\frac{Ev}{KbT}}{Vef}\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{+48}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq 3.1 \cdot 10^{+100}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} + \frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (exp (/ (- (+ Vef Ev) mu) KbT)))
        (t_1 (+ (/ NdChar (+ (exp (/ Vef KbT)) 1.0)) (/ NaChar (+ t_0 1.0))))
        (t_2 (- (/ NdChar (+ (exp (/ mu KbT)) 1.0)) (/ NaChar (- -1.0 t_0)))))
   (if (<= mu -2.25e+164)
     t_2
     (if (<= mu 1.5e-137)
       t_1
       (if (<= mu 1.22e-68)
         (+
          (/ NdChar (+ (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)) 1.0))
          (/
           NaChar
           (-
            (* Vef (+ (+ (/ 1.0 KbT) (/ 2.0 Vef)) (/ (/ Ev KbT) Vef)))
            (/ mu KbT))))
         (if (<= mu 1.6e+48)
           t_1
           (if (<= mu 3.1e+100)
             (+
              (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))
              (/ NaChar (+ (exp (/ EAccept KbT)) 1.0)))
             t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = exp((((Vef + Ev) - mu) / KbT));
	double t_1 = (NdChar / (exp((Vef / KbT)) + 1.0)) + (NaChar / (t_0 + 1.0));
	double t_2 = (NdChar / (exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - t_0));
	double tmp;
	if (mu <= -2.25e+164) {
		tmp = t_2;
	} else if (mu <= 1.5e-137) {
		tmp = t_1;
	} else if (mu <= 1.22e-68) {
		tmp = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Vef * (((1.0 / KbT) + (2.0 / Vef)) + ((Ev / KbT) / Vef))) - (mu / KbT)));
	} else if (mu <= 1.6e+48) {
		tmp = t_1;
	} else if (mu <= 3.1e+100) {
		tmp = (NdChar / (exp((EDonor / KbT)) + 1.0)) + (NaChar / (exp((EAccept / KbT)) + 1.0));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = exp((((vef + ev) - mu) / kbt))
    t_1 = (ndchar / (exp((vef / kbt)) + 1.0d0)) + (nachar / (t_0 + 1.0d0))
    t_2 = (ndchar / (exp((mu / kbt)) + 1.0d0)) - (nachar / ((-1.0d0) - t_0))
    if (mu <= (-2.25d+164)) then
        tmp = t_2
    else if (mu <= 1.5d-137) then
        tmp = t_1
    else if (mu <= 1.22d-68) then
        tmp = (ndchar / (exp(((edonor + (mu + (vef - ec))) / kbt)) + 1.0d0)) + (nachar / ((vef * (((1.0d0 / kbt) + (2.0d0 / vef)) + ((ev / kbt) / vef))) - (mu / kbt)))
    else if (mu <= 1.6d+48) then
        tmp = t_1
    else if (mu <= 3.1d+100) then
        tmp = (ndchar / (exp((edonor / kbt)) + 1.0d0)) + (nachar / (exp((eaccept / kbt)) + 1.0d0))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = Math.exp((((Vef + Ev) - mu) / KbT));
	double t_1 = (NdChar / (Math.exp((Vef / KbT)) + 1.0)) + (NaChar / (t_0 + 1.0));
	double t_2 = (NdChar / (Math.exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - t_0));
	double tmp;
	if (mu <= -2.25e+164) {
		tmp = t_2;
	} else if (mu <= 1.5e-137) {
		tmp = t_1;
	} else if (mu <= 1.22e-68) {
		tmp = (NdChar / (Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Vef * (((1.0 / KbT) + (2.0 / Vef)) + ((Ev / KbT) / Vef))) - (mu / KbT)));
	} else if (mu <= 1.6e+48) {
		tmp = t_1;
	} else if (mu <= 3.1e+100) {
		tmp = (NdChar / (Math.exp((EDonor / KbT)) + 1.0)) + (NaChar / (Math.exp((EAccept / KbT)) + 1.0));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = math.exp((((Vef + Ev) - mu) / KbT))
	t_1 = (NdChar / (math.exp((Vef / KbT)) + 1.0)) + (NaChar / (t_0 + 1.0))
	t_2 = (NdChar / (math.exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - t_0))
	tmp = 0
	if mu <= -2.25e+164:
		tmp = t_2
	elif mu <= 1.5e-137:
		tmp = t_1
	elif mu <= 1.22e-68:
		tmp = (NdChar / (math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Vef * (((1.0 / KbT) + (2.0 / Vef)) + ((Ev / KbT) / Vef))) - (mu / KbT)))
	elif mu <= 1.6e+48:
		tmp = t_1
	elif mu <= 3.1e+100:
		tmp = (NdChar / (math.exp((EDonor / KbT)) + 1.0)) + (NaChar / (math.exp((EAccept / KbT)) + 1.0))
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT))
	t_1 = Float64(Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)) + Float64(NaChar / Float64(t_0 + 1.0)))
	t_2 = Float64(Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0)) - Float64(NaChar / Float64(-1.0 - t_0)))
	tmp = 0.0
	if (mu <= -2.25e+164)
		tmp = t_2;
	elseif (mu <= 1.5e-137)
		tmp = t_1;
	elseif (mu <= 1.22e-68)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(Float64(Vef * Float64(Float64(Float64(1.0 / KbT) + Float64(2.0 / Vef)) + Float64(Float64(Ev / KbT) / Vef))) - Float64(mu / KbT))));
	elseif (mu <= 1.6e+48)
		tmp = t_1;
	elseif (mu <= 3.1e+100)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp((((Vef + Ev) - mu) / KbT));
	t_1 = (NdChar / (exp((Vef / KbT)) + 1.0)) + (NaChar / (t_0 + 1.0));
	t_2 = (NdChar / (exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - t_0));
	tmp = 0.0;
	if (mu <= -2.25e+164)
		tmp = t_2;
	elseif (mu <= 1.5e-137)
		tmp = t_1;
	elseif (mu <= 1.22e-68)
		tmp = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Vef * (((1.0 / KbT) + (2.0 / Vef)) + ((Ev / KbT) / Vef))) - (mu / KbT)));
	elseif (mu <= 1.6e+48)
		tmp = t_1;
	elseif (mu <= 3.1e+100)
		tmp = (NdChar / (exp((EDonor / KbT)) + 1.0)) + (NaChar / (exp((EAccept / KbT)) + 1.0));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] - N[(NaChar / N[(-1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.25e+164], t$95$2, If[LessEqual[mu, 1.5e-137], t$95$1, If[LessEqual[mu, 1.22e-68], N[(N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Vef * N[(N[(N[(1.0 / KbT), $MachinePrecision] + N[(2.0 / Vef), $MachinePrecision]), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.6e+48], t$95$1, If[LessEqual[mu, 3.1e+100], N[(N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if mu < -2.24999999999999988e164 or 3.10000000000000007e100 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 92.6%

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

   6. Taylor expanded in EAccept around 0 90.3%

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

   if -2.24999999999999988e164 < mu < 1.4999999999999999e-137 or 1.2200000000000001e-68 < mu < 1.6000000000000001e48

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 78.4%

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

   6. Taylor expanded in EAccept around 0 70.5%

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

   if 1.4999999999999999e-137 < mu < 1.2200000000000001e-68

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 82.7%

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

   6. Taylor expanded in EAccept around 0 81.0%

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

      1. associate-+r+ 81.0%

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

   8. Simplified 81.0%

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

   9. Taylor expanded in Vef around inf 92.3%

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

       1. associate-+r+ 92.3%

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

       2. associate-*r/ 92.3%

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

       3. metadata-eval 92.3%

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

       4. associate-/r* 92.3%

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

   11. Simplified 92.3%

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

   if 1.6000000000000001e48 < mu < 3.10000000000000007e100

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 69.7%

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

   6. Taylor expanded in EDonor around inf 69.7%

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

4. Final simplification 77.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -2.25 \cdot 10^{+164}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{mu}{KbT}} + 1} - \frac{NaChar}{-1 - e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.5 \cdot 10^{-137}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} + \frac{NaChar}{e^{\frac{\left(Vef + Ev\right) - mu}{KbT}} + 1}\\ \mathbf{elif}\;mu \leq 1.22 \cdot 10^{-68}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{Vef \cdot \left(\left(\frac{1}{KbT} + \frac{2}{Vef}\right) + \frac{\frac{Ev}{KbT}}{Vef}\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{+48}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} + \frac{NaChar}{e^{\frac{\left(Vef + Ev\right) - mu}{KbT}} + 1}\\ \mathbf{elif}\;mu \leq 3.1 \cdot 10^{+100}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} + \frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{mu}{KbT}} + 1} - \frac{NaChar}{-1 - e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 77.3% accurate, 0.9× speedup

Math

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)
	t_1 = t_0 + (NdChar / (math.exp((mu / KbT)) + 1.0))
	tmp = 0
	if mu <= -1.12e+164:
		tmp = t_1
	elif mu <= 3.4e-220:
		tmp = t_0 + (NdChar / (math.exp((Vef / KbT)) + 1.0))
	elif mu <= 1.15e-31:
		tmp = t_0 + (NdChar / (math.exp((EDonor / KbT)) + 1.0))
	elif mu <= 2.3e+49:
		tmp = (NdChar / (math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (math.exp((Ev / KbT)) + 1.0))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0)))
	tmp = 0.0
	if (mu <= -1.12e+164)
		tmp = t_1;
	elseif (mu <= 3.4e-220)
		tmp = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)));
	elseif (mu <= 1.15e-31)
		tmp = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0)));
	elseif (mu <= 2.3e+49)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.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 / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0);
	t_1 = t_0 + (NdChar / (exp((mu / KbT)) + 1.0));
	tmp = 0.0;
	if (mu <= -1.12e+164)
		tmp = t_1;
	elseif (mu <= 3.4e-220)
		tmp = t_0 + (NdChar / (exp((Vef / KbT)) + 1.0));
	elseif (mu <= 1.15e-31)
		tmp = t_0 + (NdChar / (exp((EDonor / KbT)) + 1.0));
	elseif (mu <= 2.3e+49)
		tmp = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp((Ev / KbT)) + 1.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[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.12e+164], t$95$1, If[LessEqual[mu, 3.4e-220], N[(t$95$0 + N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.15e-31], N[(t$95$0 + N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.3e+49], N[(N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 4 regimes

2. if mu < -1.12000000000000006e164 or 2.30000000000000002e49 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 93.3%

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

   if -1.12000000000000006e164 < mu < 3.39999999999999993e-220

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 79.5%

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

   if 3.39999999999999993e-220 < mu < 1.1499999999999999e-31

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 84.9%

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

   if 1.1499999999999999e-31 < mu < 2.30000000000000002e49

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 83.9%

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

4. Final simplification 85.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1.12 \cdot 10^{+164}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{e^{\frac{mu}{KbT}} + 1}\\ \mathbf{elif}\;mu \leq 3.4 \cdot 10^{-220}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{elif}\;mu \leq 1.15 \cdot 10^{-31}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{elif}\;mu \leq 2.3 \cdot 10^{+49}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{e^{\frac{mu}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 67.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -4.1 \cdot 10^{+27}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{Vef \cdot \left(\left(\frac{1}{KbT} + \frac{2}{Vef}\right) + \frac{\frac{Ev}{KbT}}{Vef}\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.7 \cdot 10^{+68} \lor \neg \left(NdChar \leq 4.05 \cdot 10^{+183}\right) \land NdChar \leq 6.2 \cdot 10^{+206}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} + \frac{NaChar}{e^{\frac{\left(Vef + Ev\right) - mu}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -4.1e+27)
   (+
    (/ NdChar (+ (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)) 1.0))
    (/
     NaChar
     (-
      (* Vef (+ (+ (/ 1.0 KbT) (/ 2.0 Vef)) (/ (/ Ev KbT) Vef)))
      (/ mu KbT))))
   (if (or (<= NdChar 2.7e+68)
           (and (not (<= NdChar 4.05e+183)) (<= NdChar 6.2e+206)))
     (+
      (/ NdChar (+ (exp (/ Vef KbT)) 1.0))
      (/ NaChar (+ (exp (/ (- (+ Vef Ev) mu) KbT)) 1.0)))
     (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.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 <= -4.1e+27) {
		tmp = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Vef * (((1.0 / KbT) + (2.0 / Vef)) + ((Ev / KbT) / Vef))) - (mu / KbT)));
	} else if ((NdChar <= 2.7e+68) || (!(NdChar <= 4.05e+183) && (NdChar <= 6.2e+206))) {
		tmp = (NdChar / (exp((Vef / KbT)) + 1.0)) + (NaChar / (exp((((Vef + Ev) - mu) / KbT)) + 1.0));
	} else {
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.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 <= (-4.1d+27)) then
        tmp = (ndchar / (exp(((edonor + (mu + (vef - ec))) / kbt)) + 1.0d0)) + (nachar / ((vef * (((1.0d0 / kbt) + (2.0d0 / vef)) + ((ev / kbt) / vef))) - (mu / kbt)))
    else if ((ndchar <= 2.7d+68) .or. (.not. (ndchar <= 4.05d+183)) .and. (ndchar <= 6.2d+206)) then
        tmp = (ndchar / (exp((vef / kbt)) + 1.0d0)) + (nachar / (exp((((vef + ev) - mu) / kbt)) + 1.0d0))
    else
        tmp = ndchar / (exp((((edonor + (mu + vef)) - ec) / kbt)) + 1.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 <= -4.1e+27) {
		tmp = (NdChar / (Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Vef * (((1.0 / KbT) + (2.0 / Vef)) + ((Ev / KbT) / Vef))) - (mu / KbT)));
	} else if ((NdChar <= 2.7e+68) || (!(NdChar <= 4.05e+183) && (NdChar <= 6.2e+206))) {
		tmp = (NdChar / (Math.exp((Vef / KbT)) + 1.0)) + (NaChar / (Math.exp((((Vef + Ev) - mu) / KbT)) + 1.0));
	} else {
		tmp = NdChar / (Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NdChar <= -4.1e+27:
		tmp = (NdChar / (math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Vef * (((1.0 / KbT) + (2.0 / Vef)) + ((Ev / KbT) / Vef))) - (mu / KbT)))
	elif (NdChar <= 2.7e+68) or (not (NdChar <= 4.05e+183) and (NdChar <= 6.2e+206)):
		tmp = (NdChar / (math.exp((Vef / KbT)) + 1.0)) + (NaChar / (math.exp((((Vef + Ev) - mu) / KbT)) + 1.0))
	else:
		tmp = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NdChar <= -4.1e+27)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(Float64(Vef * Float64(Float64(Float64(1.0 / KbT) + Float64(2.0 / Vef)) + Float64(Float64(Ev / KbT) / Vef))) - Float64(mu / KbT))));
	elseif ((NdChar <= 2.7e+68) || (!(NdChar <= 4.05e+183) && (NdChar <= 6.2e+206)))
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)) + 1.0)));
	else
		tmp = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NdChar <= -4.1e+27)
		tmp = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Vef * (((1.0 / KbT) + (2.0 / Vef)) + ((Ev / KbT) / Vef))) - (mu / KbT)));
	elseif ((NdChar <= 2.7e+68) || (~((NdChar <= 4.05e+183)) && (NdChar <= 6.2e+206)))
		tmp = (NdChar / (exp((Vef / KbT)) + 1.0)) + (NaChar / (exp((((Vef + Ev) - mu) / KbT)) + 1.0));
	else
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -4.1e+27], N[(N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Vef * N[(N[(N[(1.0 / KbT), $MachinePrecision] + N[(2.0 / Vef), $MachinePrecision]), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NdChar, 2.7e+68], And[N[Not[LessEqual[NdChar, 4.05e+183]], $MachinePrecision], LessEqual[NdChar, 6.2e+206]]], N[(N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -4.1000000000000002e27

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 69.2%

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

   6. Taylor expanded in EAccept around 0 71.5%

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

      1. associate-+r+ 71.5%

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

   8. Simplified 71.5%

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

   9. Taylor expanded in Vef around inf 73.1%

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

       1. associate-+r+ 73.1%

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

       2. associate-*r/ 73.1%

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

       3. metadata-eval 73.1%

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

       4. associate-/r* 73.2%

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

   11. Simplified 73.2%

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

   if -4.1000000000000002e27 < NdChar < 2.69999999999999991e68 or 4.04999999999999997e183 < NdChar < 6.19999999999999981e206

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 80.6%

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

   6. Taylor expanded in EAccept around 0 73.8%

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

   if 2.69999999999999991e68 < NdChar < 4.04999999999999997e183 or 6.19999999999999981e206 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.2%

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

   6. Taylor expanded in EAccept around 0 60.1%

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

      1. associate-+r+ 60.1%

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

   8. Simplified 60.1%

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

   9. Taylor expanded in Ev around inf 39.8%

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

   10. Taylor expanded in NdChar around inf 75.7%

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

4. Final simplification 74.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -4.1 \cdot 10^{+27}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{Vef \cdot \left(\left(\frac{1}{KbT} + \frac{2}{Vef}\right) + \frac{\frac{Ev}{KbT}}{Vef}\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 2.7 \cdot 10^{+68} \lor \neg \left(NdChar \leq 4.05 \cdot 10^{+183}\right) \land NdChar \leq 6.2 \cdot 10^{+206}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} + \frac{NaChar}{e^{\frac{\left(Vef + Ev\right) - mu}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 73.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}\\ t_1 := \frac{NdChar}{e^{\frac{mu}{KbT}} + 1} - \frac{NaChar}{-1 - t\_0}\\ \mathbf{if}\;mu \leq -9 \cdot 10^{+163}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq 2.55 \cdot 10^{-222}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} + \frac{NaChar}{t\_0 + 1}\\ \mathbf{elif}\;mu \leq 3.5 \cdot 10^{+103}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (exp (/ (- (+ Vef Ev) mu) KbT)))
        (t_1 (- (/ NdChar (+ (exp (/ mu KbT)) 1.0)) (/ NaChar (- -1.0 t_0)))))
   (if (<= mu -9e+163)
     t_1
     (if (<= mu 2.55e-222)
       (+ (/ NdChar (+ (exp (/ Vef KbT)) 1.0)) (/ NaChar (+ t_0 1.0)))
       (if (<= mu 3.5e+103)
         (+
          (/ NaChar (+ (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)) 1.0))
          (/ NdChar (+ (exp (/ EDonor KbT)) 1.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 = exp((((Vef + Ev) - mu) / KbT));
	double t_1 = (NdChar / (exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - t_0));
	double tmp;
	if (mu <= -9e+163) {
		tmp = t_1;
	} else if (mu <= 2.55e-222) {
		tmp = (NdChar / (exp((Vef / KbT)) + 1.0)) + (NaChar / (t_0 + 1.0));
	} else if (mu <= 3.5e+103) {
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / (exp((EDonor / KbT)) + 1.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 = exp((((vef + ev) - mu) / kbt))
    t_1 = (ndchar / (exp((mu / kbt)) + 1.0d0)) - (nachar / ((-1.0d0) - t_0))
    if (mu <= (-9d+163)) then
        tmp = t_1
    else if (mu <= 2.55d-222) then
        tmp = (ndchar / (exp((vef / kbt)) + 1.0d0)) + (nachar / (t_0 + 1.0d0))
    else if (mu <= 3.5d+103) then
        tmp = (nachar / (exp(((vef + (ev + (eaccept - mu))) / kbt)) + 1.0d0)) + (ndchar / (exp((edonor / kbt)) + 1.0d0))
    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 = Math.exp((((Vef + Ev) - mu) / KbT));
	double t_1 = (NdChar / (Math.exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - t_0));
	double tmp;
	if (mu <= -9e+163) {
		tmp = t_1;
	} else if (mu <= 2.55e-222) {
		tmp = (NdChar / (Math.exp((Vef / KbT)) + 1.0)) + (NaChar / (t_0 + 1.0));
	} else if (mu <= 3.5e+103) {
		tmp = (NaChar / (Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / (Math.exp((EDonor / KbT)) + 1.0));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = math.exp((((Vef + Ev) - mu) / KbT))
	t_1 = (NdChar / (math.exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - t_0))
	tmp = 0
	if mu <= -9e+163:
		tmp = t_1
	elif mu <= 2.55e-222:
		tmp = (NdChar / (math.exp((Vef / KbT)) + 1.0)) + (NaChar / (t_0 + 1.0))
	elif mu <= 3.5e+103:
		tmp = (NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / (math.exp((EDonor / KbT)) + 1.0))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT))
	t_1 = Float64(Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0)) - Float64(NaChar / Float64(-1.0 - t_0)))
	tmp = 0.0
	if (mu <= -9e+163)
		tmp = t_1;
	elseif (mu <= 2.55e-222)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)) + Float64(NaChar / Float64(t_0 + 1.0)));
	elseif (mu <= 3.5e+103)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.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 = exp((((Vef + Ev) - mu) / KbT));
	t_1 = (NdChar / (exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - t_0));
	tmp = 0.0;
	if (mu <= -9e+163)
		tmp = t_1;
	elseif (mu <= 2.55e-222)
		tmp = (NdChar / (exp((Vef / KbT)) + 1.0)) + (NaChar / (t_0 + 1.0));
	elseif (mu <= 3.5e+103)
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / (exp((EDonor / KbT)) + 1.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[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] - N[(NaChar / N[(-1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -9e+163], t$95$1, If[LessEqual[mu, 2.55e-222], N[(N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3.5e+103], N[(N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -8.99999999999999976e163 or 3.5e103 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 92.6%

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

   6. Taylor expanded in EAccept around 0 90.3%

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

   if -8.99999999999999976e163 < mu < 2.5500000000000001e-222

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 79.5%

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

   6. Taylor expanded in EAccept around 0 71.2%

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

   if 2.5500000000000001e-222 < mu < 3.5e103

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 83.1%

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

4. Final simplification 79.4%

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

Alternative 6: 76.3% accurate, 1.0× speedup

Math

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0))
	t_1 = Float64(Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0)) - Float64(NaChar / Float64(-1.0 - exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)))))
	tmp = 0.0
	if (mu <= -8.5e+163)
		tmp = t_1;
	elseif (mu <= 1.55e-220)
		tmp = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)));
	elseif (mu <= 1.3e+102)
		tmp = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.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 / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0);
	t_1 = (NdChar / (exp((mu / KbT)) + 1.0)) - (NaChar / (-1.0 - exp((((Vef + Ev) - mu) / KbT))));
	tmp = 0.0;
	if (mu <= -8.5e+163)
		tmp = t_1;
	elseif (mu <= 1.55e-220)
		tmp = t_0 + (NdChar / (exp((Vef / KbT)) + 1.0));
	elseif (mu <= 1.3e+102)
		tmp = t_0 + (NdChar / (exp((EDonor / KbT)) + 1.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[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $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[mu, -8.5e+163], t$95$1, If[LessEqual[mu, 1.55e-220], N[(t$95$0 + N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.3e+102], N[(t$95$0 + N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -8.5000000000000003e163 or 1.30000000000000003e102 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 92.6%

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

   6. Taylor expanded in EAccept around 0 90.3%

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

   if -8.5000000000000003e163 < mu < 1.55000000000000006e-220

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 79.5%

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

   if 1.55000000000000006e-220 < mu < 1.30000000000000003e102

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 83.1%

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

4. Final simplification 83.5%

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

Alternative 7: 76.9% accurate, 1.0× speedup

Math

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)
	t_1 = t_0 + (NdChar / (math.exp((mu / KbT)) + 1.0))
	tmp = 0
	if mu <= -3.35e+164:
		tmp = t_1
	elif mu <= 3.4e-221:
		tmp = t_0 + (NdChar / (math.exp((Vef / KbT)) + 1.0))
	elif mu <= 1.45e-28:
		tmp = t_0 + (NdChar / (math.exp((EDonor / KbT)) + 1.0))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0)))
	tmp = 0.0
	if (mu <= -3.35e+164)
		tmp = t_1;
	elseif (mu <= 3.4e-221)
		tmp = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)));
	elseif (mu <= 1.45e-28)
		tmp = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.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 / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0);
	t_1 = t_0 + (NdChar / (exp((mu / KbT)) + 1.0));
	tmp = 0.0;
	if (mu <= -3.35e+164)
		tmp = t_1;
	elseif (mu <= 3.4e-221)
		tmp = t_0 + (NdChar / (exp((Vef / KbT)) + 1.0));
	elseif (mu <= 1.45e-28)
		tmp = t_0 + (NdChar / (exp((EDonor / KbT)) + 1.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[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -3.35e+164], t$95$1, If[LessEqual[mu, 3.4e-221], N[(t$95$0 + N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.45e-28], N[(t$95$0 + N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -3.3499999999999998e164 or 1.45000000000000006e-28 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 90.2%

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

   if -3.3499999999999998e164 < mu < 3.4000000000000001e-221

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 79.5%

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

   if 3.4000000000000001e-221 < mu < 1.45000000000000006e-28

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 84.9%

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

4. Final simplification 84.2%

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

Alternative 8: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Final simplification 100.0%

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

Alternative 9: 62.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ t_1 := \frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{2}\\ \mathbf{if}\;NdChar \leq -720:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NdChar \leq -1.15 \cdot 10^{-10}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq -4.2 \cdot 10^{-63}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NdChar \leq -2.7 \cdot 10^{-188}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NdChar \leq -2.2 \cdot 10^{-266} \lor \neg \left(NdChar \leq 460\right):\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;\frac{-1}{-1 - e^{\frac{\left(Ev + EAccept\right) + \left(Vef - mu\right)}{KbT}}} \cdot NaChar + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0)))
        (t_1
         (+
          (/ NaChar (+ (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)) 1.0))
          (/ NdChar 2.0))))
   (if (<= NdChar -720.0)
     t_0
     (if (<= NdChar -1.15e-10)
       t_1
       (if (<= NdChar -4.2e-63)
         t_0
         (if (<= NdChar -2.7e-188)
           t_1
           (if (or (<= NdChar -2.2e-266) (not (<= NdChar 460.0)))
             t_0
             (+
              (*
               (/ -1.0 (- -1.0 (exp (/ (+ (+ Ev EAccept) (- Vef mu)) KbT))))
               NaChar)
              (/ NdChar 2.0)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	double t_1 = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	double tmp;
	if (NdChar <= -720.0) {
		tmp = t_0;
	} else if (NdChar <= -1.15e-10) {
		tmp = t_1;
	} else if (NdChar <= -4.2e-63) {
		tmp = t_0;
	} else if (NdChar <= -2.7e-188) {
		tmp = t_1;
	} else if ((NdChar <= -2.2e-266) || !(NdChar <= 460.0)) {
		tmp = t_0;
	} else {
		tmp = ((-1.0 / (-1.0 - exp((((Ev + EAccept) + (Vef - mu)) / KbT)))) * NaChar) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (exp((((edonor + (mu + vef)) - ec) / kbt)) + 1.0d0)
    t_1 = (nachar / (exp(((vef + (ev + (eaccept - mu))) / kbt)) + 1.0d0)) + (ndchar / 2.0d0)
    if (ndchar <= (-720.0d0)) then
        tmp = t_0
    else if (ndchar <= (-1.15d-10)) then
        tmp = t_1
    else if (ndchar <= (-4.2d-63)) then
        tmp = t_0
    else if (ndchar <= (-2.7d-188)) then
        tmp = t_1
    else if ((ndchar <= (-2.2d-266)) .or. (.not. (ndchar <= 460.0d0))) then
        tmp = t_0
    else
        tmp = (((-1.0d0) / ((-1.0d0) - exp((((ev + eaccept) + (vef - mu)) / kbt)))) * nachar) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	double t_1 = (NaChar / (Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	double tmp;
	if (NdChar <= -720.0) {
		tmp = t_0;
	} else if (NdChar <= -1.15e-10) {
		tmp = t_1;
	} else if (NdChar <= -4.2e-63) {
		tmp = t_0;
	} else if (NdChar <= -2.7e-188) {
		tmp = t_1;
	} else if ((NdChar <= -2.2e-266) || !(NdChar <= 460.0)) {
		tmp = t_0;
	} else {
		tmp = ((-1.0 / (-1.0 - Math.exp((((Ev + EAccept) + (Vef - mu)) / KbT)))) * NaChar) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	t_1 = (NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0)
	tmp = 0
	if NdChar <= -720.0:
		tmp = t_0
	elif NdChar <= -1.15e-10:
		tmp = t_1
	elif NdChar <= -4.2e-63:
		tmp = t_0
	elif NdChar <= -2.7e-188:
		tmp = t_1
	elif (NdChar <= -2.2e-266) or not (NdChar <= 460.0):
		tmp = t_0
	else:
		tmp = ((-1.0 / (-1.0 - math.exp((((Ev + EAccept) + (Vef - mu)) / KbT)))) * NaChar) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0))
	t_1 = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0)) + Float64(NdChar / 2.0))
	tmp = 0.0
	if (NdChar <= -720.0)
		tmp = t_0;
	elseif (NdChar <= -1.15e-10)
		tmp = t_1;
	elseif (NdChar <= -4.2e-63)
		tmp = t_0;
	elseif (NdChar <= -2.7e-188)
		tmp = t_1;
	elseif ((NdChar <= -2.2e-266) || !(NdChar <= 460.0))
		tmp = t_0;
	else
		tmp = Float64(Float64(Float64(-1.0 / Float64(-1.0 - exp(Float64(Float64(Float64(Ev + EAccept) + Float64(Vef - mu)) / KbT)))) * NaChar) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	t_1 = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	tmp = 0.0;
	if (NdChar <= -720.0)
		tmp = t_0;
	elseif (NdChar <= -1.15e-10)
		tmp = t_1;
	elseif (NdChar <= -4.2e-63)
		tmp = t_0;
	elseif (NdChar <= -2.7e-188)
		tmp = t_1;
	elseif ((NdChar <= -2.2e-266) || ~((NdChar <= 460.0)))
		tmp = t_0;
	else
		tmp = ((-1.0 / (-1.0 - exp((((Ev + EAccept) + (Vef - mu)) / KbT)))) * NaChar) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -720.0], t$95$0, If[LessEqual[NdChar, -1.15e-10], t$95$1, If[LessEqual[NdChar, -4.2e-63], t$95$0, If[LessEqual[NdChar, -2.7e-188], t$95$1, If[Or[LessEqual[NdChar, -2.2e-266], N[Not[LessEqual[NdChar, 460.0]], $MachinePrecision]], t$95$0, N[(N[(N[(-1.0 / N[(-1.0 - N[Exp[N[(N[(N[(Ev + EAccept), $MachinePrecision] + N[(Vef - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * NaChar), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -720 or -1.15000000000000004e-10 < NdChar < -4.2e-63 or -2.7000000000000001e-188 < NdChar < -2.2e-266 or 460 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 57.1%

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

   6. Taylor expanded in EAccept around 0 57.9%

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

      1. associate-+r+ 57.9%

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

   8. Simplified 57.9%

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

   9. Taylor expanded in Ev around inf 37.9%

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

   10. Taylor expanded in NdChar around inf 75.1%

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

   if -720 < NdChar < -1.15000000000000004e-10 or -4.2e-63 < NdChar < -2.7000000000000001e-188

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 79.4%

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

   6. Taylor expanded in mu around 0 70.2%

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

   if -2.2e-266 < NdChar < 460

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. associate-/r/ 100.0%

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

      3. +-commutative 100.0%

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

      4. +-commutative 100.0%

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

      5. associate-+r- 100.0%

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

      6. associate-+l- 100.0%

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

   6. Applied egg-rr 100.0%

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

   7. Taylor expanded in KbT around inf 70.2%

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

4. Final simplification 73.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -720:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{elif}\;NdChar \leq -1.15 \cdot 10^{-10}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{2}\\ \mathbf{elif}\;NdChar \leq -4.2 \cdot 10^{-63}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{elif}\;NdChar \leq -2.7 \cdot 10^{-188}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{2}\\ \mathbf{elif}\;NdChar \leq -2.2 \cdot 10^{-266} \lor \neg \left(NdChar \leq 460\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{-1}{-1 - e^{\frac{\left(Ev + EAccept\right) + \left(Vef - mu\right)}{KbT}}} \cdot NaChar + \frac{NdChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 62.9% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -2400 \lor \neg \left(NdChar \leq -9.5 \cdot 10^{-13} \lor \neg \left(NdChar \leq -7.5 \cdot 10^{-66}\right) \land \left(NdChar \leq -5.7 \cdot 10^{-188} \lor \neg \left(NdChar \leq -1.3 \cdot 10^{-262}\right) \land NdChar \leq 485\right)\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -2400.0)
         (not
          (or (<= NdChar -9.5e-13)
              (and (not (<= NdChar -7.5e-66))
                   (or (<= NdChar -5.7e-188)
                       (and (not (<= NdChar -1.3e-262)) (<= NdChar 485.0)))))))
   (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0))
   (+
    (/ NaChar (+ (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)) 1.0))
    (/ NdChar 2.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -2400.0) || !((NdChar <= -9.5e-13) || (!(NdChar <= -7.5e-66) && ((NdChar <= -5.7e-188) || (!(NdChar <= -1.3e-262) && (NdChar <= 485.0)))))) {
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	} else {
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((ndchar <= (-2400.0d0)) .or. (.not. (ndchar <= (-9.5d-13)) .or. (.not. (ndchar <= (-7.5d-66))) .and. (ndchar <= (-5.7d-188)) .or. (.not. (ndchar <= (-1.3d-262))) .and. (ndchar <= 485.0d0))) then
        tmp = ndchar / (exp((((edonor + (mu + vef)) - ec) / kbt)) + 1.0d0)
    else
        tmp = (nachar / (exp(((vef + (ev + (eaccept - mu))) / kbt)) + 1.0d0)) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -2400.0) || !((NdChar <= -9.5e-13) || (!(NdChar <= -7.5e-66) && ((NdChar <= -5.7e-188) || (!(NdChar <= -1.3e-262) && (NdChar <= 485.0)))))) {
		tmp = NdChar / (Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	} else {
		tmp = (NaChar / (Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NdChar <= -2400.0) or not ((NdChar <= -9.5e-13) or (not (NdChar <= -7.5e-66) and ((NdChar <= -5.7e-188) or (not (NdChar <= -1.3e-262) and (NdChar <= 485.0))))):
		tmp = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	else:
		tmp = (NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -2400.0) || !((NdChar <= -9.5e-13) || (!(NdChar <= -7.5e-66) && ((NdChar <= -5.7e-188) || (!(NdChar <= -1.3e-262) && (NdChar <= 485.0))))))
		tmp = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0));
	else
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0)) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -2400.0) || ~(((NdChar <= -9.5e-13) || (~((NdChar <= -7.5e-66)) && ((NdChar <= -5.7e-188) || (~((NdChar <= -1.3e-262)) && (NdChar <= 485.0)))))))
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	else
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -2400.0], N[Not[Or[LessEqual[NdChar, -9.5e-13], And[N[Not[LessEqual[NdChar, -7.5e-66]], $MachinePrecision], Or[LessEqual[NdChar, -5.7e-188], And[N[Not[LessEqual[NdChar, -1.3e-262]], $MachinePrecision], LessEqual[NdChar, 485.0]]]]]], $MachinePrecision]], N[(NdChar / N[(N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -2400 or -9.49999999999999991e-13 < NdChar < -7.49999999999999995e-66 or -5.70000000000000025e-188 < NdChar < -1.2999999999999999e-262 or 485 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 57.1%

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

   6. Taylor expanded in EAccept around 0 57.9%

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

      1. associate-+r+ 57.9%

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

   8. Simplified 57.9%

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

   9. Taylor expanded in Ev around inf 37.9%

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

   10. Taylor expanded in NdChar around inf 75.1%

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

   if -2400 < NdChar < -9.49999999999999991e-13 or -7.49999999999999995e-66 < NdChar < -5.70000000000000025e-188 or -1.2999999999999999e-262 < NdChar < 485

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 81.6%

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

   6. Taylor expanded in mu around 0 70.2%

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

4. Final simplification 73.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -2400 \lor \neg \left(NdChar \leq -9.5 \cdot 10^{-13} \lor \neg \left(NdChar \leq -7.5 \cdot 10^{-66}\right) \land \left(NdChar \leq -5.7 \cdot 10^{-188} \lor \neg \left(NdChar \leq -1.3 \cdot 10^{-262}\right) \land NdChar \leq 485\right)\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 67.5% accurate, 1.6× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -1.2e-71 or 1.2600000000000001e-58 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 58.5%

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

   6. Taylor expanded in EAccept around 0 58.2%

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

      1. associate-+r+ 58.2%

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

   8. Simplified 58.2%

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

   9. Taylor expanded in Ev around inf 37.8%

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

   10. Taylor expanded in NdChar around inf 70.7%

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

   if -1.2e-71 < NdChar < 1.2600000000000001e-58

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. associate-/r/ 100.0%

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

      3. +-commutative 100.0%

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

      4. +-commutative 100.0%

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

      5. associate-+r- 100.0%

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

      6. associate-+l- 100.0%

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

   6. Applied egg-rr 100.0%

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

   7. Taylor expanded in KbT around inf 78.1%

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

4. Final simplification 73.5%

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

Alternative 12: 65.9% accurate, 1.6× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -4.2e-66], N[(N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(Vef * N[(N[(N[(N[(1.0 / KbT), $MachinePrecision] + N[(2.0 / Vef), $MachinePrecision]), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] / Vef), $MachinePrecision]), $MachinePrecision] - N[(mu / N[(Vef * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 8e-55], N[(N[(N[(-1.0 / N[(-1.0 - N[Exp[N[(N[(N[(Ev + EAccept), $MachinePrecision] + N[(Vef - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * NaChar), $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], N[(NdChar / N[(N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NdChar < -4.2000000000000001e-66

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.8%

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

   6. Taylor expanded in EAccept around 0 61.3%

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

      1. associate-+r+ 61.3%

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

   8. Simplified 61.3%

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

   9. Taylor expanded in Vef around inf 72.9%

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

       1. associate-+r+ 72.9%

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

       2. associate-*r/ 72.9%

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

       3. metadata-eval 72.9%

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

       4. associate-/r* 74.2%

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

   11. Simplified 74.2%

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

   if -4.2000000000000001e-66 < NdChar < 7.99999999999999996e-55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. associate-/r/ 100.0%

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

      3. +-commutative 100.0%

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

      4. +-commutative 100.0%

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

      5. associate-+r- 100.0%

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

      6. associate-+l- 100.0%

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

   6. Applied egg-rr 100.0%

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

   7. Taylor expanded in KbT around inf 78.1%

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

   if 7.99999999999999996e-55 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 56.3%

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

   6. Taylor expanded in EAccept around 0 55.1%

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

      1. associate-+r+ 55.1%

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

   8. Simplified 55.1%

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

   9. Taylor expanded in Ev around inf 35.7%

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

   10. Taylor expanded in NdChar around inf 68.5%

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

4. Final simplification 73.8%

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

Alternative 13: 65.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -1.1 \cdot 10^{-67} \lor \neg \left(NdChar \leq -2.6 \cdot 10^{-188}\right) \land \left(NdChar \leq -2.2 \cdot 10^{-262} \lor \neg \left(NdChar \leq 485\right)\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -1.1e-67)
         (and (not (<= NdChar -2.6e-188))
              (or (<= NdChar -2.2e-262) (not (<= NdChar 485.0)))))
   (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0))
   (+
    (/ NaChar (+ (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)) 1.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 tmp;
	if ((NdChar <= -1.1e-67) || (!(NdChar <= -2.6e-188) && ((NdChar <= -2.2e-262) || !(NdChar <= 485.0)))) {
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	} else {
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.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) :: tmp
    if ((ndchar <= (-1.1d-67)) .or. (.not. (ndchar <= (-2.6d-188))) .and. (ndchar <= (-2.2d-262)) .or. (.not. (ndchar <= 485.0d0))) then
        tmp = ndchar / (exp((((edonor + (mu + vef)) - ec) / kbt)) + 1.0d0)
    else
        tmp = (nachar / (exp(((vef + (ev + (eaccept - mu))) / kbt)) + 1.0d0)) + (ndchar / ((mu / kbt) + 2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -1.1e-67) || (!(NdChar <= -2.6e-188) && ((NdChar <= -2.2e-262) || !(NdChar <= 485.0)))) {
		tmp = NdChar / (Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	} else {
		tmp = (NaChar / (Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / ((mu / KbT) + 2.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NdChar <= -1.1e-67) or (not (NdChar <= -2.6e-188) and ((NdChar <= -2.2e-262) or not (NdChar <= 485.0))):
		tmp = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	else:
		tmp = (NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / ((mu / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -1.1e-67) || (!(NdChar <= -2.6e-188) && ((NdChar <= -2.2e-262) || !(NdChar <= 485.0))))
		tmp = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0));
	else
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.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)
	tmp = 0.0;
	if ((NdChar <= -1.1e-67) || (~((NdChar <= -2.6e-188)) && ((NdChar <= -2.2e-262) || ~((NdChar <= 485.0)))))
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	else
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / ((mu / KbT) + 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.1e-67], And[N[Not[LessEqual[NdChar, -2.6e-188]], $MachinePrecision], Or[LessEqual[NdChar, -2.2e-262], N[Not[LessEqual[NdChar, 485.0]], $MachinePrecision]]]], N[(NdChar / N[(N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -1.1000000000000001e-67 or -2.6000000000000001e-188 < NdChar < -2.19999999999999989e-262 or 485 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 56.9%

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

   6. Taylor expanded in EAccept around 0 57.7%

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

      1. associate-+r+ 57.7%

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

   8. Simplified 57.7%

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

   9. Taylor expanded in Ev around inf 37.1%

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

   10. Taylor expanded in NdChar around inf 73.0%

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

   if -1.1000000000000001e-67 < NdChar < -2.6000000000000001e-188 or -2.19999999999999989e-262 < NdChar < 485

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 80.4%

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

   6. Taylor expanded in mu around 0 74.2%

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

4. Final simplification 73.4%

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

Alternative 14: 63.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -9 \cdot 10^{+174}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1} + \frac{NdChar}{2}\\ \mathbf{elif}\;KbT \leq 1.4 \cdot 10^{+176}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{-Ec}{KbT}} + 1} + NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -9e+174)
   (+ (/ NaChar (+ (exp (/ Ev KbT)) 1.0)) (/ NdChar 2.0))
   (if (<= KbT 1.4e+176)
     (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0))
     (+ (/ NdChar (+ (exp (/ (- Ec) KbT)) 1.0)) (* NaChar 0.5)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -9.00000000000000084e174

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 80.2%

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

   6. Taylor expanded in KbT around inf 76.5%

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

   if -9.00000000000000084e174 < KbT < 1.4000000000000001e176

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 43.7%

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

   6. Taylor expanded in EAccept around 0 44.1%

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

      1. associate-+r+ 44.1%

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

   8. Simplified 44.1%

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

   9. Taylor expanded in Ev around inf 32.7%

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

   10. Taylor expanded in NdChar around inf 61.3%

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

   if 1.4000000000000001e176 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 86.4%

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

   6. Taylor expanded in Ec around inf 79.1%

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

      1. mul-1-neg 79.1%

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

      2. distribute-neg-frac2 79.1%

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

   8. Simplified 79.1%

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

4. Final simplification 65.1%

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

Alternative 15: 38.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -3.3 \cdot 10^{+43} \lor \neg \left(NdChar \leq 3.5 \cdot 10^{+68}\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -3.3e+43) (not (<= NdChar 3.5e+68)))
   (+ (/ NdChar (+ (exp (/ EDonor KbT)) 1.0)) (* NaChar 0.5))
   (+ (/ NaChar (+ (exp (/ Ev KbT)) 1.0)) (/ NdChar 2.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -3.3000000000000001e43 or 3.49999999999999977e68 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 62.2%

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

   6. Taylor expanded in EDonor around inf 44.1%

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

   if -3.3000000000000001e43 < NdChar < 3.49999999999999977e68

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 61.9%

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

   6. Taylor expanded in KbT around inf 39.9%

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

4. Final simplification 41.7%

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

Alternative 16: 38.2% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -1.1e+44)
   (+ (/ NdChar (+ (exp (/ EDonor KbT)) 1.0)) (* NaChar 0.5))
   (if (<= NdChar 4.2e-63)
     (+ (/ NaChar (+ (exp (/ Ev KbT)) 1.0)) (/ NdChar 2.0))
     (+ (/ NdChar (+ (exp (/ Vef KbT)) 1.0)) (* NaChar 0.5)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -1.09999999999999998e44

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 68.6%

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

   6. Taylor expanded in EDonor around inf 51.4%

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

   if -1.09999999999999998e44 < NdChar < 4.2e-63

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 61.1%

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

   6. Taylor expanded in KbT around inf 41.3%

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

   if 4.2e-63 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 52.5%

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

   6. Taylor expanded in Vef around inf 35.0%

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

4. Final simplification 41.3%

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

Alternative 17: 36.4% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 5.9999999999999996e77

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 69.1%

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

   6. Taylor expanded in KbT around inf 38.0%

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

   if 5.9999999999999996e77 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 81.4%

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

   6. Taylor expanded in KbT around inf 32.0%

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

4. Final simplification 36.9%

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

Alternative 18: 35.4% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -2.4999999999999999e195

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Ev around inf 88.4%

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

   6. Taylor expanded in KbT around inf 45.4%

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

   if -2.4999999999999999e195 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 50.6%

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

   6. Taylor expanded in mu around inf 41.0%

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

4. Final simplification 41.6%

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

Alternative 19: 35.1% accurate, 2.1× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in EAccept around inf 69.2%

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

6. Taylor expanded in KbT around inf 35.9%

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

7. Final simplification 35.9%

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

Alternative 20: 27.0% accurate, 32.7× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / 2.0) + (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 = (ndchar / 2.0d0) + (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 (NdChar / 2.0) + (NaChar * 0.5);
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 49.0%

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

6. Taylor expanded in KbT around inf 28.9%

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

7. Final simplification 28.9%

   \[\leadsto \frac{NdChar}{2} + NaChar \cdot 0.5 \]
8. Add Preprocessing

Reproduce

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