Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 26.8s

Alternatives: 26

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Final simplification 100.0%

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

Alternative 2: 68.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;EAccept \leq -1.55 \cdot 10^{-142}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor - Ec\right)}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 2.7 \cdot 10^{-131}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;EAccept \leq 1.05 \cdot 10^{-61}:\\ \;\;\;\;t_1 + NaChar\\ \mathbf{elif}\;EAccept \leq 1.9 \cdot 10^{+127}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ (+ Vef (- mu Ec)) KbT))))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= EAccept -1.55e-142)
     (+
      (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
      (/ NdChar (+ 1.0 (exp (/ (+ mu (- EDonor Ec)) KbT)))))
     (if (<= EAccept 2.7e-131)
       t_0
       (if (<= EAccept 1.05e-61)
         (+ t_1 NaChar)
         (if (<= EAccept 1.9e+127)
           t_0
           (+ t_1 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT))));
	double t_1 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (EAccept <= -1.55e-142) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp(((mu + (EDonor - Ec)) / KbT))));
	} else if (EAccept <= 2.7e-131) {
		tmp = t_0;
	} else if (EAccept <= 1.05e-61) {
		tmp = t_1 + NaChar;
	} else if (EAccept <= 1.9e+127) {
		tmp = t_0;
	} else {
		tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp(((vef + (mu - ec)) / kbt))))
    t_1 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    if (eaccept <= (-1.55d-142)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp(((mu + (edonor - ec)) / kbt))))
    else if (eaccept <= 2.7d-131) then
        tmp = t_0
    else if (eaccept <= 1.05d-61) then
        tmp = t_1 + nachar
    else if (eaccept <= 1.9d+127) then
        tmp = t_0
    else
        tmp = t_1 + (nachar / (1.0d0 + exp((eaccept / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef + (mu - Ec)) / KbT))));
	double t_1 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (EAccept <= -1.55e-142) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + (EDonor - Ec)) / KbT))));
	} else if (EAccept <= 2.7e-131) {
		tmp = t_0;
	} else if (EAccept <= 1.05e-61) {
		tmp = t_1 + NaChar;
	} else if (EAccept <= 1.9e+127) {
		tmp = t_0;
	} else {
		tmp = t_1 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp(((Vef + (mu - Ec)) / KbT))))
	t_1 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if EAccept <= -1.55e-142:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp(((mu + (EDonor - Ec)) / KbT))))
	elif EAccept <= 2.7e-131:
		tmp = t_0
	elif EAccept <= 1.05e-61:
		tmp = t_1 + NaChar
	elif EAccept <= 1.9e+127:
		tmp = t_0
	else:
		tmp = t_1 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu - Ec)) / KbT)))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (EAccept <= -1.55e-142)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor - Ec)) / KbT)))));
	elseif (EAccept <= 2.7e-131)
		tmp = t_0;
	elseif (EAccept <= 1.05e-61)
		tmp = Float64(t_1 + NaChar);
	elseif (EAccept <= 1.9e+127)
		tmp = t_0;
	else
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT))));
	t_1 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (EAccept <= -1.55e-142)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp(((mu + (EDonor - Ec)) / KbT))));
	elseif (EAccept <= 2.7e-131)
		tmp = t_0;
	elseif (EAccept <= 1.05e-61)
		tmp = t_1 + NaChar;
	elseif (EAccept <= 1.9e+127)
		tmp = t_0;
	else
		tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if EAccept < -1.55e-142

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 70.3%

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

   5. Taylor expanded in Vef around 0 66.8%

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

      1. +-commutative 66.8%

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

      2. +-commutative 66.8%

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

      3. associate--l+ 66.8%

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

   7. Simplified 66.8%

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

   if -1.55e-142 < EAccept < 2.70000000000000021e-131 or 1.05e-61 < EAccept < 1.8999999999999999e127

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 78.5%

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

   5. Taylor expanded in EDonor around 0 73.8%

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

      1. +-commutative 73.8%

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

      2. associate--l+ 73.8%

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

   7. Simplified 73.8%

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

   if 2.70000000000000021e-131 < EAccept < 1.05e-61

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.2%

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

   5. Taylor expanded in Ev around inf 49.0%

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

   6. Taylor expanded in Ev around 0 71.5%

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

   if 1.8999999999999999e127 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 89.3%

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

4. Final simplification 73.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq -1.55 \cdot 10^{-142}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor - Ec\right)}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 2.7 \cdot 10^{-131}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.05 \cdot 10^{-61}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;EAccept \leq 1.9 \cdot 10^{+127}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 3: 70.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;EAccept \leq -3.8 \cdot 10^{-146}:\\ \;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 2.35 \cdot 10^{-131}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;EAccept \leq 4.7 \cdot 10^{-60}:\\ \;\;\;\;t_1 + NaChar\\ \mathbf{elif}\;EAccept \leq 1.8 \cdot 10^{+127}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ (+ Vef (- mu Ec)) KbT))))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= EAccept -3.8e-146)
     (+ t_1 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (if (<= EAccept 2.35e-131)
       t_0
       (if (<= EAccept 4.7e-60)
         (+ t_1 NaChar)
         (if (<= EAccept 1.8e+127)
           t_0
           (+ t_1 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT))));
	double t_1 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (EAccept <= -3.8e-146) {
		tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (EAccept <= 2.35e-131) {
		tmp = t_0;
	} else if (EAccept <= 4.7e-60) {
		tmp = t_1 + NaChar;
	} else if (EAccept <= 1.8e+127) {
		tmp = t_0;
	} else {
		tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp(((vef + (mu - ec)) / kbt))))
    t_1 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    if (eaccept <= (-3.8d-146)) then
        tmp = t_1 + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (eaccept <= 2.35d-131) then
        tmp = t_0
    else if (eaccept <= 4.7d-60) then
        tmp = t_1 + nachar
    else if (eaccept <= 1.8d+127) then
        tmp = t_0
    else
        tmp = t_1 + (nachar / (1.0d0 + exp((eaccept / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef + (mu - Ec)) / KbT))));
	double t_1 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (EAccept <= -3.8e-146) {
		tmp = t_1 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (EAccept <= 2.35e-131) {
		tmp = t_0;
	} else if (EAccept <= 4.7e-60) {
		tmp = t_1 + NaChar;
	} else if (EAccept <= 1.8e+127) {
		tmp = t_0;
	} else {
		tmp = t_1 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp(((Vef + (mu - Ec)) / KbT))))
	t_1 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if EAccept <= -3.8e-146:
		tmp = t_1 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif EAccept <= 2.35e-131:
		tmp = t_0
	elif EAccept <= 4.7e-60:
		tmp = t_1 + NaChar
	elif EAccept <= 1.8e+127:
		tmp = t_0
	else:
		tmp = t_1 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu - Ec)) / KbT)))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (EAccept <= -3.8e-146)
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (EAccept <= 2.35e-131)
		tmp = t_0;
	elseif (EAccept <= 4.7e-60)
		tmp = Float64(t_1 + NaChar);
	elseif (EAccept <= 1.8e+127)
		tmp = t_0;
	else
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT))));
	t_1 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (EAccept <= -3.8e-146)
		tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (EAccept <= 2.35e-131)
		tmp = t_0;
	elseif (EAccept <= 4.7e-60)
		tmp = t_1 + NaChar;
	elseif (EAccept <= 1.8e+127)
		tmp = t_0;
	else
		tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if EAccept < -3.79999999999999994e-146

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 70.6%

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

   if -3.79999999999999994e-146 < EAccept < 2.3499999999999998e-131 or 4.7e-60 < EAccept < 1.79999999999999989e127

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 79.0%

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

   5. Taylor expanded in EDonor around 0 74.3%

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

      1. +-commutative 74.3%

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

      2. associate--l+ 74.3%

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

   7. Simplified 74.3%

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

   if 2.3499999999999998e-131 < EAccept < 4.7e-60

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.2%

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

   5. Taylor expanded in Ev around inf 49.0%

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

   6. Taylor expanded in Ev around 0 71.5%

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

   if 1.79999999999999989e127 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 89.3%

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

