Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 13.8s

Alternatives: 23

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

Derivation

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}}} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-exp.f64 N/A

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

   2. lift-/.f64 N/A

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

   3. clear-num N/A

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

   4. div-inv N/A

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

   5. clear-num N/A

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

   6. lift-/.f64 N/A

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

   7. exp-prod N/A

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

   8. lower-pow.f64 N/A

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

   9. lower-exp.f64 100.0

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

   10. lift-+.f64 N/A

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

   11. lift-neg.f64 N/A

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

   12. unsub-neg N/A

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

   13. lower--.f64 100.0

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

   14. lift-+.f64 N/A

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

   15. +-commutative N/A

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

   16. lower-+.f64 100.0

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

4. Applied rewrites 100.0%

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

5. Final simplification 100.0%

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

Alternative 2: 73.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\\ t_1 := \frac{NdChar}{e^{\frac{\left(mu + Vef\right) - Ec}{KbT}} + 1} + \frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ t_2 := \frac{NdChar}{e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}} + 1}\\ t_3 := \frac{NaChar}{e^{t\_0} + 1}\\ t_4 := t\_3 + t\_2\\ \mathbf{if}\;t\_4 \leq -2 \cdot 10^{-299}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_4 \leq 4 \cdot 10^{-237}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;t\_4 \leq 5 \cdot 10^{-125}:\\ \;\;\;\;\frac{NaChar}{t\_0} + t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ (- (+ (+ Ev Vef) EAccept) mu) KbT))
        (t_1
         (+
          (/ NdChar (+ (exp (/ (- (+ mu Vef) Ec) KbT)) 1.0))
          (/ NaChar (+ (exp (/ Ev KbT)) 1.0))))
        (t_2 (/ NdChar (+ (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)) 1.0)))
        (t_3 (/ NaChar (+ (exp t_0) 1.0)))
        (t_4 (+ t_3 t_2)))
   (if (<= t_4 -2e-299)
     t_1
     (if (<= t_4 4e-237)
       t_3
       (if (<= t_4 5e-125) (+ (/ NaChar t_0) t_2) t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	double t_1 = (NdChar / (exp((((mu + Vef) - Ec) / KbT)) + 1.0)) + (NaChar / (exp((Ev / KbT)) + 1.0));
	double t_2 = NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	double t_3 = NaChar / (exp(t_0) + 1.0);
	double t_4 = t_3 + t_2;
	double tmp;
	if (t_4 <= -2e-299) {
		tmp = t_1;
	} else if (t_4 <= 4e-237) {
		tmp = t_3;
	} else if (t_4 <= 5e-125) {
		tmp = (NaChar / t_0) + t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_0 = (((ev + vef) + eaccept) - mu) / kbt
    t_1 = (ndchar / (exp((((mu + vef) - ec) / kbt)) + 1.0d0)) + (nachar / (exp((ev / kbt)) + 1.0d0))
    t_2 = ndchar / (exp(((mu - ((ec - vef) - edonor)) / kbt)) + 1.0d0)
    t_3 = nachar / (exp(t_0) + 1.0d0)
    t_4 = t_3 + t_2
    if (t_4 <= (-2d-299)) then
        tmp = t_1
    else if (t_4 <= 4d-237) then
        tmp = t_3
    else if (t_4 <= 5d-125) then
        tmp = (nachar / t_0) + t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	double t_1 = (NdChar / (Math.exp((((mu + Vef) - Ec) / KbT)) + 1.0)) + (NaChar / (Math.exp((Ev / KbT)) + 1.0));
	double t_2 = NdChar / (Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	double t_3 = NaChar / (Math.exp(t_0) + 1.0);
	double t_4 = t_3 + t_2;
	double tmp;
	if (t_4 <= -2e-299) {
		tmp = t_1;
	} else if (t_4 <= 4e-237) {
		tmp = t_3;
	} else if (t_4 <= 5e-125) {
		tmp = (NaChar / t_0) + t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (((Ev + Vef) + EAccept) - mu) / KbT
	t_1 = (NdChar / (math.exp((((mu + Vef) - Ec) / KbT)) + 1.0)) + (NaChar / (math.exp((Ev / KbT)) + 1.0))
	t_2 = NdChar / (math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0)
	t_3 = NaChar / (math.exp(t_0) + 1.0)
	t_4 = t_3 + t_2
	tmp = 0
	if t_4 <= -2e-299:
		tmp = t_1
	elif t_4 <= 4e-237:
		tmp = t_3
	elif t_4 <= 5e-125:
		tmp = (NaChar / t_0) + t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - mu) / KbT)
	t_1 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0)))
	t_2 = Float64(NdChar / Float64(exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)) + 1.0))
	t_3 = Float64(NaChar / Float64(exp(t_0) + 1.0))
	t_4 = Float64(t_3 + t_2)
	tmp = 0.0
	if (t_4 <= -2e-299)
		tmp = t_1;
	elseif (t_4 <= 4e-237)
		tmp = t_3;
	elseif (t_4 <= 5e-125)
		tmp = Float64(Float64(NaChar / t_0) + t_2);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	t_1 = (NdChar / (exp((((mu + Vef) - Ec) / KbT)) + 1.0)) + (NaChar / (exp((Ev / KbT)) + 1.0));
	t_2 = NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	t_3 = NaChar / (exp(t_0) + 1.0);
	t_4 = t_3 + t_2;
	tmp = 0.0;
	if (t_4 <= -2e-299)
		tmp = t_1;
	elseif (t_4 <= 4e-237)
		tmp = t_3;
	elseif (t_4 <= 5e-125)
		tmp = (NaChar / t_0) + t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1.99999999999999998e-299 or 4.99999999999999967e-125 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 76.2

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

   5. Applied rewrites 76.2%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 72.3

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

   8. Applied rewrites 72.3%

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

   if -1.99999999999999998e-299 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 4e-237

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 94.7

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

   5. Applied rewrites 94.7%

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

   if 4e-237 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 4.99999999999999967e-125

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. lower--.f64 N/A

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

      2. associate-+r+ N/A

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

      3. lower-+.f64 N/A

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

      4. lower-+.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. +-commutative N/A

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

      7. lower-+.f64 N/A

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

      8. lower-/.f64 N/A

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

      9. lower-/.f64 N/A

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

      10. lower-/.f64 65.0

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

   5. Applied rewrites 65.0%

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

   6. Taylor expanded in KbT around 0

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

   8. Applied rewrites 79.6%

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

