Bulmash initializePoisson

Percentage Accurate: 100.0% → 99.9%

Time: 35.2s

Alternatives: 21

Speedup: 1.0×

• could not determine a ground truth

  1. branch3945 = -1.3756993071661103e-15
  2. NdChar = -2.6451785904095963e-15
  3. Ec = 1.6325349134223124e-221
  4. Vef = 4.5488514386243194e-33
  5. EDonor = -2.49914980034625e-137
  6. mu = 8.126022206712713e-79
  7. KbT = -1.1545217168602457e-165
  8. NaChar = -2.9562567201246004e-264
  9. Ev = -2.7870467951637662e-285
  10. EAccept = 1.6027008024616422e-74

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.9% accurate, 0.7× speedup

Math

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

FPCore

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

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(((mu + (Vef + (EDonor - Ec))) / KbT)))) + (NaChar / (1.0 + cbrt(exp((3.0 / (KbT / (Ev + (EAccept + (Vef - mu)))))))));
}

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(((mu + (Vef + (EDonor - Ec))) / KbT)))) + (NaChar / (1.0 + Math.cbrt(Math.exp((3.0 / (KbT / (Ev + (EAccept + (Vef - mu)))))))));
}

Julia

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

   1. add-cbrt-cube_binary64 100.0%

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

5. Applied rewrite-once 100.0%

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

   1. *-commutative 100.0%

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

   2. cube-unmult 100.0%

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

   3. associate-+r+ 100.0%

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

   4. associate-+r- 100.0%

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

   5. +-commutative 100.0%

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

   6. associate--l+ 100.0%

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

   7. +-commutative 100.0%

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

   8. associate--l+ 100.0%

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

7. Simplified 100.0%

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

   1. pow-exp 100.0%

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

   2. clear-num 100.0%

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

   3. associate-*l/ 100.0%

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

   4. metadata-eval 100.0%

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

9. Applied egg-rr 100.0%

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

10. Final simplification 100.0%

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

Alternative 2: 60.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{if}\;EAccept \leq 2.2 \cdot 10^{-293}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;EAccept \leq 3 \cdot 10^{+43}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \left(KbT \cdot \frac{1}{KbT \cdot KbT}\right) \cdot \left(Vef + Ev\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;EAccept \leq 2.2 \cdot 10^{+144}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ Vef (- EDonor Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/
           NdChar
           (+
            1.0
            (-
             (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
             (/ Ec KbT)))))))
   (if (<= EAccept 2.2e-293)
     t_1
     (if (<= EAccept 3e+43)
       (+
        t_0
        (/
         NaChar
         (+
          1.0
          (-
           (+
            1.0
            (+ (/ EAccept KbT) (* (* KbT (/ 1.0 (* KbT KbT))) (+ Vef Ev))))
           (/ mu KbT)))))
       (if (<= EAccept 2.2e+144)
         t_1
         (+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (Vef + (EDonor - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	double tmp;
	if (EAccept <= 2.2e-293) {
		tmp = t_1;
	} else if (EAccept <= 3e+43) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((KbT * (1.0 / (KbT * KbT))) * (Vef + Ev)))) - (mu / KbT))));
	} else if (EAccept <= 2.2e+144) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (vef + (edonor - ec))) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + ((1.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt))))
    if (eaccept <= 2.2d-293) then
        tmp = t_1
    else if (eaccept <= 3d+43) then
        tmp = t_0 + (nachar / (1.0d0 + ((1.0d0 + ((eaccept / kbt) + ((kbt * (1.0d0 / (kbt * kbt))) * (vef + ev)))) - (mu / kbt))))
    else if (eaccept <= 2.2d+144) then
        tmp = t_1
    else
        tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (Vef + (EDonor - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	double tmp;
	if (EAccept <= 2.2e-293) {
		tmp = t_1;
	} else if (EAccept <= 3e+43) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((KbT * (1.0 / (KbT * KbT))) * (Vef + Ev)))) - (mu / KbT))));
	} else if (EAccept <= 2.2e+144) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (Vef + (EDonor - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))))
	tmp = 0
	if EAccept <= 2.2e-293:
		tmp = t_1
	elif EAccept <= 3e+43:
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((KbT * (1.0 / (KbT * KbT))) * (Vef + Ev)))) - (mu / KbT))))
	elif EAccept <= 2.2e+144:
		tmp = t_1
	else:
		tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Vef + Float64(EDonor - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT)))))
	tmp = 0.0
	if (EAccept <= 2.2e-293)
		tmp = t_1;
	elseif (EAccept <= 3e+43)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(KbT * Float64(1.0 / Float64(KbT * KbT))) * Float64(Vef + Ev)))) - Float64(mu / KbT)))));
	elseif (EAccept <= 2.2e+144)
		tmp = t_1;
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (Vef + (EDonor - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	tmp = 0.0;
	if (EAccept <= 2.2e-293)
		tmp = t_1;
	elseif (EAccept <= 3e+43)
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((KbT * (1.0 / (KbT * KbT))) * (Vef + Ev)))) - (mu / KbT))));
	elseif (EAccept <= 2.2e+144)
		tmp = t_1;
	else
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < 2.2e-293 or 3.00000000000000017e43 < EAccept < 2.19999999999999988e144

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.0%

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

   if 2.2e-293 < EAccept < 3.00000000000000017e43

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 69.3%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]
   5. Step-by-step derivation

      1. frac-add 59.5%

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

      2. clear-num 59.5%

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

      3. *-commutative 59.5%

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

      4. distribute-lft-out 61.1%

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

   6. Applied egg-rr 61.1%

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

      1. unpow2 61.1%

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

      2. associate-/r/ 62.6%

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

      3. unpow2 62.6%

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

      4. +-commutative 62.6%

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

   8. Simplified 62.6%

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

      1. associate-*l/ 61.1%

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

      2. associate-/l* 61.1%

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

   10. Applied egg-rr 61.1%

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

       1. unpow2 61.1%

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

       2. associate-/r/ 62.6%

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

       3. unpow2 62.6%

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

       4. associate-*r* 75.7%

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

       5. +-commutative 75.7%

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

   12. Simplified 75.7%

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

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

   4. Taylor expanded in EAccept around inf 80.0%

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