4. Final simplification 75.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq -3.8 \cdot 10^{-146}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 2.35 \cdot 10^{-131}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 4.7 \cdot 10^{-60}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;EAccept \leq 1.8 \cdot 10^{+127}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 4: 67.5% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ (+ Vef (- mu Ec)) KbT)))))))
   (if (<= NdChar -3.8e-22)
     t_0
     (if (<= NdChar 9.8e-201)
       (+
        (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
        (/
         NdChar
         (+
          1.0
          (-
           (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
           (/ Ec KbT)))))
       (if (<= NdChar 2.6e-146)
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
         (if (<= NdChar 1.75e+144)
           t_0
           (+
            (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
            NaChar)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT))));
	double tmp;
	if (NdChar <= -3.8e-22) {
		tmp = t_0;
	} else if (NdChar <= 9.8e-201) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	} else if (NdChar <= 2.6e-146) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (NdChar <= 1.75e+144) {
		tmp = t_0;
	} else {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + NaChar;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp(((vef + (mu - ec)) / kbt))))
    if (ndchar <= (-3.8d-22)) then
        tmp = t_0
    else if (ndchar <= 9.8d-201) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + ((1.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt))))
    else if (ndchar <= 2.6d-146) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    else if (ndchar <= 1.75d+144) then
        tmp = t_0
    else
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + nachar
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef + (mu - Ec)) / KbT))));
	double tmp;
	if (NdChar <= -3.8e-22) {
		tmp = t_0;
	} else if (NdChar <= 9.8e-201) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	} else if (NdChar <= 2.6e-146) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else if (NdChar <= 1.75e+144) {
		tmp = t_0;
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + NaChar;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp(((Vef + (mu - Ec)) / KbT))))
	tmp = 0
	if NdChar <= -3.8e-22:
		tmp = t_0
	elif NdChar <= 9.8e-201:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))))
	elif NdChar <= 2.6e-146:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif NdChar <= 1.75e+144:
		tmp = t_0
	else:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + NaChar
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu - Ec)) / KbT)))))
	tmp = 0.0
	if (NdChar <= -3.8e-22)
		tmp = t_0;
	elseif (NdChar <= 9.8e-201)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT)))));
	elseif (NdChar <= 2.6e-146)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (NdChar <= 1.75e+144)
		tmp = t_0;
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + NaChar);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT))));
	tmp = 0.0;
	if (NdChar <= -3.8e-22)
		tmp = t_0;
	elseif (NdChar <= 9.8e-201)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	elseif (NdChar <= 2.6e-146)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (NdChar <= 1.75e+144)
		tmp = t_0;
	else
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + NaChar;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if NdChar < -3.80000000000000023e-22 or 2.59999999999999987e-146 < NdChar < 1.7499999999999999e144

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 78.3%

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

   5. Taylor expanded in EDonor around 0 72.0%

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

      1. +-commutative 72.0%

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

      2. associate--l+ 72.0%

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

   7. Simplified 72.0%

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

   if -3.80000000000000023e-22 < NdChar < 9.7999999999999994e-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}}} \]

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 75.5%

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

   if 9.7999999999999994e-201 < NdChar < 2.59999999999999987e-146

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 65.2%

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

   5. Taylor expanded in mu around inf 65.2%

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

   if 1.7499999999999999e144 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 55.9%

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

   5. Taylor expanded in Ev around inf 70.1%

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

   6. Taylor expanded in Ev around 0 83.8%

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

4. Final simplification 74.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -3.8 \cdot 10^{-22}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 9.8 \cdot 10^{-201}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;NdChar \leq 2.6 \cdot 10^{-146}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 1.75 \cdot 10^{+144}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \end{array} \]

Alternative 5: 73.2% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < -1.05e-142

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 70.3%

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

   if -1.05e-142 < EAccept < 8.39999999999999977e154

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 78.5%

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

   if 8.39999999999999977e154 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 91.6%

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

4. Final simplification 77.3%

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

Alternative 6: 74.9% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -2.75e+90) (not (<= Vef 1.18e-91)))
   (+
    (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
    (/ NdChar (+ 1.0 (exp (/ (+ Vef (- mu Ec)) KbT)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
    (/ NdChar (+ 1.0 (exp (/ (+ mu (- EDonor Ec)) KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((Vef <= -2.75e+90) || !(Vef <= 1.18e-91)) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp(((mu + (EDonor - Ec)) / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((Vef <= -2.75e+90) || ~((Vef <= 1.18e-91)))
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT))));
	else
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp(((mu + (EDonor - Ec)) / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -2.74999999999999999e90 or 1.18e-91 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 85.9%

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

   5. Taylor expanded in EDonor around 0 78.9%

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

      1. +-commutative 78.9%

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

      2. associate--l+ 78.9%

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

   7. Simplified 78.9%

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

   if -2.74999999999999999e90 < Vef < 1.18e-91

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Ev around inf 73.3%

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

   5. Taylor expanded in Vef around 0 73.3%

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

      1. +-commutative 73.3%

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

      2. +-commutative 73.3%

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

      3. associate--l+ 73.3%

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

   7. Simplified 73.3%

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

4. Final simplification 75.8%

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

Alternative 7: 68.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -9.8 \cdot 10^{+114}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 5 \cdot 10^{-6}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.05 \cdot 10^{+182}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + 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
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (- (/ mu KbT))))))))
   (if (<= mu -9.8e+114)
     t_0
     (if (<= mu 5e-6)
       (+
        (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
        (/ NdChar (+ 1.0 (exp (/ (- Vef Ec) KbT)))))
       (if (<= mu 2.05e+182)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          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 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	double tmp;
	if (mu <= -9.8e+114) {
		tmp = t_0;
	} else if (mu <= 5e-6) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef - Ec) / KbT))));
	} else if (mu <= 2.05e+182) {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + 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) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp(-(mu / kbt))))
    if (mu <= (-9.8d+114)) then
        tmp = t_0
    else if (mu <= 5d-6) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp(((vef - ec) / kbt))))
    else if (mu <= 2.05d+182) then
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + 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 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
	double tmp;
	if (mu <= -9.8e+114) {
		tmp = t_0;
	} else if (mu <= 5e-6) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef - Ec) / KbT))));
	} else if (mu <= 2.05e+182) {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + NaChar;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp(-(mu / KbT))))
	tmp = 0
	if mu <= -9.8e+114:
		tmp = t_0
	elif mu <= 5e-6:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp(((Vef - Ec) / KbT))))
	elif mu <= 2.05e+182:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + NaChar
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT))))))
	tmp = 0.0
	if (mu <= -9.8e+114)
		tmp = t_0;
	elseif (mu <= 5e-6)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef - Ec) / KbT)))));
	elseif (mu <= 2.05e+182)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + 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 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
	tmp = 0.0;
	if (mu <= -9.8e+114)
		tmp = t_0;
	elseif (mu <= 5e-6)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef - Ec) / KbT))));
	elseif (mu <= 2.05e+182)
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + 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[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -9.8e+114], t$95$0, If[LessEqual[mu, 5e-6], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.05e+182], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + NaChar), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -9.8000000000000002e114 or 2.05000000000000001e182 < mu

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in mu around inf 88.1%

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

      1. associate-*r/ 88.1%

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

      2. mul-1-neg 88.1%

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

   6. Simplified 88.1%

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

   7. Taylor expanded in mu around inf 76.0%

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

   if -9.8000000000000002e114 < mu < 5.00000000000000041e-6

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 79.3%

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

   5. Taylor expanded in EDonor around 0 71.7%

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

      1. +-commutative 71.7%

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

      2. associate--l+ 71.7%

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

   7. Simplified 71.7%

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

   8. Taylor expanded in mu around 0 72.3%

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

   if 5.00000000000000041e-6 < mu < 2.05000000000000001e182

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 51.8%

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

   5. Taylor expanded in Ev around inf 64.2%

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

   6. Taylor expanded in Ev around 0 70.0%

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