4. Final simplification 77.3%

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

Alternative 3: 66.9% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\\ t_1 := \frac{NdChar}{e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}} + 1}\\ t_2 := \frac{NaChar}{e^{t\_0} + 1}\\ t_3 := 0.5 \cdot NdChar + t\_2\\ t_4 := t\_2 + t\_1\\ \mathbf{if}\;t\_4 \leq -1 \cdot 10^{-42}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;t\_4 \leq 4 \cdot 10^{-237}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_4 \leq 10^{-73}:\\ \;\;\;\;\frac{NaChar}{t\_0} + t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ (- (+ (+ Ev Vef) EAccept) mu) KbT))
        (t_1 (/ NdChar (+ (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)) 1.0)))
        (t_2 (/ NaChar (+ (exp t_0) 1.0)))
        (t_3 (+ (* 0.5 NdChar) t_2))
        (t_4 (+ t_2 t_1)))
   (if (<= t_4 -1e-42)
     t_3
     (if (<= t_4 4e-237) t_2 (if (<= t_4 1e-73) (+ (/ NaChar t_0) t_1) t_3)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	double t_1 = NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	double t_2 = NaChar / (exp(t_0) + 1.0);
	double t_3 = (0.5 * NdChar) + t_2;
	double t_4 = t_2 + t_1;
	double tmp;
	if (t_4 <= -1e-42) {
		tmp = t_3;
	} else if (t_4 <= 4e-237) {
		tmp = t_2;
	} else if (t_4 <= 1e-73) {
		tmp = (NaChar / t_0) + t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_0 = (((ev + vef) + eaccept) - mu) / kbt
    t_1 = ndchar / (exp(((mu - ((ec - vef) - edonor)) / kbt)) + 1.0d0)
    t_2 = nachar / (exp(t_0) + 1.0d0)
    t_3 = (0.5d0 * ndchar) + t_2
    t_4 = t_2 + t_1
    if (t_4 <= (-1d-42)) then
        tmp = t_3
    else if (t_4 <= 4d-237) then
        tmp = t_2
    else if (t_4 <= 1d-73) then
        tmp = (nachar / t_0) + t_1
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	double t_1 = NdChar / (Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	double t_2 = NaChar / (Math.exp(t_0) + 1.0);
	double t_3 = (0.5 * NdChar) + t_2;
	double t_4 = t_2 + t_1;
	double tmp;
	if (t_4 <= -1e-42) {
		tmp = t_3;
	} else if (t_4 <= 4e-237) {
		tmp = t_2;
	} else if (t_4 <= 1e-73) {
		tmp = (NaChar / t_0) + t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (((Ev + Vef) + EAccept) - mu) / KbT
	t_1 = NdChar / (math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0)
	t_2 = NaChar / (math.exp(t_0) + 1.0)
	t_3 = (0.5 * NdChar) + t_2
	t_4 = t_2 + t_1
	tmp = 0
	if t_4 <= -1e-42:
		tmp = t_3
	elif t_4 <= 4e-237:
		tmp = t_2
	elif t_4 <= 1e-73:
		tmp = (NaChar / t_0) + t_1
	else:
		tmp = t_3
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - mu) / KbT)
	t_1 = Float64(NdChar / Float64(exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)) + 1.0))
	t_2 = Float64(NaChar / Float64(exp(t_0) + 1.0))
	t_3 = Float64(Float64(0.5 * NdChar) + t_2)
	t_4 = Float64(t_2 + t_1)
	tmp = 0.0
	if (t_4 <= -1e-42)
		tmp = t_3;
	elseif (t_4 <= 4e-237)
		tmp = t_2;
	elseif (t_4 <= 1e-73)
		tmp = Float64(Float64(NaChar / t_0) + t_1);
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	t_1 = NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	t_2 = NaChar / (exp(t_0) + 1.0);
	t_3 = (0.5 * NdChar) + t_2;
	t_4 = t_2 + t_1;
	tmp = 0.0;
	if (t_4 <= -1e-42)
		tmp = t_3;
	elseif (t_4 <= 4e-237)
		tmp = t_2;
	elseif (t_4 <= 1e-73)
		tmp = (NaChar / t_0) + t_1;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1.00000000000000004e-42 or 9.99999999999999997e-74 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 68.6

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

   5. Applied rewrites 68.6%

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

   if -1.00000000000000004e-42 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 4e-237

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 79.7

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

   5. Applied rewrites 79.7%

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

   if 4e-237 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 9.99999999999999997e-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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower--.f64 N/A

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

      2. associate-+r+ N/A

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

      3. lower-+.f64 N/A

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

      4. lower-+.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. +-commutative N/A

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

      7. lower-+.f64 N/A

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

      8. lower-/.f64 N/A

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

      9. lower-/.f64 N/A

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

      10. lower-/.f64 58.0

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

   5. Applied rewrites 58.0%

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

   6. Taylor expanded in KbT around 0

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

   8. Applied rewrites 64.8%

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

4. Final simplification 72.0%

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

Alternative 4: 66.6% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\\ t_1 := \frac{NaChar}{e^{t\_0} + 1}\\ t_2 := 0.5 \cdot NdChar + t\_1\\ t_3 := t\_1 + \frac{NdChar}{e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}} + 1}\\ \mathbf{if}\;t\_3 \leq -1 \cdot 10^{-42}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 4 \cdot 10^{-237}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_3 \leq 10^{-73}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(mu + EDonor\right) - Ec}{KbT}} + 1} + \frac{NaChar}{t\_0}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ (- (+ (+ Ev Vef) EAccept) mu) KbT))
        (t_1 (/ NaChar (+ (exp t_0) 1.0)))
        (t_2 (+ (* 0.5 NdChar) t_1))
        (t_3
         (+
          t_1
          (/ NdChar (+ (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)) 1.0)))))
   (if (<= t_3 -1e-42)
     t_2
     (if (<= t_3 4e-237)
       t_1
       (if (<= t_3 1e-73)
         (+
          (/ NdChar (+ (exp (/ (- (+ mu EDonor) Ec) KbT)) 1.0))
          (/ NaChar t_0))
         t_2)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	double t_1 = NaChar / (exp(t_0) + 1.0);
	double t_2 = (0.5 * NdChar) + t_1;
	double t_3 = t_1 + (NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	double tmp;
	if (t_3 <= -1e-42) {
		tmp = t_2;
	} else if (t_3 <= 4e-237) {
		tmp = t_1;
	} else if (t_3 <= 1e-73) {
		tmp = (NdChar / (exp((((mu + EDonor) - Ec) / KbT)) + 1.0)) + (NaChar / t_0);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = (((ev + vef) + eaccept) - mu) / kbt
    t_1 = nachar / (exp(t_0) + 1.0d0)
    t_2 = (0.5d0 * ndchar) + t_1
    t_3 = t_1 + (ndchar / (exp(((mu - ((ec - vef) - edonor)) / kbt)) + 1.0d0))
    if (t_3 <= (-1d-42)) then
        tmp = t_2
    else if (t_3 <= 4d-237) then
        tmp = t_1
    else if (t_3 <= 1d-73) then
        tmp = (ndchar / (exp((((mu + edonor) - ec) / kbt)) + 1.0d0)) + (nachar / t_0)
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	double t_1 = NaChar / (Math.exp(t_0) + 1.0);
	double t_2 = (0.5 * NdChar) + t_1;
	double t_3 = t_1 + (NdChar / (Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	double tmp;
	if (t_3 <= -1e-42) {
		tmp = t_2;
	} else if (t_3 <= 4e-237) {
		tmp = t_1;
	} else if (t_3 <= 1e-73) {
		tmp = (NdChar / (Math.exp((((mu + EDonor) - Ec) / KbT)) + 1.0)) + (NaChar / t_0);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (((Ev + Vef) + EAccept) - mu) / KbT
	t_1 = NaChar / (math.exp(t_0) + 1.0)
	t_2 = (0.5 * NdChar) + t_1
	t_3 = t_1 + (NdChar / (math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0))
	tmp = 0
	if t_3 <= -1e-42:
		tmp = t_2
	elif t_3 <= 4e-237:
		tmp = t_1
	elif t_3 <= 1e-73:
		tmp = (NdChar / (math.exp((((mu + EDonor) - Ec) / KbT)) + 1.0)) + (NaChar / t_0)
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - mu) / KbT)
	t_1 = Float64(NaChar / Float64(exp(t_0) + 1.0))
	t_2 = Float64(Float64(0.5 * NdChar) + t_1)
	t_3 = Float64(t_1 + Float64(NdChar / Float64(exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)) + 1.0)))
	tmp = 0.0
	if (t_3 <= -1e-42)
		tmp = t_2;
	elseif (t_3 <= 4e-237)
		tmp = t_1;
	elseif (t_3 <= 1e-73)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Float64(Float64(mu + EDonor) - Ec) / KbT)) + 1.0)) + Float64(NaChar / t_0));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (((Ev + Vef) + EAccept) - mu) / KbT;
	t_1 = NaChar / (exp(t_0) + 1.0);
	t_2 = (0.5 * NdChar) + t_1;
	t_3 = t_1 + (NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	tmp = 0.0;
	if (t_3 <= -1e-42)
		tmp = t_2;
	elseif (t_3 <= 4e-237)
		tmp = t_1;
	elseif (t_3 <= 1e-73)
		tmp = (NdChar / (exp((((mu + EDonor) - Ec) / KbT)) + 1.0)) + (NaChar / t_0);
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1.00000000000000004e-42 or 9.99999999999999997e-74 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 68.6

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

   5. Applied rewrites 68.6%

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

   if -1.00000000000000004e-42 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 4e-237

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 79.7

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

   5. Applied rewrites 79.7%

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

   if 4e-237 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 9.99999999999999997e-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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower--.f64 N/A

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

      2. associate-+r+ N/A

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

      3. lower-+.f64 N/A

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

      4. lower-+.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. +-commutative N/A

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

      7. lower-+.f64 N/A

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

      8. lower-/.f64 N/A

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

      9. lower-/.f64 N/A

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

      10. lower-/.f64 58.0

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

   5. Applied rewrites 58.0%

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

   6. Taylor expanded in KbT around 0

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

   8. Applied rewrites 64.8%

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

   9. Taylor expanded in Vef around 0

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

       1. lower--.f64 N/A

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

       2. +-commutative N/A

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

       3. lower-+.f64 58.9

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

   11. Applied rewrites 58.9%

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

4. Final simplification 71.3%

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

Alternative 5: 67.0% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}} + 1}\\ t_1 := \frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} + 1}\\ t_2 := 0.5 \cdot NdChar + t\_1\\ t_3 := t\_1 + t\_0\\ \mathbf{if}\;t\_3 \leq -1 \cdot 10^{-42}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 4 \cdot 10^{-240}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_3 \leq 4 \cdot 10^{-29}:\\ \;\;\;\;\frac{NaChar}{2} + t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)) 1.0)))
        (t_1 (/ NaChar (+ (exp (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) 1.0)))
        (t_2 (+ (* 0.5 NdChar) t_1))
        (t_3 (+ t_1 t_0)))
   (if (<= t_3 -1e-42)
     t_2
     (if (<= t_3 4e-240) t_1 (if (<= t_3 4e-29) (+ (/ NaChar 2.0) t_0) t_2)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	double t_1 = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) + 1.0);
	double t_2 = (0.5 * NdChar) + t_1;
	double t_3 = t_1 + t_0;
	double tmp;
	if (t_3 <= -1e-42) {
		tmp = t_2;
	} else if (t_3 <= 4e-240) {
		tmp = t_1;
	} else if (t_3 <= 4e-29) {
		tmp = (NaChar / 2.0) + t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (exp(((mu - ((ec - vef) - edonor)) / kbt)) + 1.0d0)
    t_1 = nachar / (exp(((((ev + vef) + eaccept) - mu) / kbt)) + 1.0d0)
    t_2 = (0.5d0 * ndchar) + t_1
    t_3 = t_1 + t_0
    if (t_3 <= (-1d-42)) then
        tmp = t_2
    else if (t_3 <= 4d-240) then
        tmp = t_1
    else if (t_3 <= 4d-29) then
        tmp = (nachar / 2.0d0) + t_0
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	double t_1 = NaChar / (Math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) + 1.0);
	double t_2 = (0.5 * NdChar) + t_1;
	double t_3 = t_1 + t_0;
	double tmp;
	if (t_3 <= -1e-42) {
		tmp = t_2;
	} else if (t_3 <= 4e-240) {
		tmp = t_1;
	} else if (t_3 <= 4e-29) {
		tmp = (NaChar / 2.0) + t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0)
	t_1 = NaChar / (math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) + 1.0)
	t_2 = (0.5 * NdChar) + t_1
	t_3 = t_1 + t_0
	tmp = 0
	if t_3 <= -1e-42:
		tmp = t_2
	elif t_3 <= 4e-240:
		tmp = t_1
	elif t_3 <= 4e-29:
		tmp = (NaChar / 2.0) + t_0
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)) + 1.0))
	t_1 = Float64(NaChar / Float64(exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - mu) / KbT)) + 1.0))
	t_2 = Float64(Float64(0.5 * NdChar) + t_1)
	t_3 = Float64(t_1 + t_0)
	tmp = 0.0
	if (t_3 <= -1e-42)
		tmp = t_2;
	elseif (t_3 <= 4e-240)
		tmp = t_1;
	elseif (t_3 <= 4e-29)
		tmp = Float64(Float64(NaChar / 2.0) + t_0);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	t_1 = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) + 1.0);
	t_2 = (0.5 * NdChar) + t_1;
	t_3 = t_1 + t_0;
	tmp = 0.0;
	if (t_3 <= -1e-42)
		tmp = t_2;
	elseif (t_3 <= 4e-240)
		tmp = t_1;
	elseif (t_3 <= 4e-29)
		tmp = (NaChar / 2.0) + t_0;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1.00000000000000004e-42 or 3.99999999999999977e-29 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 68.2

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

   5. Applied rewrites 68.2%

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

   if -1.00000000000000004e-42 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 3.9999999999999999e-240

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 79.5

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

   5. Applied rewrites 79.5%

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

   if 3.9999999999999999e-240 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 3.99999999999999977e-29

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

   5. Applied rewrites 58.6%

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