4. Final simplification 67.1%

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

Alternative 3: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Final simplification 100.0%

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

Alternative 4: 71.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < 2.4000000000000002e59

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 72.7%

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

   if 2.4000000000000002e59 < EAccept < 2.19999999999999988e144

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 68.3%

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

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

   4. Taylor expanded in EAccept around inf 80.0%

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

4. Final simplification 73.2%

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

Alternative 5: 73.2% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -2e103

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 89.1%

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

   if -2e103 < Ev < -1.55e-270

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 77.4%

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

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

   4. Taylor expanded in EAccept around inf 75.6%

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

4. Final simplification 78.9%

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

Alternative 6: 64.2% accurate, 1.6× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -8.50000000000000007e-15

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 66.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]
   5. Step-by-step derivation

      1. frac-add 57.0%

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

      2. clear-num 57.0%

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

      3. *-commutative 57.0%

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

      4. distribute-lft-out 57.0%

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

   6. Applied egg-rr 57.0%

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

      1. unpow2 57.0%

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

      2. associate-/r/ 57.0%

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

      3. unpow2 57.0%

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

      4. +-commutative 57.0%

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

   8. Simplified 57.0%

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

      1. associate-*l/ 57.0%

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

      2. associate-/l* 57.0%

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

   10. Applied egg-rr 57.0%

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

       1. unpow2 57.0%

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

       2. associate-/r/ 57.0%

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

       3. unpow2 57.0%

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

       4. associate-*r* 66.6%

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

       5. +-commutative 66.6%

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

   12. Simplified 66.6%

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

   if -8.50000000000000007e-15 < NdChar < 1.20000000000000002e92

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 71.2%

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

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

   4. Taylor expanded in KbT around inf 69.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]
   5. Step-by-step derivation

      1. clear-num 69.7%

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

      2. inv-pow 69.7%

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

      3. associate--l+ 69.7%

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

      4. associate-+r+ 69.7%

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

      5. metadata-eval 69.7%

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

      6. associate--l+ 69.7%

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

      7. div-inv 69.7%

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

      8. div-inv 69.7%

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

      9. distribute-rgt-out 71.9%

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

      10. div-inv 71.9%

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

      11. *-commutative 71.9%

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

      12. distribute-lft-out-- 78.6%

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

   6. Applied egg-rr 78.6%

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

      1. unpow-1 78.6%

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

      2. *-commutative 78.6%

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

      3. +-commutative 78.6%

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

   8. Simplified 78.6%

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

4. Final simplification 71.3%

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