4. Final simplification 72.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -9.8 \cdot 10^{+114}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq 5 \cdot 10^{-6}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.05 \cdot 10^{+182}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\ \end{array} \]

Alternative 8: 65.1% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{if}\;NaChar \leq -8 \cdot 10^{-91}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -1.3 \cdot 10^{-218}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 3.2 \cdot 10^{+53}:\\ \;\;\;\;t_0 + NaChar\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/
           NdChar
           (+
            1.0
            (-
             (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
             (/ Ec KbT)))))))
   (if (<= NaChar -8e-91)
     t_1
     (if (<= NaChar -1.3e-218)
       (+
        t_0
        (/
         NaChar
         (+
          1.0
          (-
           (+ 1.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
           (/ mu KbT)))))
       (if (<= NaChar 3.2e+53) (+ t_0 NaChar) t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	double tmp;
	if (NaChar <= -8e-91) {
		tmp = t_1;
	} else if (NaChar <= -1.3e-218) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	} else if (NaChar <= 3.2e+53) {
		tmp = t_0 + NaChar;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	double tmp;
	if (NaChar <= -8e-91) {
		tmp = t_1;
	} else if (NaChar <= -1.3e-218) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	} else if (NaChar <= 3.2e+53) {
		tmp = t_0 + NaChar;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))))
	tmp = 0
	if NaChar <= -8e-91:
		tmp = t_1
	elif NaChar <= -1.3e-218:
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))))
	elif NaChar <= 3.2e+53:
		tmp = t_0 + NaChar
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT)))))
	tmp = 0.0
	if (NaChar <= -8e-91)
		tmp = t_1;
	elseif (NaChar <= -1.3e-218)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT)))));
	elseif (NaChar <= 3.2e+53)
		tmp = Float64(t_0 + NaChar);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	tmp = 0.0;
	if (NaChar <= -8e-91)
		tmp = t_1;
	elseif (NaChar <= -1.3e-218)
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	elseif (NaChar <= 3.2e+53)
		tmp = t_0 + NaChar;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -8.00000000000000018e-91 or 3.2e53 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 69.0%

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

   if -8.00000000000000018e-91 < NaChar < -1.29999999999999992e-218

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 77.6%

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

   if -1.29999999999999992e-218 < NaChar < 3.2e53

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 60.5%

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

   5. Taylor expanded in Ev around inf 67.1%

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

   6. Taylor expanded in Ev around 0 74.9%

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

4. Final simplification 72.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -8 \cdot 10^{-91}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -1.3 \cdot 10^{-218}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq 3.2 \cdot 10^{+53}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \end{array} \]

Alternative 9: 65.1% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{if}\;NaChar \leq -1.5 \cdot 10^{-90}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -1.15 \cdot 10^{-218}:\\ \;\;\;\;t_0 + \frac{1}{\frac{\left(1 + \left(1 + \left(\frac{Ev}{KbT} + \left(\frac{Vef}{KbT} + \frac{EAccept}{KbT}\right)\right)\right)\right) - \frac{mu}{KbT}}{NaChar}}\\ \mathbf{elif}\;NaChar \leq 5.2 \cdot 10^{+40}:\\ \;\;\;\;t_0 + NaChar\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/
           NdChar
           (+
            1.0
            (-
             (+ 1.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT))))
             (/ Ec KbT)))))))
   (if (<= NaChar -1.5e-90)
     t_1
     (if (<= NaChar -1.15e-218)
       (+
        t_0
        (/
         1.0
         (/
          (-
           (+ 1.0 (+ 1.0 (+ (/ Ev KbT) (+ (/ Vef KbT) (/ EAccept KbT)))))
           (/ mu KbT))
          NaChar)))
       (if (<= NaChar 5.2e+40) (+ t_0 NaChar) t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	double tmp;
	if (NaChar <= -1.5e-90) {
		tmp = t_1;
	} else if (NaChar <= -1.15e-218) {
		tmp = t_0 + (1.0 / (((1.0 + (1.0 + ((Ev / KbT) + ((Vef / KbT) + (EAccept / KbT))))) - (mu / KbT)) / NaChar));
	} else if (NaChar <= 5.2e+40) {
		tmp = t_0 + NaChar;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + ((1.0d0 + ((edonor / kbt) + ((vef / kbt) + (mu / kbt)))) - (ec / kbt))))
    if (nachar <= (-1.5d-90)) then
        tmp = t_1
    else if (nachar <= (-1.15d-218)) then
        tmp = t_0 + (1.0d0 / (((1.0d0 + (1.0d0 + ((ev / kbt) + ((vef / kbt) + (eaccept / kbt))))) - (mu / kbt)) / nachar))
    else if (nachar <= 5.2d+40) then
        tmp = t_0 + nachar
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	double tmp;
	if (NaChar <= -1.5e-90) {
		tmp = t_1;
	} else if (NaChar <= -1.15e-218) {
		tmp = t_0 + (1.0 / (((1.0 + (1.0 + ((Ev / KbT) + ((Vef / KbT) + (EAccept / KbT))))) - (mu / KbT)) / NaChar));
	} else if (NaChar <= 5.2e+40) {
		tmp = t_0 + NaChar;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))))
	tmp = 0
	if NaChar <= -1.5e-90:
		tmp = t_1
	elif NaChar <= -1.15e-218:
		tmp = t_0 + (1.0 / (((1.0 + (1.0 + ((Ev / KbT) + ((Vef / KbT) + (EAccept / KbT))))) - (mu / KbT)) / NaChar))
	elif NaChar <= 5.2e+40:
		tmp = t_0 + NaChar
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT)))))
	tmp = 0.0
	if (NaChar <= -1.5e-90)
		tmp = t_1;
	elseif (NaChar <= -1.15e-218)
		tmp = Float64(t_0 + Float64(1.0 / Float64(Float64(Float64(1.0 + Float64(1.0 + Float64(Float64(Ev / KbT) + Float64(Float64(Vef / KbT) + Float64(EAccept / KbT))))) - Float64(mu / KbT)) / NaChar)));
	elseif (NaChar <= 5.2e+40)
		tmp = Float64(t_0 + NaChar);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + ((1.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))));
	tmp = 0.0;
	if (NaChar <= -1.5e-90)
		tmp = t_1;
	elseif (NaChar <= -1.15e-218)
		tmp = t_0 + (1.0 / (((1.0 + (1.0 + ((Ev / KbT) + ((Vef / KbT) + (EAccept / KbT))))) - (mu / KbT)) / NaChar));
	elseif (NaChar <= 5.2e+40)
		tmp = t_0 + NaChar;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.5000000000000001e-90 or 5.2000000000000001e40 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 69.0%

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

   if -1.5000000000000001e-90 < NaChar < -1.14999999999999997e-218

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 77.6%

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

      1. clear-num 78.0%

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

      2. inv-pow 78.0%

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

      3. associate-+r+ 78.0%

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

      4. +-commutative 78.0%

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

   6. Applied egg-rr 78.0%

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

      1. unpow-1 78.0%

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

      2. associate-+r- 78.0%

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

      3. associate-+l+ 78.0%

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

      4. associate-+r+ 78.0%

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

      5. +-commutative 78.0%

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

   8. Simplified 78.0%

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

   if -1.14999999999999997e-218 < NaChar < 5.2000000000000001e40

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 60.5%

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

   5. Taylor expanded in Ev around inf 67.1%

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

   6. Taylor expanded in Ev around 0 74.9%

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