4. Final simplification 70.6%

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

Alternative 6: 67.9% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} + 1}\\ t_1 := 0.5 \cdot NdChar + t\_0\\ t_2 := t\_0 + \frac{NdChar}{e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}} + 1}\\ \mathbf{if}\;t\_2 \leq -1 \cdot 10^{-42}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-77}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ (exp (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) 1.0)))
        (t_1 (+ (* 0.5 NdChar) t_0))
        (t_2
         (+
          t_0
          (/ NdChar (+ (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)) 1.0)))))
   (if (<= t_2 -1e-42) t_1 (if (<= t_2 5e-77) t_0 t_1))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) + 1.0);
	double t_1 = (0.5 * NdChar) + t_0;
	double t_2 = t_0 + (NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	double tmp;
	if (t_2 <= -1e-42) {
		tmp = t_1;
	} else if (t_2 <= 5e-77) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (exp(((((ev + vef) + eaccept) - mu) / kbt)) + 1.0d0)
    t_1 = (0.5d0 * ndchar) + t_0
    t_2 = t_0 + (ndchar / (exp(((mu - ((ec - vef) - edonor)) / kbt)) + 1.0d0))
    if (t_2 <= (-1d-42)) then
        tmp = t_1
    else if (t_2 <= 5d-77) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (Math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) + 1.0);
	double t_1 = (0.5 * NdChar) + t_0;
	double t_2 = t_0 + (NdChar / (Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	double tmp;
	if (t_2 <= -1e-42) {
		tmp = t_1;
	} else if (t_2 <= 5e-77) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) + 1.0)
	t_1 = (0.5 * NdChar) + t_0
	t_2 = t_0 + (NdChar / (math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0))
	tmp = 0
	if t_2 <= -1e-42:
		tmp = t_1
	elif t_2 <= 5e-77:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - mu) / KbT)) + 1.0))
	t_1 = Float64(Float64(0.5 * NdChar) + t_0)
	t_2 = Float64(t_0 + Float64(NdChar / Float64(exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)) + 1.0)))
	tmp = 0.0
	if (t_2 <= -1e-42)
		tmp = t_1;
	elseif (t_2 <= 5e-77)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) + 1.0);
	t_1 = (0.5 * NdChar) + t_0;
	t_2 = t_0 + (NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	tmp = 0.0;
	if (t_2 <= -1e-42)
		tmp = t_1;
	elseif (t_2 <= 5e-77)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1.00000000000000004e-42 or 4.99999999999999963e-77 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 67.9

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

   5. Applied rewrites 67.9%

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

   if -1.00000000000000004e-42 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 4.99999999999999963e-77

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 69.9

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

   5. Applied rewrites 69.9%

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

4. Final simplification 68.8%

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

Alternative 7: 37.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(Ev + Vef\right) + EAccept\\ t_1 := \left(NaChar + NdChar\right) \cdot 0.5\\ t_2 := \frac{NaChar}{e^{\frac{t\_0 - mu}{KbT}} + 1} + \frac{NdChar}{e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}} + 1}\\ \mathbf{if}\;t\_2 \leq -2 \cdot 10^{-299}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_2 \leq 4 \cdot 10^{-237}:\\ \;\;\;\;\frac{NaChar}{2 - \frac{mu - t\_0}{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 (+ (+ Ev Vef) EAccept))
        (t_1 (* (+ NaChar NdChar) 0.5))
        (t_2
         (+
          (/ NaChar (+ (exp (/ (- t_0 mu) KbT)) 1.0))
          (/ NdChar (+ (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)) 1.0)))))
   (if (<= t_2 -2e-299)
     t_1
     (if (<= t_2 4e-237) (/ NaChar (- 2.0 (/ (- mu t_0) 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 = (Ev + Vef) + EAccept;
	double t_1 = (NaChar + NdChar) * 0.5;
	double t_2 = (NaChar / (exp(((t_0 - mu) / KbT)) + 1.0)) + (NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	double tmp;
	if (t_2 <= -2e-299) {
		tmp = t_1;
	} else if (t_2 <= 4e-237) {
		tmp = NaChar / (2.0 - ((mu - t_0) / KbT));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (ev + vef) + eaccept
    t_1 = (nachar + ndchar) * 0.5d0
    t_2 = (nachar / (exp(((t_0 - mu) / kbt)) + 1.0d0)) + (ndchar / (exp(((mu - ((ec - vef) - edonor)) / kbt)) + 1.0d0))
    if (t_2 <= (-2d-299)) then
        tmp = t_1
    else if (t_2 <= 4d-237) then
        tmp = nachar / (2.0d0 - ((mu - t_0) / 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 = (Ev + Vef) + EAccept;
	double t_1 = (NaChar + NdChar) * 0.5;
	double t_2 = (NaChar / (Math.exp(((t_0 - mu) / KbT)) + 1.0)) + (NdChar / (Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	double tmp;
	if (t_2 <= -2e-299) {
		tmp = t_1;
	} else if (t_2 <= 4e-237) {
		tmp = NaChar / (2.0 - ((mu - t_0) / KbT));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (Ev + Vef) + EAccept
	t_1 = (NaChar + NdChar) * 0.5
	t_2 = (NaChar / (math.exp(((t_0 - mu) / KbT)) + 1.0)) + (NdChar / (math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0))
	tmp = 0
	if t_2 <= -2e-299:
		tmp = t_1
	elif t_2 <= 4e-237:
		tmp = NaChar / (2.0 - ((mu - t_0) / KbT))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(Ev + Vef) + EAccept)
	t_1 = Float64(Float64(NaChar + NdChar) * 0.5)
	t_2 = Float64(Float64(NaChar / Float64(exp(Float64(Float64(t_0 - mu) / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)) + 1.0)))
	tmp = 0.0
	if (t_2 <= -2e-299)
		tmp = t_1;
	elseif (t_2 <= 4e-237)
		tmp = Float64(NaChar / Float64(2.0 - Float64(Float64(mu - t_0) / 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 = (Ev + Vef) + EAccept;
	t_1 = (NaChar + NdChar) * 0.5;
	t_2 = (NaChar / (exp(((t_0 - mu) / KbT)) + 1.0)) + (NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0));
	tmp = 0.0;
	if (t_2 <= -2e-299)
		tmp = t_1;
	elseif (t_2 <= 4e-237)
		tmp = NaChar / (2.0 - ((mu - t_0) / 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[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(N[Exp[N[(N[(t$95$0 - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[Exp[N[(N[(mu - N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -2e-299], t$95$1, If[LessEqual[t$95$2, 4e-237], N[(NaChar / N[(2.0 - N[(N[(mu - t$95$0), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1.99999999999999998e-299 or 4e-237 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 34.0

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

   5. Applied rewrites 34.0%

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

   if -1.99999999999999998e-299 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 4e-237

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 94.7

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

   5. Applied rewrites 94.7%

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

   7. Applied rewrites 94.7%

      \[\leadsto \frac{NaChar}{{\mathsf{E}\left(\right)}^{\left(\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\right)} + 1} \]

   8. Taylor expanded in KbT around inf

      \[\leadsto \frac{NaChar}{2 + \color{blue}{\frac{\log \mathsf{E}\left(\right) \cdot \left(\left(EAccept + \left(Ev + Vef\right)\right) - mu\right)}{KbT}}} \]
   9. Step-by-step derivation

   10. Applied rewrites 50.4%

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

4. Final simplification 37.4%

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

Alternative 8: 76.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}} + 1}\\ t_1 := \frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + t\_0\\ t_2 := \frac{NdChar}{e^{\frac{\left(mu + Vef\right) - Ec}{KbT}} + 1} + \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{if}\;Vef \leq -4.15 \cdot 10^{+111}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;Vef \leq -20500:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq 5.1 \cdot 10^{-138}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1} + t\_0\\ \mathbf{elif}\;Vef \leq 2.6 \cdot 10^{+84}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)) 1.0)))
        (t_1 (+ (/ NaChar (+ (exp (/ EAccept KbT)) 1.0)) t_0))
        (t_2
         (+
          (/ NdChar (+ (exp (/ (- (+ mu Vef) Ec) KbT)) 1.0))
          (/ NaChar (+ (exp (/ Vef KbT)) 1.0)))))
   (if (<= Vef -4.15e+111)
     t_2
     (if (<= Vef -20500.0)
       t_1
       (if (<= Vef 5.1e-138)
         (+ (/ NaChar (+ (exp (/ Ev KbT)) 1.0)) t_0)
         (if (<= Vef 2.6e+84) t_1 t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	double t_1 = (NaChar / (exp((EAccept / KbT)) + 1.0)) + t_0;
	double t_2 = (NdChar / (exp((((mu + Vef) - Ec) / KbT)) + 1.0)) + (NaChar / (exp((Vef / KbT)) + 1.0));
	double tmp;
	if (Vef <= -4.15e+111) {
		tmp = t_2;
	} else if (Vef <= -20500.0) {
		tmp = t_1;
	} else if (Vef <= 5.1e-138) {
		tmp = (NaChar / (exp((Ev / KbT)) + 1.0)) + t_0;
	} else if (Vef <= 2.6e+84) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (exp(((mu - ((ec - vef) - edonor)) / kbt)) + 1.0d0)
    t_1 = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + t_0
    t_2 = (ndchar / (exp((((mu + vef) - ec) / kbt)) + 1.0d0)) + (nachar / (exp((vef / kbt)) + 1.0d0))
    if (vef <= (-4.15d+111)) then
        tmp = t_2
    else if (vef <= (-20500.0d0)) then
        tmp = t_1
    else if (vef <= 5.1d-138) then
        tmp = (nachar / (exp((ev / kbt)) + 1.0d0)) + t_0
    else if (vef <= 2.6d+84) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	double t_1 = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + t_0;
	double t_2 = (NdChar / (Math.exp((((mu + Vef) - Ec) / KbT)) + 1.0)) + (NaChar / (Math.exp((Vef / KbT)) + 1.0));
	double tmp;
	if (Vef <= -4.15e+111) {
		tmp = t_2;
	} else if (Vef <= -20500.0) {
		tmp = t_1;
	} else if (Vef <= 5.1e-138) {
		tmp = (NaChar / (Math.exp((Ev / KbT)) + 1.0)) + t_0;
	} else if (Vef <= 2.6e+84) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0)
	t_1 = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + t_0
	t_2 = (NdChar / (math.exp((((mu + Vef) - Ec) / KbT)) + 1.0)) + (NaChar / (math.exp((Vef / KbT)) + 1.0))
	tmp = 0
	if Vef <= -4.15e+111:
		tmp = t_2
	elif Vef <= -20500.0:
		tmp = t_1
	elif Vef <= 5.1e-138:
		tmp = (NaChar / (math.exp((Ev / KbT)) + 1.0)) + t_0
	elif Vef <= 2.6e+84:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)) + 1.0))
	t_1 = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + t_0)
	t_2 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(Vef / KbT)) + 1.0)))
	tmp = 0.0
	if (Vef <= -4.15e+111)
		tmp = t_2;
	elseif (Vef <= -20500.0)
		tmp = t_1;
	elseif (Vef <= 5.1e-138)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0)) + t_0);
	elseif (Vef <= 2.6e+84)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (exp(((mu - ((Ec - Vef) - EDonor)) / KbT)) + 1.0);
	t_1 = (NaChar / (exp((EAccept / KbT)) + 1.0)) + t_0;
	t_2 = (NdChar / (exp((((mu + Vef) - Ec) / KbT)) + 1.0)) + (NaChar / (exp((Vef / KbT)) + 1.0));
	tmp = 0.0;
	if (Vef <= -4.15e+111)
		tmp = t_2;
	elseif (Vef <= -20500.0)
		tmp = t_1;
	elseif (Vef <= 5.1e-138)
		tmp = (NaChar / (exp((Ev / KbT)) + 1.0)) + t_0;
	elseif (Vef <= 2.6e+84)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Vef < -4.14999999999999988e111 or 2.6000000000000001e84 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Vef around inf

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

      1. lower-/.f64 91.6

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

   5. Applied rewrites 91.6%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 88.3

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

   8. Applied rewrites 88.3%

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

   if -4.14999999999999988e111 < Vef < -20500 or 5.1000000000000002e-138 < Vef < 2.6000000000000001e84

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in EAccept around inf

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

      1. lower-/.f64 82.9

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

   5. Applied rewrites 82.9%

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

   if -20500 < Vef < 5.1000000000000002e-138

   1. Initial program 100.0%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 77.9

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

   5. Applied rewrites 77.9%

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

4. Final simplification 82.8%

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

Alternative 9: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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}}} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-exp.f64 N/A

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

   2. lift-/.f64 N/A

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

   3. frac-2neg N/A

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

   4. distribute-frac-neg N/A

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

   5. exp-neg N/A

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

   6. lower-/.f64 N/A

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

   7. lower-exp.f64 N/A

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

   8. lower-/.f64 N/A

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

   9. lift-+.f64 N/A

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

   10. lift-neg.f64 N/A

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

   11. unsub-neg N/A

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

   12. lower--.f64 N/A

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

   13. lift-+.f64 N/A

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

   14. +-commutative N/A

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

   15. lower-+.f64 N/A

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

   16. lower-neg.f64 99.9

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

4. Applied rewrites 99.9%

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

5. Final simplification 99.9%

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

Alternative 10: 72.6% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -2.7000000000000002e143

   1. Initial program 99.8%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 86.6

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

   5. Applied rewrites 86.6%

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

   if -2.7000000000000002e143 < Ev < 2.5000000000000001e-157

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Vef around inf

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

      1. lower-/.f64 79.7

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

   5. Applied rewrites 79.7%

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

   if 2.5000000000000001e-157 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in EAccept around inf

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

      1. lower-/.f64 68.4

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

   5. Applied rewrites 68.4%

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

4. Final simplification 76.3%

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

Alternative 11: 76.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -4.14999999999999988e111 or 2.6000000000000001e84 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Vef around inf

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

      1. lower-/.f64 91.6

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

   5. Applied rewrites 91.6%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 88.3

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

   8. Applied rewrites 88.3%

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

   if -4.14999999999999988e111 < Vef < 2.6000000000000001e84

   1. Initial program 100.0%

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

   3. Taylor expanded in EAccept around inf

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

      1. lower-/.f64 73.6

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

   5. Applied rewrites 73.6%

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

4. Final simplification 78.4%

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

Alternative 12: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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}}} \]
2. Add Preprocessing

3. Final simplification 99.9%

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

Alternative 13: 67.4% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -2.7000000000000002e143

   1. Initial program 99.8%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 86.6

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

   5. Applied rewrites 86.6%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 80.0

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

   8. Applied rewrites 80.0%

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

   if -2.7000000000000002e143 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Vef around inf

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

      1. lower-/.f64 77.6

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

   5. Applied rewrites 77.6%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 71.5

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

   8. Applied rewrites 71.5%

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

4. Final simplification 72.9%

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

Alternative 14: 62.7% accurate, 1.9× speedup

Math

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

FPCore

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

Derivation

1. Split input into 2 regimes

2. if KbT < 1.10000000000000002e211

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 61.2

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

   5. Applied rewrites 61.2%

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

   7. Applied rewrites 61.2%

      \[\leadsto \frac{NaChar}{{\mathsf{E}\left(\right)}^{\left(\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\right)} + 1} \]

   if 1.10000000000000002e211 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 91.0

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

   5. Applied rewrites 91.0%

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

   6. Taylor expanded in KbT around inf

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

   8. Applied rewrites 86.2%

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

4. Final simplification 63.2%

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

Alternative 15: 62.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq 1.15 \cdot 10^{+211}:\\ \;\;\;\;\frac{NaChar}{{\mathsf{E}\left(\right)}^{\left(\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\right)} + 1}\\ \mathbf{else}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT 1.15e+211)
   (/ NaChar (+ (pow (E) (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) 1.0))
   (* (+ NaChar NdChar) 0.5)))

Derivation

1. Split input into 2 regimes

2. if KbT < 1.15000000000000005e211

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 61.2

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

   5. Applied rewrites 61.2%

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

   7. Applied rewrites 61.2%

      \[\leadsto \frac{NaChar}{{\mathsf{E}\left(\right)}^{\left(\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\right)} + 1} \]

   if 1.15000000000000005e211 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 78.1

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

   5. Applied rewrites 78.1%

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

4. Final simplification 62.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq 1.15 \cdot 10^{+211}:\\ \;\;\;\;\frac{NaChar}{{\mathsf{E}\left(\right)}^{\left(\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\right)} + 1}\\ \mathbf{else}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 47.0% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 8.2 \cdot 10^{+43}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev - mu}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 1.08 \cdot 10^{+60}:\\ \;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(\frac{\frac{NaChar \cdot NaChar}{NdChar} - NaChar}{NdChar}, -1, -1\right)}{-NdChar}} \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept - mu}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 8.2e+43)
   (/ NaChar (+ (exp (/ (- Ev mu) KbT)) 1.0))
   (if (<= EAccept 1.08e+60)
     (*
      (/
       1.0
       (/
        (fma (/ (- (/ (* NaChar NaChar) NdChar) NaChar) NdChar) -1.0 -1.0)
        (- NdChar)))
      0.5)
     (/ NaChar (+ (exp (/ (- EAccept mu) KbT)) 1.0)))))

C

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

Julia

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < 8.2000000000000001e43

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 59.5

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

   5. Applied rewrites 59.5%

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

   7. Applied rewrites 59.5%

      \[\leadsto \frac{NaChar}{{\mathsf{E}\left(\right)}^{\left(\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\right)} + 1} \]

   8. Taylor expanded in Vef around 0

      \[\leadsto \frac{NaChar}{e^{\frac{\log \mathsf{E}\left(\right) \cdot \left(\left(EAccept + Ev\right) - mu\right)}{KbT}} + 1} \]
   9. Step-by-step derivation

   10. Applied rewrites 51.6%

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

   11. Taylor expanded in EAccept around 0

       \[\leadsto \frac{NaChar}{e^{\frac{Ev - mu}{KbT}} + 1} \]
   12. Step-by-step derivation

   13. Applied rewrites 48.5%

       \[\leadsto \frac{NaChar}{e^{\frac{Ev - mu}{KbT}} + 1} \]

   if 8.2000000000000001e43 < EAccept < 1.08e60

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 45.8

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

   5. Applied rewrites 45.8%

      \[\leadsto \color{blue}{0.5 \cdot \left(NdChar + NaChar\right)} \]
   6. Step-by-step derivation

   7. Applied rewrites 27.7%

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

   8. Taylor expanded in NdChar around -inf

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

   10. Applied rewrites 40.3%

       \[\leadsto 0.5 \cdot \frac{1}{\frac{\mathsf{fma}\left(\frac{\frac{NaChar \cdot NaChar}{NdChar} - NaChar}{NdChar}, -1, -1\right)}{\color{blue}{-NdChar}}} \]

   if 1.08e60 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 60.0

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

   5. Applied rewrites 60.0%

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

   7. Applied rewrites 60.0%

      \[\leadsto \frac{NaChar}{{\mathsf{E}\left(\right)}^{\left(\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\right)} + 1} \]

   8. Taylor expanded in Vef around 0

      \[\leadsto \frac{NaChar}{e^{\frac{\log \mathsf{E}\left(\right) \cdot \left(\left(EAccept + Ev\right) - mu\right)}{KbT}} + 1} \]
   9. Step-by-step derivation

   10. Applied rewrites 54.2%

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

   11. Taylor expanded in Ev around 0

       \[\leadsto \frac{NaChar}{e^{\frac{EAccept - mu}{KbT}} + 1} \]
   12. Step-by-step derivation

   13. Applied rewrites 49.9%

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

4. Final simplification 48.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 8.2 \cdot 10^{+43}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev - mu}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 1.08 \cdot 10^{+60}:\\ \;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(\frac{\frac{NaChar \cdot NaChar}{NdChar} - NaChar}{NdChar}, -1, -1\right)}{-NdChar}} \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept - mu}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 62.5% accurate, 2.0× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < 1.15000000000000005e211

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 61.2

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

   5. Applied rewrites 61.2%

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

   if 1.15000000000000005e211 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 78.1

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

   5. Applied rewrites 78.1%

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