Alternative 7: 64.5% accurate, 1.6× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -2.9999999999999998e-14

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 66.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]
   5. Step-by-step derivation

      1. frac-add 57.0%

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

      2. clear-num 57.0%

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

      3. *-commutative 57.0%

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

      4. distribute-lft-out 57.0%

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

   6. Applied egg-rr 57.0%

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

      1. times-frac 66.2%

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

      2. +-commutative 66.2%

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

   8. Simplified 66.2%

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

      1. +-commutative 66.2%

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

      2. inv-pow 66.2%

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

      3. sqr-pow 39.1%

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

      4. fma-def 39.1%

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

      5. *-inverses 39.1%

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

      6. *-lft-identity 39.1%

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

      7. +-commutative 39.1%

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

      8. metadata-eval 39.1%

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

      9. *-inverses 39.1%

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

      10. *-lft-identity 39.1%

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

      11. +-commutative 39.1%

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

      12. metadata-eval 39.1%

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

   10. Applied egg-rr 39.1%

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

       1. fma-udef 39.1%

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

       2. pow-sqr 66.2%

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

       3. metadata-eval 66.2%

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

       4. unpow-1 66.2%

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

       5. metadata-eval 66.2%

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

       6. *-inverses 66.2%

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

       7. +-commutative 66.2%

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

       8. associate-/r* 66.2%

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

       9. +-commutative 66.2%

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

       10. associate-/r* 66.2%

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

       11. *-inverses 66.2%

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

       12. metadata-eval 66.2%

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

       13. +-commutative 66.2%

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

   12. Simplified 66.2%

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

   if -2.9999999999999998e-14 < NdChar < 1.4e92

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 71.2%

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

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

   4. Taylor expanded in KbT around inf 69.7%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]
   5. Step-by-step derivation

      1. clear-num 69.7%

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

      2. inv-pow 69.7%

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

      3. associate--l+ 69.7%

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

      4. associate-+r+ 69.7%

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

      5. metadata-eval 69.7%

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

      6. associate--l+ 69.7%

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

      7. div-inv 69.7%

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

      8. div-inv 69.7%

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

      9. distribute-rgt-out 71.9%

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

      10. div-inv 71.9%

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

      11. *-commutative 71.9%

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

      12. distribute-lft-out-- 78.6%

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

   6. Applied egg-rr 78.6%

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

      1. unpow-1 78.6%

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

      2. *-commutative 78.6%

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

      3. +-commutative 78.6%

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

   8. Simplified 78.6%

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

4. Final simplification 71.2%

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