4. Final simplification 72.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.5 \cdot 10^{-90}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;NaChar \leq -1.15 \cdot 10^{-218}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{1}{\frac{\left(1 + \left(1 + \left(\frac{Ev}{KbT} + \left(\frac{Vef}{KbT} + \frac{EAccept}{KbT}\right)\right)\right)\right) - \frac{mu}{KbT}}{NaChar}}\\ \mathbf{elif}\;NaChar \leq 5.2 \cdot 10^{+40}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + \left(\left(1 + \left(\frac{EDonor}{KbT} + \left(\frac{Vef}{KbT} + \frac{mu}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\ \end{array} \]

Alternative 10: 64.7% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t_0 + NaChar\\ \mathbf{if}\;KbT \leq -1.7 \cdot 10^{+43}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq -5.2 \cdot 10^{-294}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 6.5 \cdot 10^{-292}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}} + \frac{KbT \cdot NaChar}{Vef}\\ \mathbf{elif}\;KbT \leq 2.3 \cdot 10^{+141}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 NaChar)))
   (if (<= KbT -1.7e+43)
     (+
      t_0
      (/
       NaChar
       (+
        1.0
        (-
         (+ 1.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
         (/ mu KbT)))))
     (if (<= KbT -5.2e-294)
       t_1
       (if (<= KbT 6.5e-292)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ Vef (- mu Ec)) KbT))))
          (/ (* KbT NaChar) Vef))
         (if (<= KbT 2.3e+141)
           t_1
           (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ Vef KbT)))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (KbT <= -1.7e+43) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	} else if (KbT <= -5.2e-294) {
		tmp = t_1;
	} else if (KbT <= 6.5e-292) {
		tmp = (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	} else if (KbT <= 2.3e+141) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = t_0 + nachar
    if (kbt <= (-1.7d+43)) then
        tmp = t_0 + (nachar / (1.0d0 + ((1.0d0 + ((eaccept / kbt) + ((ev / kbt) + (vef / kbt)))) - (mu / kbt))))
    else if (kbt <= (-5.2d-294)) then
        tmp = t_1
    else if (kbt <= 6.5d-292) then
        tmp = (ndchar / (1.0d0 + exp(((vef + (mu - ec)) / kbt)))) + ((kbt * nachar) / vef)
    else if (kbt <= 2.3d+141) then
        tmp = t_1
    else
        tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (vef / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (KbT <= -1.7e+43) {
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	} else if (KbT <= -5.2e-294) {
		tmp = t_1;
	} else if (KbT <= 6.5e-292) {
		tmp = (NdChar / (1.0 + Math.exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	} else if (KbT <= 2.3e+141) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = t_0 + NaChar
	tmp = 0
	if KbT <= -1.7e+43:
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))))
	elif KbT <= -5.2e-294:
		tmp = t_1
	elif KbT <= 6.5e-292:
		tmp = (NdChar / (1.0 + math.exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef)
	elif KbT <= 2.3e+141:
		tmp = t_1
	else:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + NaChar)
	tmp = 0.0
	if (KbT <= -1.7e+43)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT)))));
	elseif (KbT <= -5.2e-294)
		tmp = t_1;
	elseif (KbT <= 6.5e-292)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu - Ec)) / KbT)))) + Float64(Float64(KbT * NaChar) / Vef));
	elseif (KbT <= 2.3e+141)
		tmp = t_1;
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = t_0 + NaChar;
	tmp = 0.0;
	if (KbT <= -1.7e+43)
		tmp = t_0 + (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT))));
	elseif (KbT <= -5.2e-294)
		tmp = t_1;
	elseif (KbT <= 6.5e-292)
		tmp = (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	elseif (KbT <= 2.3e+141)
		tmp = t_1;
	else
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -1.70000000000000006e43

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 70.0%

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

   if -1.70000000000000006e43 < KbT < -5.1999999999999999e-294 or 6.4999999999999997e-292 < KbT < 2.3000000000000002e141

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 39.6%

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

   5. Taylor expanded in Ev around inf 47.8%

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

   6. Taylor expanded in Ev around 0 63.3%

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

   if -5.1999999999999999e-294 < KbT < 6.4999999999999997e-292

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 58.7%

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

   5. Taylor expanded in Vef around inf 83.9%

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

   6. Taylor expanded in EDonor around 0 83.9%

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

      1. +-commutative 84.0%

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

      2. associate--l+ 84.0%

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

   8. Simplified 83.9%

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

   if 2.3000000000000002e141 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in Vef around inf 88.5%

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

   5. Taylor expanded in Vef around 0 84.1%

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

4. Final simplification 68.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.7 \cdot 10^{+43}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(1 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq -5.2 \cdot 10^{-294}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 6.5 \cdot 10^{-292}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}} + \frac{KbT \cdot NaChar}{Vef}\\ \mathbf{elif}\;KbT \leq 2.3 \cdot 10^{+141}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \end{array} \]