4. Final simplification 62.5%

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

Alternative 18: 56.1% accurate, 2.0× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < 1.10000000000000002e211

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 61.2

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

   5. Applied rewrites 61.2%

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

   6. Taylor expanded in Ev around 0

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

   8. Applied rewrites 54.5%

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

   if 1.10000000000000002e211 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 78.1

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

   5. Applied rewrites 78.1%

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

4. Final simplification 56.4%

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

Alternative 19: 56.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq 1.15 \cdot 10^{+211}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(Ev + Vef\right) + EAccept}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < 1.15000000000000005e211

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 61.2

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

   5. Applied rewrites 61.2%

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

   6. Taylor expanded in mu around 0

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

   8. Applied rewrites 56.4%

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

   if 1.15000000000000005e211 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 78.1

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

   5. Applied rewrites 78.1%

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

4. Final simplification 58.1%

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

Alternative 20: 47.3% accurate, 2.0× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < 8.49999999999999975e210

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 61.2

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

   5. Applied rewrites 61.2%

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

   7. Applied rewrites 61.2%

      \[\leadsto \frac{NaChar}{{\mathsf{E}\left(\right)}^{\left(\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}\right)} + 1} \]

   8. Taylor expanded in Vef around 0

      \[\leadsto \frac{NaChar}{e^{\frac{\log \mathsf{E}\left(\right) \cdot \left(\left(EAccept + Ev\right) - mu\right)}{KbT}} + 1} \]
   9. Step-by-step derivation

   10. Applied rewrites 53.1%

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

   11. Taylor expanded in Ev around 0

       \[\leadsto \frac{NaChar}{e^{\frac{EAccept - mu}{KbT}} + 1} \]
   12. Step-by-step derivation

   13. Applied rewrites 46.4%

       \[\leadsto \frac{NaChar}{e^{\frac{EAccept - mu}{KbT}} + 1} \]

   if 8.49999999999999975e210 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 78.1

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

   5. Applied rewrites 78.1%

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