Alternative 8: 61.1% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;NaChar \leq -128000000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -1.9 \cdot 10^{-74}:\\ \;\;\;\;t_0 + \frac{1}{\frac{2 + \left(\frac{EAccept}{KbT} + \left(\left(Vef + Ev\right) - mu\right) \cdot \frac{1}{KbT}\right)}{NaChar}}\\ \mathbf{elif}\;NaChar \leq 1.4 \cdot 10^{+43}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ Vef (- EDonor Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (* NdChar 0.5))))
   (if (<= NaChar -128000000.0)
     t_1
     (if (<= NaChar -1.9e-74)
       (+
        t_0
        (/
         1.0
         (/
          (+ 2.0 (+ (/ EAccept KbT) (* (- (+ Vef Ev) mu) (/ 1.0 KbT))))
          NaChar)))
       (if (<= NaChar 1.4e+43) (+ t_0 (/ NaChar (- 1.0 (/ mu KbT)))) t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (Vef + (EDonor - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (NaChar <= -128000000.0) {
		tmp = t_1;
	} else if (NaChar <= -1.9e-74) {
		tmp = t_0 + (1.0 / ((2.0 + ((EAccept / KbT) + (((Vef + Ev) - mu) * (1.0 / KbT)))) / NaChar));
	} else if (NaChar <= 1.4e+43) {
		tmp = t_0 + (NaChar / (1.0 - (mu / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (Vef + (EDonor - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if NaChar <= -128000000.0:
		tmp = t_1
	elif NaChar <= -1.9e-74:
		tmp = t_0 + (1.0 / ((2.0 + ((EAccept / KbT) + (((Vef + Ev) - mu) * (1.0 / KbT)))) / NaChar))
	elif NaChar <= 1.4e+43:
		tmp = t_0 + (NaChar / (1.0 - (mu / KbT)))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Vef + Float64(EDonor - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (NaChar <= -128000000.0)
		tmp = t_1;
	elseif (NaChar <= -1.9e-74)
		tmp = Float64(t_0 + Float64(1.0 / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Float64(Vef + Ev) - mu) * Float64(1.0 / KbT)))) / NaChar)));
	elseif (NaChar <= 1.4e+43)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 - Float64(mu / KbT))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (Vef + (EDonor - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (NaChar <= -128000000.0)
		tmp = t_1;
	elseif (NaChar <= -1.9e-74)
		tmp = t_0 + (1.0 / ((2.0 + ((EAccept / KbT) + (((Vef + Ev) - mu) * (1.0 / KbT)))) / NaChar));
	elseif (NaChar <= 1.4e+43)
		tmp = t_0 + (NaChar / (1.0 - (mu / KbT)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.28e8 or 1.40000000000000009e43 < NaChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 64.8%

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

   if -1.28e8 < NaChar < -1.8999999999999998e-74

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.0%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]
   5. Step-by-step derivation

      1. clear-num 67.9%

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

      2. inv-pow 67.9%

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

      3. associate--l+ 67.9%

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

      4. associate-+r+ 67.9%

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

      5. metadata-eval 67.9%

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

      6. associate--l+ 67.9%

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

      7. div-inv 67.9%

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

      8. div-inv 67.9%

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

      9. distribute-rgt-out 67.9%

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

      10. div-inv 67.9%

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

      11. *-commutative 67.9%

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

      12. distribute-lft-out-- 73.4%

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

   6. Applied egg-rr 73.4%

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

      1. unpow-1 73.4%

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

      2. *-commutative 73.4%

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

      3. +-commutative 73.4%

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

   8. Simplified 73.4%

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

   if -1.8999999999999998e-74 < NaChar < 1.40000000000000009e43

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.8%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]
   5. Step-by-step derivation

      1. frac-add 55.9%

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

      2. clear-num 55.9%

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

      3. *-commutative 55.9%

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

      4. distribute-lft-out 55.9%

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

   6. Applied egg-rr 55.9%

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

      1. unpow2 55.9%

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

      2. associate-/r/ 56.7%

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

      3. unpow2 56.7%

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

      4. +-commutative 56.7%

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

   8. Simplified 56.7%

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

   9. Taylor expanded in mu around inf 74.1%

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

       1. mul-1-neg 74.1%

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

       2. distribute-frac-neg 74.1%

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

   11. Simplified 74.1%

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

4. Final simplification 69.9%

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

Alternative 9: 62.1% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.26e-16) (not (<= NaChar 1.75e-7)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (* NdChar 0.5))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ Vef (- EDonor Ec))) KbT))))
    (/ NaChar (+ (/ Vef KbT) 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.26000000000000001e-16 or 1.74999999999999992e-7 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 63.2%

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

   if -1.26000000000000001e-16 < NaChar < 1.74999999999999992e-7

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 82.9%

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

   5. Taylor expanded in Vef around 0 71.2%

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

4. Final simplification 67.1%

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

Alternative 10: 60.7% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.40000000000000007e-15 or 9.200000000000001e43 < NaChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 64.8%

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

   if -1.40000000000000007e-15 < NaChar < 9.200000000000001e43

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.6%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]
   5. Step-by-step derivation

      1. frac-add 57.0%

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

      2. clear-num 57.0%

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

      3. *-commutative 57.0%

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

      4. distribute-lft-out 57.0%

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

   6. Applied egg-rr 57.0%

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

      1. unpow2 57.0%

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

      2. associate-/r/ 57.7%

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

      3. unpow2 57.7%

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

      4. +-commutative 57.7%

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

   8. Simplified 57.7%

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

   9. Taylor expanded in mu around inf 71.1%

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

       1. mul-1-neg 71.1%

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

       2. distribute-frac-neg 71.1%

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

   11. Simplified 71.1%

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

4. Final simplification 68.1%

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

Alternative 11: 47.5% accurate, 1.9× speedup

Math

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

FPCore

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

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 <= -8.5e+98) || !(KbT <= 7.2e-275)) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = (NdChar / (1.0 + exp(((mu + (Vef + (EDonor - Ec))) / KbT)))) + (KbT / (Ev / NaChar));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

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

   4. Taylor expanded in KbT around inf 60.7%

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

   if -8.4999999999999996e98 < KbT < 7.1999999999999994e-275

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 52.5%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]

   5. Taylor expanded in Ev around inf 51.1%

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

      1. associate-/l* 47.7%

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

   7. Simplified 47.7%

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

4. Final simplification 56.3%

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

Alternative 12: 47.5% accurate, 1.9× speedup

Math

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