Alternative 11: 65.8% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t_0 + NaChar\\ \mathbf{if}\;KbT \leq -4 \cdot 10^{+122}:\\ \;\;\;\;t_0 + NaChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -5.3 \cdot 10^{-294}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 6.4 \cdot 10^{-292}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}} + \frac{KbT \cdot NaChar}{Vef}\\ \mathbf{elif}\;KbT \leq 2.35 \cdot 10^{+142}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 NaChar)))
   (if (<= KbT -4e+122)
     (+ t_0 (* NaChar 0.5))
     (if (<= KbT -5.3e-294)
       t_1
       (if (<= KbT 6.4e-292)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ Vef (- mu Ec)) KbT))))
          (/ (* KbT NaChar) Vef))
         (if (<= KbT 2.35e+142)
           t_1
           (+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ Vef KbT)))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (KbT <= -4e+122) {
		tmp = t_0 + (NaChar * 0.5);
	} else if (KbT <= -5.3e-294) {
		tmp = t_1;
	} else if (KbT <= 6.4e-292) {
		tmp = (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	} else if (KbT <= 2.35e+142) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = t_0 + nachar
    if (kbt <= (-4d+122)) then
        tmp = t_0 + (nachar * 0.5d0)
    else if (kbt <= (-5.3d-294)) then
        tmp = t_1
    else if (kbt <= 6.4d-292) then
        tmp = (ndchar / (1.0d0 + exp(((vef + (mu - ec)) / kbt)))) + ((kbt * nachar) / vef)
    else if (kbt <= 2.35d+142) then
        tmp = t_1
    else
        tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (vef / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double tmp;
	if (KbT <= -4e+122) {
		tmp = t_0 + (NaChar * 0.5);
	} else if (KbT <= -5.3e-294) {
		tmp = t_1;
	} else if (KbT <= 6.4e-292) {
		tmp = (NdChar / (1.0 + Math.exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	} else if (KbT <= 2.35e+142) {
		tmp = t_1;
	} else {
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = t_0 + NaChar
	tmp = 0
	if KbT <= -4e+122:
		tmp = t_0 + (NaChar * 0.5)
	elif KbT <= -5.3e-294:
		tmp = t_1
	elif KbT <= 6.4e-292:
		tmp = (NdChar / (1.0 + math.exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef)
	elif KbT <= 2.35e+142:
		tmp = t_1
	else:
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + NaChar)
	tmp = 0.0
	if (KbT <= -4e+122)
		tmp = Float64(t_0 + Float64(NaChar * 0.5));
	elseif (KbT <= -5.3e-294)
		tmp = t_1;
	elseif (KbT <= 6.4e-292)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu - Ec)) / KbT)))) + Float64(Float64(KbT * NaChar) / Vef));
	elseif (KbT <= 2.35e+142)
		tmp = t_1;
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = t_0 + NaChar;
	tmp = 0.0;
	if (KbT <= -4e+122)
		tmp = t_0 + (NaChar * 0.5);
	elseif (KbT <= -5.3e-294)
		tmp = t_1;
	elseif (KbT <= 6.4e-292)
		tmp = (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	elseif (KbT <= 2.35e+142)
		tmp = t_1;
	else
		tmp = t_0 + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + NaChar), $MachinePrecision]}, If[LessEqual[KbT, -4e+122], N[(t$95$0 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -5.3e-294], t$95$1, If[LessEqual[KbT, 6.4e-292], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(mu - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(KbT * NaChar), $MachinePrecision] / Vef), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.35e+142], t$95$1, N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -4.00000000000000006e122

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 86.5%

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

   5. Taylor expanded in Vef around 0 77.9%

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

   if -4.00000000000000006e122 < KbT < -5.29999999999999969e-294 or 6.4000000000000003e-292 < KbT < 2.35e142

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 41.6%

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

   5. Taylor expanded in Ev around inf 47.6%

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

   6. Taylor expanded in Ev around 0 62.0%

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

   if -5.29999999999999969e-294 < KbT < 6.4000000000000003e-292

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 58.7%

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

   5. Taylor expanded in Vef around inf 83.9%

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

   6. Taylor expanded in EDonor around 0 83.9%

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

      1. +-commutative 84.0%

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

      2. associate--l+ 84.0%

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

   8. Simplified 83.9%

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

   if 2.35e142 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in Vef around inf 88.5%

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

   5. Taylor expanded in Vef around 0 84.1%

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

4. Final simplification 68.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -4 \cdot 10^{+122}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -5.3 \cdot 10^{-294}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 6.4 \cdot 10^{-292}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}} + \frac{KbT \cdot NaChar}{Vef}\\ \mathbf{elif}\;KbT \leq 2.35 \cdot 10^{+142}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \end{array} \]

Alternative 12: 65.7% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t_0 + NaChar\\ t_2 := t_0 + NaChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -2.65 \cdot 10^{+122}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;KbT \leq -5.3 \cdot 10^{-294}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq 6.4 \cdot 10^{-292}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}} + \frac{KbT \cdot NaChar}{Vef}\\ \mathbf{elif}\;KbT \leq 5.2 \cdot 10^{+140}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 NaChar))
        (t_2 (+ t_0 (* NaChar 0.5))))
   (if (<= KbT -2.65e+122)
     t_2
     (if (<= KbT -5.3e-294)
       t_1
       (if (<= KbT 6.4e-292)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ Vef (- mu Ec)) KbT))))
          (/ (* KbT NaChar) Vef))
         (if (<= KbT 5.2e+140) t_1 t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double t_2 = t_0 + (NaChar * 0.5);
	double tmp;
	if (KbT <= -2.65e+122) {
		tmp = t_2;
	} else if (KbT <= -5.3e-294) {
		tmp = t_1;
	} else if (KbT <= 6.4e-292) {
		tmp = (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	} else if (KbT <= 5.2e+140) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = t_0 + nachar
    t_2 = t_0 + (nachar * 0.5d0)
    if (kbt <= (-2.65d+122)) then
        tmp = t_2
    else if (kbt <= (-5.3d-294)) then
        tmp = t_1
    else if (kbt <= 6.4d-292) then
        tmp = (ndchar / (1.0d0 + exp(((vef + (mu - ec)) / kbt)))) + ((kbt * nachar) / vef)
    else if (kbt <= 5.2d+140) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + NaChar;
	double t_2 = t_0 + (NaChar * 0.5);
	double tmp;
	if (KbT <= -2.65e+122) {
		tmp = t_2;
	} else if (KbT <= -5.3e-294) {
		tmp = t_1;
	} else if (KbT <= 6.4e-292) {
		tmp = (NdChar / (1.0 + Math.exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	} else if (KbT <= 5.2e+140) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = t_0 + NaChar
	t_2 = t_0 + (NaChar * 0.5)
	tmp = 0
	if KbT <= -2.65e+122:
		tmp = t_2
	elif KbT <= -5.3e-294:
		tmp = t_1
	elif KbT <= 6.4e-292:
		tmp = (NdChar / (1.0 + math.exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef)
	elif KbT <= 5.2e+140:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + NaChar)
	t_2 = Float64(t_0 + Float64(NaChar * 0.5))
	tmp = 0.0
	if (KbT <= -2.65e+122)
		tmp = t_2;
	elseif (KbT <= -5.3e-294)
		tmp = t_1;
	elseif (KbT <= 6.4e-292)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu - Ec)) / KbT)))) + Float64(Float64(KbT * NaChar) / Vef));
	elseif (KbT <= 5.2e+140)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = t_0 + NaChar;
	t_2 = t_0 + (NaChar * 0.5);
	tmp = 0.0;
	if (KbT <= -2.65e+122)
		tmp = t_2;
	elseif (KbT <= -5.3e-294)
		tmp = t_1;
	elseif (KbT <= 6.4e-292)
		tmp = (NdChar / (1.0 + exp(((Vef + (mu - Ec)) / KbT)))) + ((KbT * NaChar) / Vef);
	elseif (KbT <= 5.2e+140)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + NaChar), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.65e+122], t$95$2, If[LessEqual[KbT, -5.3e-294], t$95$1, If[LessEqual[KbT, 6.4e-292], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(mu - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(KbT * NaChar), $MachinePrecision] / Vef), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 5.2e+140], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.65e122 or 5.2000000000000002e140 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 87.4%

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

   5. Taylor expanded in Vef around 0 80.7%

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

   if -2.65e122 < KbT < -5.29999999999999969e-294 or 6.4000000000000003e-292 < KbT < 5.2000000000000002e140

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 41.6%

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

   5. Taylor expanded in Ev around inf 47.6%

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

   6. Taylor expanded in Ev around 0 62.0%

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

   if -5.29999999999999969e-294 < KbT < 6.4000000000000003e-292

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 58.7%

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

   5. Taylor expanded in Vef around inf 83.9%

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

   6. Taylor expanded in EDonor around 0 83.9%

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

      1. +-commutative 84.0%

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

      2. associate--l+ 84.0%

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

   8. Simplified 83.9%

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

4. Final simplification 68.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.65 \cdot 10^{+122}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -5.3 \cdot 10^{-294}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{elif}\;KbT \leq 6.4 \cdot 10^{-292}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}} + \frac{KbT \cdot NaChar}{Vef}\\ \mathbf{elif}\;KbT \leq 5.2 \cdot 10^{+140}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \]

