Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 13.0s

Alternatives: 17

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Final simplification 100.0%

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

Alternative 2: 78.7% accurate, 0.3× speedup

Math

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(-1.0 - exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) - t_0)
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)))) - t_0)
	tmp = 0.0
	if (t_2 <= -1e-209)
		tmp = t_1;
	elseif (t_2 <= 1e-200)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / 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 = NaChar / (-1.0 - exp((((EAccept + (Ev + Vef)) - mu) / KbT)));
	t_1 = (NdChar / (1.0 + exp((EDonor / KbT)))) - t_0;
	t_2 = (NdChar / (1.0 + exp(((mu - ((Ec - Vef) - EDonor)) / KbT)))) - t_0;
	tmp = 0.0;
	if (t_2 <= -1e-209)
		tmp = t_1;
	elseif (t_2 <= 1e-200)
		tmp = NdChar / (1.0 + exp(((((mu + Vef) + EDonor) - Ec) / 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[(NaChar / N[(-1.0 - N[Exp[N[(N[(N[(EAccept + N[(Ev + Vef), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-209], t$95$1, If[LessEqual[t$95$2, 1e-200], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(N[(mu + Vef), $MachinePrecision] + EDonor), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $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))))) < -1e-209 or 9.9999999999999998e-201 < (+.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 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 EDonor around inf

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

      1. lower-/.f64 84.8

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

   5. Applied rewrites 84.8%

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

   if -1e-209 < (+.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.9999999999999998e-201

   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 NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 95.7%

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

   6. Taylor expanded in Vef around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-+.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. +-commutative N/A

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

      12. lower-+.f64 N/A

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

   8. Applied rewrites 65.0%

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

   9. Taylor expanded in NdChar around inf

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

       1. lower-/.f64 N/A

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

       2. +-commutative N/A

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

       3. lower-+.f64 N/A

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

       4. lower-exp.f64 N/A

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

       5. lower-/.f64 N/A

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

       6. lower--.f64 N/A

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

       7. +-commutative N/A

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

       8. lower-+.f64 N/A

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

       9. +-commutative N/A

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

       10. lower-+.f64 92.1

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

   11. Applied rewrites 92.1%

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

4. Final simplification 86.7%

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

Alternative 3: 35.8% accurate, 0.4× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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))))) < -4.9999999999999998e-226 or 4.99999999999999996e-300 < (+.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 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 38.2

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

   5. Applied rewrites 38.2%

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

   if -4.9999999999999998e-226 < (+.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.99999999999999996e-300

   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 98.2

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

   5. Applied rewrites 98.2%

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

   6. Taylor expanded in KbT around inf

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

   8. Applied rewrites 47.7%

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

4. Final simplification 40.0%

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

Alternative 4: 32.9% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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))))) < -4.9999999999999998e-226 or 4.99999999999999996e-300 < (+.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 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 38.2

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

   5. Applied rewrites 38.2%

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

   if -4.9999999999999998e-226 < (+.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.99999999999999996e-300

   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 2.7

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

   5. Applied rewrites 2.7%

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

   7. Applied rewrites 4.7%

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

   8. Taylor expanded in NdChar around 0

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

   10. Applied rewrites 31.8%

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

4. Final simplification 37.0%

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

Alternative 5: 29.5% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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))))) < -5.0000000000000002e-154 or 4.99999999999999996e-300 < (+.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 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 40.1

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

   5. Applied rewrites 40.1%

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

   if -5.0000000000000002e-154 < (+.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.99999999999999996e-300

   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}{4} \cdot \frac{NaChar \cdot \left(\left(EAccept + \left(Ev + Vef\right)\right) - mu\right)}{KbT} + \left(\frac{-1}{4} \cdot \frac{NdChar \cdot \left(\left(EDonor + \left(Vef + mu\right)\right) - Ec\right)}{KbT} + \left(\frac{1}{2} \cdot NaChar + \frac{1}{2} \cdot NdChar\right)\right)} \]
   4. Step-by-step derivation

      1. associate-+r+ N/A

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

      2. distribute-lft-out N/A

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

      3. lower-fma.f64 N/A

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

   5. Applied rewrites 1.5%

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

   6. Taylor expanded in Ec around inf

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

   8. Applied rewrites 19.9%

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

4. Final simplification 35.4%

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

Alternative 6: 94.6% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if mu < -2.1000000000000001e146 or 1.9999999999999999e61 < mu

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 91.5%

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

   6. Taylor expanded in Vef around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-+.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. +-commutative N/A

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

      12. lower-+.f64 N/A

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

   8. Applied rewrites 96.7%

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

   if -2.1000000000000001e146 < mu < 1.9999999999999999e61

   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 mu around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-+.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. +-commutative N/A

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

      12. lower-+.f64 N/A

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

   5. Applied rewrites 97.3%

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

4. Final simplification 97.1%

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

Alternative 7: 92.9% accurate, 1.0× speedup

Math

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

Fortran

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

Python

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

Julia

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

Derivation

1. Split input into 2 regimes

2. if mu < -3.1e147 or 5.4999999999999998e165 < mu

   1. Initial program 100.0%

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

   3. Taylor expanded in mu around inf

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

      1. lower-/.f64 93.1

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

   5. Applied rewrites 93.1%

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

   if -3.1e147 < mu < 5.4999999999999998e165

   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 mu around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-+.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. +-commutative N/A

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

      12. lower-+.f64 N/A

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

   5. Applied rewrites 96.1%

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

4. Final simplification 95.3%

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

Alternative 8: 69.7% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.59999999999999991e59 or 1.0499999999999999e35 < NaChar

   1. Initial program 100.0%

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

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

   5. Applied rewrites 77.3%

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

   if -1.59999999999999991e59 < NaChar < 1.0499999999999999e35

   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 NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 90.0%

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

   6. Taylor expanded in Vef around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-+.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. +-commutative N/A

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

      12. lower-+.f64 N/A

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

   8. Applied rewrites 87.2%

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

   9. Taylor expanded in NdChar around inf

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

       1. lower-/.f64 N/A

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

       2. +-commutative N/A

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

       3. lower-+.f64 N/A

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

       4. lower-exp.f64 N/A

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

       5. lower-/.f64 N/A

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

       6. lower--.f64 N/A

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

       7. +-commutative N/A

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

       8. lower-+.f64 N/A

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

       9. +-commutative N/A

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

       10. lower-+.f64 72.3

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

   11. Applied rewrites 72.3%

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

4. Final simplification 74.3%

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

Alternative 9: 62.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(NaChar + NdChar\right) \cdot 0.5\\ \mathbf{if}\;KbT \leq -1.25 \cdot 10^{+169}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 2.05 \cdot 10^{+200}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \frac{NdChar}{KbT} \cdot EDonor, t\_0\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (+ NaChar NdChar) 0.5)))
   (if (<= KbT -1.25e+169)
     t_0
     (if (<= KbT 2.05e+200)
       (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0))
       (fma -0.25 (* (/ NdChar KbT) EDonor) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar + NdChar) * 0.5;
	double tmp;
	if (KbT <= -1.25e+169) {
		tmp = t_0;
	} else if (KbT <= 2.05e+200) {
		tmp = NaChar / (exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	} else {
		tmp = fma(-0.25, ((NdChar / KbT) * EDonor), t_0);
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar + NdChar) * 0.5)
	tmp = 0.0
	if (KbT <= -1.25e+169)
		tmp = t_0;
	elseif (KbT <= 2.05e+200)
		tmp = Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)) - -1.0));
	else
		tmp = fma(-0.25, Float64(Float64(NdChar / KbT) * EDonor), t_0);
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.25000000000000004e169

   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 81.7

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

   5. Applied rewrites 81.7%

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

   if -1.25000000000000004e169 < KbT < 2.0500000000000001e200

   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 64.1

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

   5. Applied rewrites 64.1%

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

   if 2.0500000000000001e200 < 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}{4} \cdot \frac{NaChar \cdot \left(\left(EAccept + \left(Ev + Vef\right)\right) - mu\right)}{KbT} + \left(\frac{-1}{4} \cdot \frac{NdChar \cdot \left(\left(EDonor + \left(Vef + mu\right)\right) - Ec\right)}{KbT} + \left(\frac{1}{2} \cdot NaChar + \frac{1}{2} \cdot NdChar\right)\right)} \]
   4. Step-by-step derivation

      1. associate-+r+ N/A

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

      2. distribute-lft-out N/A

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

      3. lower-fma.f64 N/A

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

   5. Applied rewrites 85.3%

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

   6. Taylor expanded in EDonor around inf

      \[\leadsto \mathsf{fma}\left(\frac{-1}{4}, \frac{EDonor \cdot NdChar}{\color{blue}{KbT}}, \frac{1}{2} \cdot \left(NdChar + NaChar\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 85.5%

      \[\leadsto \mathsf{fma}\left(-0.25, EDonor \cdot \color{blue}{\frac{NdChar}{KbT}}, 0.5 \cdot \left(NdChar + NaChar\right)\right) \]
3. Recombined 3 regimes into one program.

4. Final simplification 68.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.25 \cdot 10^{+169}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \mathbf{elif}\;KbT \leq 2.05 \cdot 10^{+200}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \frac{NdChar}{KbT} \cdot EDonor, \left(NaChar + NdChar\right) \cdot 0.5\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 36.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 5 \cdot 10^{-240}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;EAccept \leq 3.15 \cdot 10^{+41}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 3.6 \cdot 10^{+120}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 5e-240)
   (/ NaChar (- (exp (/ Ev KbT)) -1.0))
   (if (<= EAccept 3.15e+41)
     (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
     (if (<= EAccept 3.6e+120)
       (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
       (/ NaChar (- (exp (/ EAccept 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 <= 5e-240) {
		tmp = NaChar / (exp((Ev / KbT)) - -1.0);
	} else if (EAccept <= 3.15e+41) {
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	} else if (EAccept <= 3.6e+120) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else {
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (eaccept <= 5d-240) then
        tmp = nachar / (exp((ev / kbt)) - (-1.0d0))
    else if (eaccept <= 3.15d+41) then
        tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
    else if (eaccept <= 3.6d+120) then
        tmp = ndchar / (1.0d0 + exp((vef / kbt)))
    else
        tmp = nachar / (exp((eaccept / kbt)) - (-1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (EAccept <= 5e-240) {
		tmp = NaChar / (Math.exp((Ev / KbT)) - -1.0);
	} else if (EAccept <= 3.15e+41) {
		tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	} else if (EAccept <= 3.6e+120) {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	} else {
		tmp = NaChar / (Math.exp((EAccept / KbT)) - -1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if EAccept <= 5e-240:
		tmp = NaChar / (math.exp((Ev / KbT)) - -1.0)
	elif EAccept <= 3.15e+41:
		tmp = NdChar / (1.0 + math.exp((EDonor / KbT)))
	elif EAccept <= 3.6e+120:
		tmp = NdChar / (1.0 + math.exp((Vef / KbT)))
	else:
		tmp = NaChar / (math.exp((EAccept / KbT)) - -1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (EAccept <= 5e-240)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) - -1.0));
	elseif (EAccept <= 3.15e+41)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))));
	elseif (EAccept <= 3.6e+120)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	else
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) - -1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (EAccept <= 5e-240)
		tmp = NaChar / (exp((Ev / KbT)) - -1.0);
	elseif (EAccept <= 3.15e+41)
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	elseif (EAccept <= 3.6e+120)
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	else
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EAccept, 5e-240], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.15e+41], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.6e+120], N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if EAccept < 5.0000000000000004e-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 63.8

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

   5. Applied rewrites 63.8%

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

   6. Taylor expanded in Ev around inf

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

   8. Applied rewrites 37.0%

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

   if 5.0000000000000004e-240 < EAccept < 3.1499999999999999e41

   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 NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 92.6%

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

   6. Taylor expanded in Vef around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-+.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. +-commutative N/A

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

      12. lower-+.f64 N/A

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

   8. Applied rewrites 83.6%

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

   9. Taylor expanded in NdChar around inf

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

       1. lower-/.f64 N/A

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

       2. +-commutative N/A

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

       3. lower-+.f64 N/A

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

       4. lower-exp.f64 N/A

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

       5. lower-/.f64 N/A

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

       6. lower--.f64 N/A

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

       7. +-commutative N/A

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

       8. lower-+.f64 N/A

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

       9. +-commutative N/A

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

       10. lower-+.f64 63.9

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

   11. Applied rewrites 63.9%

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

   12. Taylor expanded in EDonor around inf

       \[\leadsto \frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} \]
   13. Step-by-step derivation

   14. Applied rewrites 43.4%

       \[\leadsto \frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} \]

   if 3.1499999999999999e41 < EAccept < 3.60000000000000016e120

   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 NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 89.9%

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

   6. Taylor expanded in Vef around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-+.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. +-commutative N/A

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

      12. lower-+.f64 N/A

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

   8. Applied rewrites 83.6%

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

   9. Taylor expanded in NdChar around inf

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

       1. lower-/.f64 N/A

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

       2. +-commutative N/A

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

       3. lower-+.f64 N/A

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

       4. lower-exp.f64 N/A

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

       5. lower-/.f64 N/A

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

       6. lower--.f64 N/A

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

       7. +-commutative N/A

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

       8. lower-+.f64 N/A

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

       9. +-commutative N/A

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

       10. lower-+.f64 67.8

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

   11. Applied rewrites 67.8%

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

   12. Taylor expanded in Vef around inf

       \[\leadsto \frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} \]
   13. Step-by-step derivation

   14. Applied rewrites 45.4%

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

   if 3.60000000000000016e120 < 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 69.3

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

   5. Applied rewrites 69.3%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 59.8%

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

4. Final simplification 42.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 5 \cdot 10^{-240}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;EAccept \leq 3.15 \cdot 10^{+41}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 3.6 \cdot 10^{+120}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 40.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(NaChar + NdChar\right) \cdot 0.5\\ \mathbf{if}\;KbT \leq -1.05 \cdot 10^{+165}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq -9.5 \cdot 10^{-52}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \mathbf{elif}\;KbT \leq 1.22 \cdot 10^{+101}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{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 (* (+ NaChar NdChar) 0.5)))
   (if (<= KbT -1.05e+165)
     t_0
     (if (<= KbT -9.5e-52)
       (/ NaChar (- (exp (/ EAccept KbT)) -1.0))
       (if (<= KbT 1.22e+101) (/ NaChar (- (exp (/ Ev 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 = (NaChar + NdChar) * 0.5;
	double tmp;
	if (KbT <= -1.05e+165) {
		tmp = t_0;
	} else if (KbT <= -9.5e-52) {
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	} else if (KbT <= 1.22e+101) {
		tmp = NaChar / (exp((Ev / 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 = (nachar + ndchar) * 0.5d0
    if (kbt <= (-1.05d+165)) then
        tmp = t_0
    else if (kbt <= (-9.5d-52)) then
        tmp = nachar / (exp((eaccept / kbt)) - (-1.0d0))
    else if (kbt <= 1.22d+101) then
        tmp = nachar / (exp((ev / 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 = (NaChar + NdChar) * 0.5;
	double tmp;
	if (KbT <= -1.05e+165) {
		tmp = t_0;
	} else if (KbT <= -9.5e-52) {
		tmp = NaChar / (Math.exp((EAccept / KbT)) - -1.0);
	} else if (KbT <= 1.22e+101) {
		tmp = NaChar / (Math.exp((Ev / KbT)) - -1.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar + NdChar) * 0.5
	tmp = 0
	if KbT <= -1.05e+165:
		tmp = t_0
	elif KbT <= -9.5e-52:
		tmp = NaChar / (math.exp((EAccept / KbT)) - -1.0)
	elif KbT <= 1.22e+101:
		tmp = NaChar / (math.exp((Ev / 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(NaChar + NdChar) * 0.5)
	tmp = 0.0
	if (KbT <= -1.05e+165)
		tmp = t_0;
	elseif (KbT <= -9.5e-52)
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) - -1.0));
	elseif (KbT <= 1.22e+101)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / 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 = (NaChar + NdChar) * 0.5;
	tmp = 0.0;
	if (KbT <= -1.05e+165)
		tmp = t_0;
	elseif (KbT <= -9.5e-52)
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	elseif (KbT <= 1.22e+101)
		tmp = NaChar / (exp((Ev / 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[(NaChar + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]}, If[LessEqual[KbT, -1.05e+165], t$95$0, If[LessEqual[KbT, -9.5e-52], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.22e+101], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.05e165 or 1.22e101 < 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 76.5

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

   5. Applied rewrites 76.5%

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

   if -1.05e165 < KbT < -9.50000000000000007e-52

   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 75.3

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

   5. Applied rewrites 75.3%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 44.2%

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

   if -9.50000000000000007e-52 < KbT < 1.22e101

   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 61.1

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

   5. Applied rewrites 61.1%

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

   6. Taylor expanded in Ev around inf

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

   8. Applied rewrites 34.8%

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

4. Final simplification 47.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.05 \cdot 10^{+165}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \mathbf{elif}\;KbT \leq -9.5 \cdot 10^{-52}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \mathbf{elif}\;KbT \leq 1.22 \cdot 10^{+101}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 36.6% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 5e-240)
   (/ NaChar (- (exp (/ Ev KbT)) -1.0))
   (if (<= EAccept 2e+79)
     (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
     (/ NaChar (- (exp (/ EAccept 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 <= 5e-240) {
		tmp = NaChar / (exp((Ev / KbT)) - -1.0);
	} else if (EAccept <= 2e+79) {
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	} else {
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < 5.0000000000000004e-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 63.8

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

   5. Applied rewrites 63.8%

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

   6. Taylor expanded in Ev around inf

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

   8. Applied rewrites 37.0%

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

   if 5.0000000000000004e-240 < EAccept < 1.99999999999999993e79

   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 NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 93.2%

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

   6. Taylor expanded in Vef around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-+.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. +-commutative N/A

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

      12. lower-+.f64 N/A

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

   8. Applied rewrites 83.5%

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

   9. Taylor expanded in NdChar around inf

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

       1. lower-/.f64 N/A

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

       2. +-commutative N/A

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

       3. lower-+.f64 N/A

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

       4. lower-exp.f64 N/A

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

       5. lower-/.f64 N/A

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

       6. lower--.f64 N/A

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

       7. +-commutative N/A

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

       8. lower-+.f64 N/A

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

       9. +-commutative N/A

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

       10. lower-+.f64 67.0

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

   11. Applied rewrites 67.0%

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

   12. Taylor expanded in EDonor around inf

       \[\leadsto \frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} \]
   13. Step-by-step derivation

   14. Applied rewrites 45.5%

       \[\leadsto \frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1} \]

   if 1.99999999999999993e79 < 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 67.2

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

   5. Applied rewrites 67.2%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 54.3%

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

4. Final simplification 42.9%

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

Alternative 13: 38.6% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -7.5 \cdot 10^{+14}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq 1.65 \cdot 10^{-149}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -7.5e+14)
   (/ NaChar (- (exp (/ Ev KbT)) -1.0))
   (if (<= Ev 1.65e-149)
     (/ NaChar (- (exp (/ Vef KbT)) -1.0))
     (/ NaChar (- (exp (/ EAccept 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 (Ev <= -7.5e+14) {
		tmp = NaChar / (exp((Ev / KbT)) - -1.0);
	} else if (Ev <= 1.65e-149) {
		tmp = NaChar / (exp((Vef / KbT)) - -1.0);
	} else {
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Ev <= -7.5e+14)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) - -1.0));
	elseif (Ev <= 1.65e-149)
		tmp = Float64(NaChar / Float64(exp(Float64(Vef / KbT)) - -1.0));
	else
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) - -1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Ev <= -7.5e+14)
		tmp = NaChar / (exp((Ev / KbT)) - -1.0);
	elseif (Ev <= 1.65e-149)
		tmp = NaChar / (exp((Vef / KbT)) - -1.0);
	else
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -7.5e+14], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 1.65e-149], N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if Ev < -7.5e14

   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 55.6

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

   5. Applied rewrites 55.6%

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

   6. Taylor expanded in Ev around inf

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

   8. Applied rewrites 45.3%

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

   if -7.5e14 < Ev < 1.65000000000000009e-149

   1. Initial program 100.0%

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

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

   5. Applied rewrites 66.0%

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

   6. Taylor expanded in Vef around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 45.0%

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

   if 1.65000000000000009e-149 < 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 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 56.9

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

   5. Applied rewrites 56.9%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 41.8%

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

4. Final simplification 44.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -7.5 \cdot 10^{+14}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq 1.65 \cdot 10^{-149}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 39.6% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(NaChar + NdChar\right) \cdot 0.5\\ \mathbf{if}\;KbT \leq -1.05 \cdot 10^{+165}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 5.6 \cdot 10^{+30}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{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 (* (+ NaChar NdChar) 0.5)))
   (if (<= KbT -1.05e+165)
     t_0
     (if (<= KbT 5.6e+30) (/ 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 = (NaChar + NdChar) * 0.5;
	double tmp;
	if (KbT <= -1.05e+165) {
		tmp = t_0;
	} else if (KbT <= 5.6e+30) {
		tmp = NaChar / (exp((EAccept / 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 = (nachar + ndchar) * 0.5d0
    if (kbt <= (-1.05d+165)) then
        tmp = t_0
    else if (kbt <= 5.6d+30) then
        tmp = nachar / (exp((eaccept / 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 = (NaChar + NdChar) * 0.5;
	double tmp;
	if (KbT <= -1.05e+165) {
		tmp = t_0;
	} else if (KbT <= 5.6e+30) {
		tmp = NaChar / (Math.exp((EAccept / KbT)) - -1.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar + NdChar) * 0.5
	tmp = 0
	if KbT <= -1.05e+165:
		tmp = t_0
	elif KbT <= 5.6e+30:
		tmp = NaChar / (math.exp((EAccept / 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(NaChar + NdChar) * 0.5)
	tmp = 0.0
	if (KbT <= -1.05e+165)
		tmp = t_0;
	elseif (KbT <= 5.6e+30)
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / 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 = (NaChar + NdChar) * 0.5;
	tmp = 0.0;
	if (KbT <= -1.05e+165)
		tmp = t_0;
	elseif (KbT <= 5.6e+30)
		tmp = NaChar / (exp((EAccept / 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[(NaChar + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]}, If[LessEqual[KbT, -1.05e+165], t$95$0, If[LessEqual[KbT, 5.6e+30], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if KbT < -1.05e165 or 5.59999999999999966e30 < 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 66.3

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

   5. Applied rewrites 66.3%

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

   if -1.05e165 < KbT < 5.59999999999999966e30

   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 66.2

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

   5. Applied rewrites 66.2%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 39.1%

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

4. Final simplification 48.1%

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

Alternative 15: 23.0% accurate, 15.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.45 \cdot 10^{+57}:\\ \;\;\;\;0.5 \cdot NaChar\\ \mathbf{elif}\;NaChar \leq 1.02 \cdot 10^{+35}:\\ \;\;\;\;0.5 \cdot NdChar\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot NaChar\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -1.45e+57)
   (* 0.5 NaChar)
   (if (<= NaChar 1.02e+35) (* 0.5 NdChar) (* 0.5 NaChar))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -1.45e+57) {
		tmp = 0.5 * NaChar;
	} else if (NaChar <= 1.02e+35) {
		tmp = 0.5 * NdChar;
	} else {
		tmp = 0.5 * NaChar;
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -1.45e+57) {
		tmp = 0.5 * NaChar;
	} else if (NaChar <= 1.02e+35) {
		tmp = 0.5 * NdChar;
	} else {
		tmp = 0.5 * NaChar;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -1.45e+57:
		tmp = 0.5 * NaChar
	elif NaChar <= 1.02e+35:
		tmp = 0.5 * NdChar
	else:
		tmp = 0.5 * NaChar
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -1.45e+57)
		tmp = Float64(0.5 * NaChar);
	elseif (NaChar <= 1.02e+35)
		tmp = Float64(0.5 * NdChar);
	else
		tmp = Float64(0.5 * NaChar);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -1.45e+57)
		tmp = 0.5 * NaChar;
	elseif (NaChar <= 1.02e+35)
		tmp = 0.5 * NdChar;
	else
		tmp = 0.5 * NaChar;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.4500000000000001e57 or 1.02000000000000007e35 < NaChar

   1. Initial program 100.0%

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

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

   5. Applied rewrites 32.5%

      \[\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 29.1%

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

   if -1.4500000000000001e57 < NaChar < 1.02000000000000007e35

   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.9

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

   5. Applied rewrites 30.9%

      \[\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 12.8%

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

   9. Taylor expanded in NdChar around inf

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

   11. Applied rewrites 25.0%

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

Alternative 16: 27.6% accurate, 30.7× speedup

Math

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

FPCore

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

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

5. Applied rewrites 31.6%

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

6. Final simplification 31.6%

   \[\leadsto \left(NaChar + NdChar\right) \cdot 0.5 \]
7. Add Preprocessing

Alternative 17: 17.9% 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 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 31.6

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

5. Applied rewrites 31.6%

   \[\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 19.5%

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

Reproduce

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