4. Final simplification 48.8%

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

Alternative 21: 19.5% accurate, 15.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -1.6 \cdot 10^{+117}:\\ \;\;\;\;0.5 \cdot NdChar\\ \mathbf{elif}\;Ev \leq 2.8 \cdot 10^{-193}:\\ \;\;\;\;0.5 \cdot NaChar\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot NdChar\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -1.6e+117)
   (* 0.5 NdChar)
   (if (<= Ev 2.8e-193) (* 0.5 NaChar) (* 0.5 NdChar))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -1.6e+117) {
		tmp = 0.5 * NdChar;
	} else if (Ev <= 2.8e-193) {
		tmp = 0.5 * NaChar;
	} else {
		tmp = 0.5 * NdChar;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (ev <= (-1.6d+117)) then
        tmp = 0.5d0 * ndchar
    else if (ev <= 2.8d-193) then
        tmp = 0.5d0 * nachar
    else
        tmp = 0.5d0 * ndchar
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -1.6e+117) {
		tmp = 0.5 * NdChar;
	} else if (Ev <= 2.8e-193) {
		tmp = 0.5 * NaChar;
	} else {
		tmp = 0.5 * NdChar;
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -1.6e+117], N[(0.5 * NdChar), $MachinePrecision], If[LessEqual[Ev, 2.8e-193], N[(0.5 * NaChar), $MachinePrecision], N[(0.5 * NdChar), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if Ev < -1.60000000000000002e117 or 2.8000000000000002e-193 < Ev

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 25.2

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

   5. Applied rewrites 25.2%

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

   6. Taylor expanded in NdChar around inf

      \[\leadsto \frac{1}{2} \cdot \color{blue}{NdChar} \]
   7. Step-by-step derivation

   8. Applied rewrites 23.0%

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

   if -1.60000000000000002e117 < Ev < 2.8000000000000002e-193

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 31.7

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

   5. Applied rewrites 31.7%

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

   6. Taylor expanded in NdChar around 0

      \[\leadsto \frac{1}{2} \cdot \color{blue}{NaChar} \]
   7. Step-by-step derivation

   8. Applied rewrites 23.6%

      \[\leadsto 0.5 \cdot \color{blue}{NaChar} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 22: 26.9% accurate, 18.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -6 \cdot 10^{+117}:\\ \;\;\;\;0.5 \cdot NdChar\\ \mathbf{else}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -6e+117], N[(0.5 * NdChar), $MachinePrecision], N[(N[(NaChar + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Ev < -6e117

   1. Initial program 99.8%

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

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 14.8

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

   5. Applied rewrites 14.8%

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

   6. Taylor expanded in NdChar around inf

      \[\leadsto \frac{1}{2} \cdot \color{blue}{NdChar} \]
   7. Step-by-step derivation

   8. Applied rewrites 27.6%

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

   if -6e117 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. +-commutative N/A

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

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 30.5

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

   5. Applied rewrites 30.5%

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

4. Final simplification 30.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -6 \cdot 10^{+117}:\\ \;\;\;\;0.5 \cdot NdChar\\ \mathbf{else}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 23: 18.5% accurate, 46.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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}}} \]
2. Add Preprocessing

3. Taylor expanded in KbT around inf

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

   1. +-commutative N/A

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

   2. distribute-lft-out N/A

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

   3. lower-*.f64 N/A

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

   4. lower-+.f64 27.8

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

5. Applied rewrites 27.8%

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

6. Taylor expanded in NdChar around 0

   \[\leadsto \frac{1}{2} \cdot \color{blue}{NaChar} \]
7. Step-by-step derivation

8. Applied rewrites 18.5%

   \[\leadsto 0.5 \cdot \color{blue}{NaChar} \]
9. Add Preprocessing

Reproduce

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