Alternative 13: 66.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;KbT \leq -3.8 \cdot 10^{+122} \lor \neg \left(KbT \leq 3.4 \cdot 10^{+142}\right):\\ \;\;\;\;t_0 + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;t_0 + NaChar\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (or (<= KbT -3.8e+122) (not (<= KbT 3.4e+142)))
     (+ t_0 (* NaChar 0.5))
     (+ t_0 NaChar))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[KbT, -3.8e+122], N[Not[LessEqual[KbT, 3.4e+142]], $MachinePrecision]], N[(t$95$0 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + NaChar), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if KbT < -3.7999999999999998e122 or 3.3999999999999998e142 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 87.4%

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

   5. Taylor expanded in Vef around 0 80.7%

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

   if -3.7999999999999998e122 < KbT < 3.3999999999999998e142

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 42.7%

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

   5. Taylor expanded in Ev around inf 50.1%

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

   6. Taylor expanded in Ev around 0 60.8%

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

4. Final simplification 66.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.8 \cdot 10^{+122} \lor \neg \left(KbT \leq 3.4 \cdot 10^{+142}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \end{array} \]

Alternative 14: 65.8% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.09999999999999995e197

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 87.8%

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

   5. Taylor expanded in EDonor around 0 87.8%

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

      1. +-commutative 87.8%

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

      2. associate--l+ 87.8%

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

   7. Simplified 87.8%

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

   8. Taylor expanded in Vef around 0 80.0%

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

   if -1.09999999999999995e197 < KbT < 1.35000000000000007e152

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 46.3%

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

   5. Taylor expanded in Ev around inf 51.9%

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

   6. Taylor expanded in Ev around 0 62.0%

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

   if 1.35000000000000007e152 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in KbT around inf 83.5%

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

4. Final simplification 66.4%

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

Alternative 15: 65.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -4.4 \cdot 10^{+197} \lor \neg \left(KbT \leq 4.2 \cdot 10^{+141}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -4.4e+197) (not (<= KbT 4.2e+141)))
   (+ (/ NdChar (+ 1.0 (exp (/ (+ Vef (- mu Ec)) KbT)))) (* NaChar 0.5))
   (+ (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))) NaChar)))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -4.4e+197], N[Not[LessEqual[KbT, 4.2e+141]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(mu - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + NaChar), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -4.39999999999999979e197 or 4.1999999999999997e141 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 88.2%

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

   5. Taylor expanded in EDonor around 0 83.8%

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

      1. +-commutative 83.8%

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

      2. associate--l+ 83.8%

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

   7. Simplified 83.8%

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

   8. Taylor expanded in Vef around 0 77.8%

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

   if -4.39999999999999979e197 < KbT < 4.1999999999999997e141

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 45.2%

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

   5. Taylor expanded in Ev around inf 51.3%

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

   6. Taylor expanded in Ev around 0 61.6%

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

4. Final simplification 65.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -4.4 \cdot 10^{+197} \lor \neg \left(KbT \leq 4.2 \cdot 10^{+141}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu - Ec\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar\\ \end{array} \]

Alternative 16: 64.7% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -5.4000000000000001e197

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 88.1%

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

   5. Taylor expanded in KbT around inf 71.5%

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

   if -5.4000000000000001e197 < KbT < 6.8000000000000003e170

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 46.1%

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

   5. Taylor expanded in Ev around inf 51.8%

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

   6. Taylor expanded in Ev around 0 61.7%

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

   if 6.8000000000000003e170 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in KbT around inf 85.1%

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

   5. Taylor expanded in Ev around inf 78.1%

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

4. Final simplification 64.5%

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

Alternative 17: 39.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{if}\;KbT \leq -1.52 \cdot 10^{-80}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;KbT \leq -1.3 \cdot 10^{-206}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;KbT \leq 8.8 \cdot 10^{+71}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \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 (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))))
   (if (<= KbT -1.52e-80)
     t_0
     (if (<= KbT -1.3e-206)
       (/ NaChar (+ 1.0 (/ Ev KbT)))
       (if (<= KbT 8.8e+71) (+ NaChar (* NdChar 0.5)) 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 / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -1.52e-80) {
		tmp = t_0;
	} else if (KbT <= -1.3e-206) {
		tmp = NaChar / (1.0 + (Ev / KbT));
	} else if (KbT <= 8.8e+71) {
		tmp = NaChar + (NdChar * 0.5);
	} 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 / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
    if (kbt <= (-1.52d-80)) then
        tmp = t_0
    else if (kbt <= (-1.3d-206)) then
        tmp = nachar / (1.0d0 + (ev / kbt))
    else if (kbt <= 8.8d+71) then
        tmp = nachar + (ndchar * 0.5d0)
    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 / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
	double tmp;
	if (KbT <= -1.52e-80) {
		tmp = t_0;
	} else if (KbT <= -1.3e-206) {
		tmp = NaChar / (1.0 + (Ev / KbT));
	} else if (KbT <= 8.8e+71) {
		tmp = NaChar + (NdChar * 0.5);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5)
	tmp = 0
	if KbT <= -1.52e-80:
		tmp = t_0
	elif KbT <= -1.3e-206:
		tmp = NaChar / (1.0 + (Ev / KbT))
	elif KbT <= 8.8e+71:
		tmp = NaChar + (NdChar * 0.5)
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5))
	tmp = 0.0
	if (KbT <= -1.52e-80)
		tmp = t_0;
	elseif (KbT <= -1.3e-206)
		tmp = Float64(NaChar / Float64(1.0 + Float64(Ev / KbT)));
	elseif (KbT <= 8.8e+71)
		tmp = Float64(NaChar + Float64(NdChar * 0.5));
	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 / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	tmp = 0.0;
	if (KbT <= -1.52e-80)
		tmp = t_0;
	elseif (KbT <= -1.3e-206)
		tmp = NaChar / (1.0 + (Ev / KbT));
	elseif (KbT <= 8.8e+71)
		tmp = NaChar + (NdChar * 0.5);
	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[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.52e-80], t$95$0, If[LessEqual[KbT, -1.3e-206], N[(NaChar / N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 8.8e+71], N[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.5199999999999999e-80 or 8.79999999999999978e71 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 77.7%

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

   5. Taylor expanded in KbT around inf 53.7%

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

   if -1.5199999999999999e-80 < KbT < -1.3e-206

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 43.5%

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

   5. Taylor expanded in Ev around inf 53.6%

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

   6. Taylor expanded in KbT around inf 18.4%

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

   7. Taylor expanded in NdChar around 0 24.9%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + \frac{Ev}{KbT}}} \]

   if -1.3e-206 < KbT < 8.79999999999999978e71

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 41.8%

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

   5. Taylor expanded in Ev around inf 51.9%

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

   6. Taylor expanded in KbT around inf 17.2%

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

   7. Taylor expanded in Ev around 0 36.3%

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

4. Final simplification 43.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.52 \cdot 10^{-80}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -1.3 \cdot 10^{-206}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;KbT \leq 8.8 \cdot 10^{+71}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 18: 39.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.08 \cdot 10^{-70}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -6 \cdot 10^{-201}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;KbT \leq 1.15 \cdot 10^{+72}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.08e-70)
   (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
   (if (<= KbT -6e-201)
     (/ NaChar (+ 1.0 (/ Ev KbT)))
     (if (<= KbT 1.15e+72)
       (+ NaChar (* NdChar 0.5))
       (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1.08e-70) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= -6e-201) {
		tmp = NaChar / (1.0 + (Ev / KbT));
	} else if (KbT <= 1.15e+72) {
		tmp = NaChar + (NdChar * 0.5);
	} else {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -1.08e-70)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= -6e-201)
		tmp = Float64(NaChar / Float64(1.0 + Float64(Ev / KbT)));
	elseif (KbT <= 1.15e+72)
		tmp = Float64(NaChar + Float64(NdChar * 0.5));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -1.08e-70)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= -6e-201)
		tmp = NaChar / (1.0 + (Ev / KbT));
	elseif (KbT <= 1.15e+72)
		tmp = NaChar + (NdChar * 0.5);
	else
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -1.0800000000000001e-70

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 74.3%

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

   5. Taylor expanded in KbT around inf 49.1%

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

   if -1.0800000000000001e-70 < KbT < -6.00000000000000004e-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}}} \]

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 43.5%

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

   5. Taylor expanded in Ev around inf 53.6%

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

   6. Taylor expanded in KbT around inf 18.4%

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

   7. Taylor expanded in NdChar around 0 24.9%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + \frac{Ev}{KbT}}} \]

   if -6.00000000000000004e-201 < KbT < 1.15e72

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 41.8%

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

   5. Taylor expanded in Ev around inf 51.9%

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

   6. Taylor expanded in KbT around inf 17.2%

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

   7. Taylor expanded in Ev around 0 36.3%

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

   if 1.15e72 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 70.0%

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

   5. Taylor expanded in Ev around inf 62.1%

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