FPCore

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

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 <= -4.3e+101) || !(KbT <= 1.7e-274)) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar * 0.5);
	} else {
		tmp = (NdChar / (1.0 + exp(((mu + (Vef + (EDonor - Ec))) / KbT)))) + (KbT / (Vef / NaChar));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

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

   4. Taylor expanded in KbT around inf 60.7%

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

   if -4.3000000000000001e101 < KbT < 1.6999999999999999e-274

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 52.5%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]

   5. Taylor expanded in Vef around inf 54.2%

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

      1. associate-/l* 55.3%

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

   7. Simplified 55.3%

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

4. Final simplification 58.9%

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

Alternative 13: 55.3% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -1.7e-4

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.3%

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

   if -1.7e-4 < NdChar < 2.54999999999999986e123

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 58.7%

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

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

   4. Taylor expanded in KbT around inf 69.2%

      \[\leadsto \frac{NdChar}{1 + e^{\frac{mu + \left(Vef + \left(EDonor - 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)}} \]

   5. Taylor expanded in Vef around inf 55.7%

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

      1. associate-/l* 64.5%

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

   7. Simplified 64.5%

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

4. Final simplification 60.2%

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

Alternative 14: 50.4% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -6.7e7

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 73.9%

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

   5. Taylor expanded in Vef around 0 65.9%

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

   6. Taylor expanded in Ec around inf 49.9%

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

      1. mul-1-neg 49.9%

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

   8. Simplified 49.9%

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

   if -6.7e7 < NdChar < 9.19999999999999962e123

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 57.8%

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

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

   4. Taylor expanded in Vef around inf 88.8%

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

   5. Taylor expanded in Vef around 0 74.7%

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

   6. Taylor expanded in EDonor around inf 50.4%

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

4. Final simplification 54.9%

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

Alternative 15: 37.4% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -2020 or 8.49999999999999966e68 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 89.8%

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

   5. Taylor expanded in Vef around 0 65.6%

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

   6. Taylor expanded in Ec around inf 43.7%

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

      1. mul-1-neg 43.7%

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

   8. Simplified 43.7%

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

   if -2020 < Vef < 8.49999999999999966e68

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 62.1%

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

   5. Taylor expanded in Ev around inf 50.7%

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

4. Final simplification 47.6%

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

Alternative 16: 40.8% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -3.4e-8 or 1.09999999999999992e-30 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 61.5%

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

   5. Taylor expanded in Ev around inf 48.4%

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

   if -3.4e-8 < NaChar < 1.09999999999999992e-30

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 82.4%

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

   5. Taylor expanded in Vef around 0 71.8%

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

   6. Taylor expanded in mu around inf 46.3%

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

4. Final simplification 47.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3.4 \cdot 10^{-8} \lor \neg \left(NaChar \leq 1.1 \cdot 10^{-30}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef}{KbT} + 2} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]

Alternative 17: 37.0% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < 7.19999999999999968e-277

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 76.2%

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

   5. Taylor expanded in Vef around 0 63.6%

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

   6. Taylor expanded in EDonor around inf 42.5%

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

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

   4. Taylor expanded in KbT around inf 55.5%

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

   5. Taylor expanded in Ev around inf 42.1%

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

4. Final simplification 42.3%

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

Alternative 18: 35.1% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < 1.09999999999999996e103

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 52.8%

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

   5. Taylor expanded in EAccept around inf 37.4%

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

   if 1.09999999999999996e103 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 92.3%

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

   5. Taylor expanded in Vef around 0 70.4%

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

   6. Taylor expanded in KbT around inf 32.0%

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

4. Final simplification 36.5%

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

Alternative 19: 35.5% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -1.05e-280

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 44.8%

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

   5. Taylor expanded in EAccept around inf 31.6%

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

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

   4. Taylor expanded in KbT around inf 51.4%

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

   5. Taylor expanded in Ev around inf 38.8%

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

4. Final simplification 35.7%

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

Alternative 20: 27.2% accurate, 7.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[(N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.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{mu + \left(Vef + \left(EDonor - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

4. Taylor expanded in Vef around inf 72.4%

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

5. Taylor expanded in Vef around 0 55.6%

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

6. Taylor expanded in KbT around inf 29.4%

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

7. Final simplification 29.4%

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

Alternative 21: 28.0% accurate, 32.7× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 48.6%

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

5. Taylor expanded in KbT around inf 27.7%

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

6. Final simplification 27.7%

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

Reproduce

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