4. Final simplification 43.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.08 \cdot 10^{-70}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -6 \cdot 10^{-201}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;KbT \leq 1.15 \cdot 10^{+72}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 19: 39.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.65 \cdot 10^{-68}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -9.5 \cdot 10^{-202}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;KbT \leq 2.6 \cdot 10^{+77}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.65e-68)
   (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
   (if (<= KbT -9.5e-202)
     (/ NaChar (+ 1.0 (/ Ev KbT)))
     (if (<= KbT 2.6e+77)
       (+ NaChar (* NdChar 0.5))
       (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (* NdChar 0.5))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1.65e-68) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= -9.5e-202) {
		tmp = NaChar / (1.0 + (Ev / KbT));
	} else if (KbT <= 2.6e+77) {
		tmp = NaChar + (NdChar * 0.5);
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1.65e-68:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5)
	elif KbT <= -9.5e-202:
		tmp = NaChar / (1.0 + (Ev / KbT))
	elif KbT <= 2.6e+77:
		tmp = NaChar + (NdChar * 0.5)
	else:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -1.65e-68)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= -9.5e-202)
		tmp = Float64(NaChar / Float64(1.0 + Float64(Ev / KbT)));
	elseif (KbT <= 2.6e+77)
		tmp = Float64(NaChar + Float64(NdChar * 0.5));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -1.65e-68)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= -9.5e-202)
		tmp = NaChar / (1.0 + (Ev / KbT));
	elseif (KbT <= 2.6e+77)
		tmp = NaChar + (NdChar * 0.5);
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -1.6499999999999999e-68

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 74.3%

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

   5. Taylor expanded in KbT around inf 49.1%

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

   if -1.6499999999999999e-68 < KbT < -9.5000000000000001e-202

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 43.5%

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

   5. Taylor expanded in Ev around inf 53.6%

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

   6. Taylor expanded in KbT around inf 18.4%

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

   7. Taylor expanded in NdChar around 0 24.9%

      \[\leadsto \color{blue}{\frac{NaChar}{1 + \frac{Ev}{KbT}}} \]

   if -9.5000000000000001e-202 < KbT < 2.6000000000000002e77

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 41.3%

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

   5. Taylor expanded in Ev around inf 51.4%

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

   6. Taylor expanded in KbT around inf 17.1%

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

   7. Taylor expanded in Ev around 0 37.0%

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

   if 2.6000000000000002e77 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 84.7%

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

   5. Taylor expanded in KbT around inf 63.0%

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

4. Final simplification 44.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.65 \cdot 10^{-68}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -9.5 \cdot 10^{-202}:\\ \;\;\;\;\frac{NaChar}{1 + \frac{Ev}{KbT}}\\ \mathbf{elif}\;KbT \leq 2.6 \cdot 10^{+77}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 20: 39.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;KbT \leq -1.6 \cdot 10^{-104}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -1 \cdot 10^{-184}:\\ \;\;\;\;t_0 + \frac{NdChar \cdot KbT}{mu}\\ \mathbf{elif}\;KbT \leq 1.65 \cdot 10^{+82}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;t_0 + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= KbT -1.6e-104)
     (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
     (if (<= KbT -1e-184)
       (+ t_0 (/ (* NdChar KbT) mu))
       (if (<= KbT 1.65e+82)
         (+ NaChar (* NdChar 0.5))
         (+ t_0 (* NdChar 0.5)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (KbT <= -1.6e-104) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= -1e-184) {
		tmp = t_0 + ((NdChar * KbT) / mu);
	} else if (KbT <= 1.65e+82) {
		tmp = NaChar + (NdChar * 0.5);
	} else {
		tmp = t_0 + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((vef / kbt)))
    if (kbt <= (-1.6d-104)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
    else if (kbt <= (-1d-184)) then
        tmp = t_0 + ((ndchar * kbt) / mu)
    else if (kbt <= 1.65d+82) then
        tmp = nachar + (ndchar * 0.5d0)
    else
        tmp = t_0 + (ndchar * 0.5d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (KbT <= -1.6e-104) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
	} else if (KbT <= -1e-184) {
		tmp = t_0 + ((NdChar * KbT) / mu);
	} else if (KbT <= 1.65e+82) {
		tmp = NaChar + (NdChar * 0.5);
	} else {
		tmp = t_0 + (NdChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if KbT <= -1.6e-104:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5)
	elif KbT <= -1e-184:
		tmp = t_0 + ((NdChar * KbT) / mu)
	elif KbT <= 1.65e+82:
		tmp = NaChar + (NdChar * 0.5)
	else:
		tmp = t_0 + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (KbT <= -1.6e-104)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5));
	elseif (KbT <= -1e-184)
		tmp = Float64(t_0 + Float64(Float64(NdChar * KbT) / mu));
	elseif (KbT <= 1.65e+82)
		tmp = Float64(NaChar + Float64(NdChar * 0.5));
	else
		tmp = Float64(t_0 + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (KbT <= -1.6e-104)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
	elseif (KbT <= -1e-184)
		tmp = t_0 + ((NdChar * KbT) / mu);
	elseif (KbT <= 1.65e+82)
		tmp = NaChar + (NdChar * 0.5);
	else
		tmp = t_0 + (NdChar * 0.5);
	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[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.6e-104], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -1e-184], N[(t$95$0 + N[(N[(NdChar * KbT), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.65e+82], N[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -1.59999999999999994e-104

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 75.3%

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

   5. Taylor expanded in KbT around inf 47.9%

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

   if -1.59999999999999994e-104 < KbT < -1.0000000000000001e-184

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 63.1%

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

   5. Taylor expanded in KbT around inf 43.1%

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

      1. associate-+r+ 18.0%

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

   7. Simplified 43.1%

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

   8. Taylor expanded in mu around inf 33.7%

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

   if -1.0000000000000001e-184 < KbT < 1.6499999999999999e82

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 40.4%

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

   5. Taylor expanded in Ev around inf 53.2%

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

   6. Taylor expanded in KbT around inf 18.0%

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

   7. Taylor expanded in Ev around 0 37.6%

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

   if 1.6499999999999999e82 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in Vef around inf 84.7%

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

   5. Taylor expanded in KbT around inf 63.0%

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

4. Final simplification 45.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.6 \cdot 10^{-104}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\ \mathbf{elif}\;KbT \leq -1 \cdot 10^{-184}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar \cdot KbT}{mu}\\ \mathbf{elif}\;KbT \leq 1.65 \cdot 10^{+82}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + NdChar \cdot 0.5\\ \end{array} \]

Alternative 21: 38.9% accurate, 5.3× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.7e+43)
   (+
    (/
     NaChar
     (+
      1.0
      (- (+ 1.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT)))) (/ mu KbT))))
    (/
     NdChar
     (- (+ (+ (/ Vef KbT) (/ mu KbT)) (+ (/ EDonor KbT) 2.0)) (/ Ec KbT))))
   (if (<= KbT 6e+82)
     (+ NaChar (* NdChar 0.5))
     (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT))))))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1.7e+43:
		tmp = (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)))) + (NdChar / ((((Vef / KbT) + (mu / KbT)) + ((EDonor / KbT) + 2.0)) - (Ec / KbT)))
	elif KbT <= 6e+82:
		tmp = NaChar + (NdChar * 0.5)
	else:
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))))
	return tmp

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -1.7e+43)
		tmp = (NaChar / (1.0 + ((1.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)))) + (NdChar / ((((Vef / KbT) + (mu / KbT)) + ((EDonor / KbT) + 2.0)) - (Ec / KbT)));
	elseif (KbT <= 6e+82)
		tmp = NaChar + (NdChar * 0.5);
	else
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.70000000000000006e43

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 70.0%

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

   5. Taylor expanded in KbT around inf 52.4%

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

      1. associate-+r+ 52.4%

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

   7. Simplified 52.4%

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

   if -1.70000000000000006e43 < KbT < 5.99999999999999978e82

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 40.2%

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

   5. Taylor expanded in Ev around inf 50.4%

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

   6. Taylor expanded in KbT around inf 17.7%

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

   7. Taylor expanded in Ev around 0 33.3%

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

   if 5.99999999999999978e82 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in EAccept around inf 83.2%

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

   5. Taylor expanded in KbT around inf 60.7%

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

   6. Taylor expanded in EAccept around 0 58.6%

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

4. Final simplification 42.4%

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

Alternative 22: 40.1% accurate, 13.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.18 \cdot 10^{+197} \lor \neg \left(KbT \leq 9 \cdot 10^{+81}\right):\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -1.18e+197) (not (<= KbT 9e+81)))
   (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
   (+ NaChar (* NdChar 0.5))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -1.18e+197) || !(KbT <= 9e+81)) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else {
		tmp = NaChar + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -1.18e+197) || !(KbT <= 9e+81)) {
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	} else {
		tmp = NaChar + (NdChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -1.18e+197) or not (KbT <= 9e+81):
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))))
	else:
		tmp = NaChar + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -1.18e+197) || !(KbT <= 9e+81))
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT)))));
	else
		tmp = Float64(NaChar + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -1.18e+197) || ~((KbT <= 9e+81)))
		tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
	else
		tmp = NaChar + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -1.18e+197], N[Not[LessEqual[KbT, 9e+81]], $MachinePrecision]], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -1.18e197 or 9.00000000000000034e81 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in EAccept around inf 84.8%

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

   5. Taylor expanded in KbT around inf 64.3%

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

   6. Taylor expanded in EAccept around 0 61.3%

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

   if -1.18e197 < KbT < 9.00000000000000034e81

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 44.8%

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

   5. Taylor expanded in Ev around inf 51.2%

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

   6. Taylor expanded in KbT around inf 20.7%

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

   7. Taylor expanded in Ev around 0 34.9%

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

4. Final simplification 42.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.18 \cdot 10^{+197} \lor \neg \left(KbT \leq 9 \cdot 10^{+81}\right):\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \end{array} \]

Alternative 23: 40.2% accurate, 17.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.2 \cdot 10^{+197}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;KbT \leq 8.4 \cdot 10^{+82}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -2.2e+197)
   (+ (* NdChar 0.5) (/ NaChar (- 2.0 (/ mu KbT))))
   (if (<= KbT 8.4e+82)
     (+ NaChar (* NdChar 0.5))
     (+ (* NdChar 0.5) (/ NaChar 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.2e+197], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 8.4e+82], N[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.19999999999999989e197

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 84.0%

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

      1. associate-*r/ 84.0%

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

      2. mul-1-neg 84.0%

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

   6. Simplified 84.0%

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

   7. Taylor expanded in KbT around inf 65.9%

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

   8. Taylor expanded in mu around 0 65.9%

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

      1. mul-1-neg 65.9%

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

      2. unsub-neg 65.9%

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

   10. Simplified 65.9%

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

   if -2.19999999999999989e197 < KbT < 8.4000000000000001e82

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 44.8%

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

   5. Taylor expanded in Ev around inf 51.2%

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

   6. Taylor expanded in KbT around inf 20.7%

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

   7. Taylor expanded in Ev around 0 34.9%

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

   if 8.4000000000000001e82 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 69.4%

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

   5. Taylor expanded in KbT around inf 58.7%

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

4. Final simplification 42.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.2 \cdot 10^{+197}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;KbT \leq 8.4 \cdot 10^{+82}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\ \end{array} \]

Alternative 24: 40.1% accurate, 20.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -9.5 \cdot 10^{+107} \lor \neg \left(KbT \leq 8.2 \cdot 10^{+82}\right):\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -9.5e+107) (not (<= KbT 8.2e+82)))
   (+ (* NdChar 0.5) (/ NaChar 2.0))
   (+ NaChar (* NdChar 0.5))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -9.5e+107) || !(KbT <= 8.2e+82)) {
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	} else {
		tmp = NaChar + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -9.5e+107) || !(KbT <= 8.2e+82)) {
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	} else {
		tmp = NaChar + (NdChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -9.5e+107) or not (KbT <= 8.2e+82):
		tmp = (NdChar * 0.5) + (NaChar / 2.0)
	else:
		tmp = NaChar + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -9.5e+107) || !(KbT <= 8.2e+82))
		tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / 2.0));
	else
		tmp = Float64(NaChar + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -9.5e+107) || ~((KbT <= 8.2e+82)))
		tmp = (NdChar * 0.5) + (NaChar / 2.0);
	else
		tmp = NaChar + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -9.5e+107], N[Not[LessEqual[KbT, 8.2e+82]], $MachinePrecision]], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -9.50000000000000019e107 or 8.1999999999999999e82 < 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}}} \]

   3. Simplified 99.9%

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

   4. Taylor expanded in KbT around inf 69.6%

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

   5. Taylor expanded in KbT around inf 58.0%

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

   if -9.50000000000000019e107 < KbT < 8.1999999999999999e82

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 41.8%

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

   5. Taylor expanded in Ev around inf 49.3%

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

   6. Taylor expanded in KbT around inf 17.9%

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

   7. Taylor expanded in Ev around 0 33.3%

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

4. Final simplification 42.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -9.5 \cdot 10^{+107} \lor \neg \left(KbT \leq 8.2 \cdot 10^{+82}\right):\\ \;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NaChar + NdChar \cdot 0.5\\ \end{array} \]

Alternative 25: 36.4% accurate, 45.8× speedup

Math

\[\begin{array}{l} \\ NaChar + NdChar \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(NaChar + Float64(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[(NaChar + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 53.8%

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

5. Taylor expanded in Ev around inf 51.9%

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

6. Taylor expanded in KbT around inf 25.7%

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

7. Taylor expanded in Ev around 0 36.3%

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

8. Final simplification 36.3%

   \[\leadsto NaChar + NdChar \cdot 0.5 \]

Alternative 26: 18.4% accurate, 76.3× speedup

Math

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

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

4. Taylor expanded in KbT around inf 53.8%

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

5. Taylor expanded in Ev around inf 51.9%

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

6. Taylor expanded in KbT around inf 25.7%

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

7. Taylor expanded in NdChar around inf 17.8%

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

8. Final simplification 17.8%

   \[\leadsto NdChar \cdot 0.5 \]

Reproduce

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