Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 20.3s

Alternatives: 24

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

FPCore

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

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

5. Final simplification 100.0%

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

Alternative 2: 61.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{if}\;EAccept \leq -2.1 \cdot 10^{-95}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;EAccept \leq 8.5 \cdot 10^{-183}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(Vef + Ev\right) - mu}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 2.25 \cdot 10^{+15}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;EAccept \leq 4 \cdot 10^{+99}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 3.05 \cdot 10^{+267}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + \frac{NdChar}{e^{\frac{Ec}{-KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0))))
   (if (<= EAccept -2.1e-95)
     t_0
     (if (<= EAccept 8.5e-183)
       (/ NaChar (+ (exp (/ (- (+ Vef Ev) mu) KbT)) 1.0))
       (if (<= EAccept 2.25e+15)
         t_0
         (if (<= EAccept 4e+99)
           (/ NaChar (+ (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)) 1.0))
           (if (<= EAccept 3.05e+267)
             t_0
             (+
              (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))
              (/ NdChar (+ (exp (/ Ec (- KbT))) 1.0))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	double tmp;
	if (EAccept <= -2.1e-95) {
		tmp = t_0;
	} else if (EAccept <= 8.5e-183) {
		tmp = NaChar / (exp((((Vef + Ev) - mu) / KbT)) + 1.0);
	} else if (EAccept <= 2.25e+15) {
		tmp = t_0;
	} else if (EAccept <= 4e+99) {
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	} else if (EAccept <= 3.05e+267) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((Ec / -KbT)) + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (exp((((edonor + (mu + vef)) - ec) / kbt)) + 1.0d0)
    if (eaccept <= (-2.1d-95)) then
        tmp = t_0
    else if (eaccept <= 8.5d-183) then
        tmp = nachar / (exp((((vef + ev) - mu) / kbt)) + 1.0d0)
    else if (eaccept <= 2.25d+15) then
        tmp = t_0
    else if (eaccept <= 4d+99) then
        tmp = nachar / (exp((((eaccept + (vef + ev)) - mu) / kbt)) + 1.0d0)
    else if (eaccept <= 3.05d+267) then
        tmp = t_0
    else
        tmp = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + (ndchar / (exp((ec / -kbt)) + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	double tmp;
	if (EAccept <= -2.1e-95) {
		tmp = t_0;
	} else if (EAccept <= 8.5e-183) {
		tmp = NaChar / (Math.exp((((Vef + Ev) - mu) / KbT)) + 1.0);
	} else if (EAccept <= 2.25e+15) {
		tmp = t_0;
	} else if (EAccept <= 4e+99) {
		tmp = NaChar / (Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	} else if (EAccept <= 3.05e+267) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (Math.exp((Ec / -KbT)) + 1.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	tmp = 0
	if EAccept <= -2.1e-95:
		tmp = t_0
	elif EAccept <= 8.5e-183:
		tmp = NaChar / (math.exp((((Vef + Ev) - mu) / KbT)) + 1.0)
	elif EAccept <= 2.25e+15:
		tmp = t_0
	elif EAccept <= 4e+99:
		tmp = NaChar / (math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0)
	elif EAccept <= 3.05e+267:
		tmp = t_0
	else:
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (math.exp((Ec / -KbT)) + 1.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0))
	tmp = 0.0
	if (EAccept <= -2.1e-95)
		tmp = t_0;
	elseif (EAccept <= 8.5e-183)
		tmp = Float64(NaChar / Float64(exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)) + 1.0));
	elseif (EAccept <= 2.25e+15)
		tmp = t_0;
	elseif (EAccept <= 4e+99)
		tmp = Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)) + 1.0));
	elseif (EAccept <= 3.05e+267)
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(Ec / Float64(-KbT))) + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	tmp = 0.0;
	if (EAccept <= -2.1e-95)
		tmp = t_0;
	elseif (EAccept <= 8.5e-183)
		tmp = NaChar / (exp((((Vef + Ev) - mu) / KbT)) + 1.0);
	elseif (EAccept <= 2.25e+15)
		tmp = t_0;
	elseif (EAccept <= 4e+99)
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	elseif (EAccept <= 3.05e+267)
		tmp = t_0;
	else
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((Ec / -KbT)) + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if EAccept < -2.1e-95 or 8.49999999999999973e-183 < EAccept < 2.25e15 or 3.9999999999999999e99 < EAccept < 3.0500000000000002e267

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 69.2%

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

   if -2.1e-95 < EAccept < 8.49999999999999973e-183

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 73.6%

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

   6. Taylor expanded in EAccept around 0 73.6%

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

   if 2.25e15 < EAccept < 3.9999999999999999e99

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 72.2%

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

   if 3.0500000000000002e267 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 100.0%

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

   6. Taylor expanded in Ec around inf 90.6%

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

      1. associate-*r/ 90.6%

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

      2. mul-1-neg 90.6%

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

   8. Simplified 90.6%

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

4. Final simplification 72.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq -2.1 \cdot 10^{-95}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 8.5 \cdot 10^{-183}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(Vef + Ev\right) - mu}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 2.25 \cdot 10^{+15}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 4 \cdot 10^{+99}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 3.05 \cdot 10^{+267}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + \frac{NdChar}{e^{\frac{Ec}{-KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 69.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ t_1 := \frac{NaChar}{e^{\frac{Vef + \left(Ev - \left(mu - EAccept\right)\right)}{KbT}} + 1} + \frac{NdChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{if}\;Vef \leq -7.2 \cdot 10^{-35}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -3.2 \cdot 10^{-139}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 2.7 \cdot 10^{-209}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + \frac{NdChar}{e^{\frac{Ec}{-KbT}} + 1}\\ \mathbf{elif}\;Vef \leq 1.2 \cdot 10^{+43}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0)))
        (t_1
         (+
          (/ NaChar (+ (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT)) 1.0))
          (/ NdChar (+ (exp (/ Vef KbT)) 1.0)))))
   (if (<= Vef -7.2e-35)
     t_1
     (if (<= Vef -3.2e-139)
       t_0
       (if (<= Vef 2.7e-209)
         (+
          (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))
          (/ NdChar (+ (exp (/ Ec (- KbT))) 1.0)))
         (if (<= Vef 1.2e+43) t_0 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	double t_1 = (NaChar / (exp(((Vef + (Ev - (mu - EAccept))) / KbT)) + 1.0)) + (NdChar / (exp((Vef / KbT)) + 1.0));
	double tmp;
	if (Vef <= -7.2e-35) {
		tmp = t_1;
	} else if (Vef <= -3.2e-139) {
		tmp = t_0;
	} else if (Vef <= 2.7e-209) {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((Ec / -KbT)) + 1.0));
	} else if (Vef <= 1.2e+43) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (exp((((edonor + (mu + vef)) - ec) / kbt)) + 1.0d0)
    t_1 = (nachar / (exp(((vef + (ev - (mu - eaccept))) / kbt)) + 1.0d0)) + (ndchar / (exp((vef / kbt)) + 1.0d0))
    if (vef <= (-7.2d-35)) then
        tmp = t_1
    else if (vef <= (-3.2d-139)) then
        tmp = t_0
    else if (vef <= 2.7d-209) then
        tmp = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + (ndchar / (exp((ec / -kbt)) + 1.0d0))
    else if (vef <= 1.2d+43) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	double t_1 = (NaChar / (Math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)) + 1.0)) + (NdChar / (Math.exp((Vef / KbT)) + 1.0));
	double tmp;
	if (Vef <= -7.2e-35) {
		tmp = t_1;
	} else if (Vef <= -3.2e-139) {
		tmp = t_0;
	} else if (Vef <= 2.7e-209) {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (Math.exp((Ec / -KbT)) + 1.0));
	} else if (Vef <= 1.2e+43) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	t_1 = (NaChar / (math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)) + 1.0)) + (NdChar / (math.exp((Vef / KbT)) + 1.0))
	tmp = 0
	if Vef <= -7.2e-35:
		tmp = t_1
	elif Vef <= -3.2e-139:
		tmp = t_0
	elif Vef <= 2.7e-209:
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (math.exp((Ec / -KbT)) + 1.0))
	elif Vef <= 1.2e+43:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0))
	t_1 = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev - Float64(mu - EAccept))) / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)))
	tmp = 0.0
	if (Vef <= -7.2e-35)
		tmp = t_1;
	elseif (Vef <= -3.2e-139)
		tmp = t_0;
	elseif (Vef <= 2.7e-209)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(Ec / Float64(-KbT))) + 1.0)));
	elseif (Vef <= 1.2e+43)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	t_1 = (NaChar / (exp(((Vef + (Ev - (mu - EAccept))) / KbT)) + 1.0)) + (NdChar / (exp((Vef / KbT)) + 1.0));
	tmp = 0.0;
	if (Vef <= -7.2e-35)
		tmp = t_1;
	elseif (Vef <= -3.2e-139)
		tmp = t_0;
	elseif (Vef <= 2.7e-209)
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((Ec / -KbT)) + 1.0));
	elseif (Vef <= 1.2e+43)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Vef < -7.20000000000000038e-35 or 1.20000000000000012e43 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Vef around inf 85.6%

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

   if -7.20000000000000038e-35 < Vef < -3.1999999999999999e-139 or 2.69999999999999998e-209 < Vef < 1.20000000000000012e43

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 78.3%

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

   if -3.1999999999999999e-139 < Vef < 2.69999999999999998e-209

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 82.5%

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

   6. Taylor expanded in Ec around inf 74.6%

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

      1. associate-*r/ 74.6%

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

      2. mul-1-neg 74.6%

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

   8. Simplified 74.6%

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

4. Final simplification 81.1%

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

Alternative 4: 67.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}} + 1}\\ t_1 := \frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} - \frac{NaChar}{-1 - e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{if}\;Vef \leq -2.9 \cdot 10^{-33}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -2.15 \cdot 10^{-138}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 5.8 \cdot 10^{-199}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + \frac{NdChar}{e^{\frac{Ec}{-KbT}} + 1}\\ \mathbf{elif}\;Vef \leq 10^{+46}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0)))
        (t_1
         (-
          (/ NdChar (+ (exp (/ Vef KbT)) 1.0))
          (/ NaChar (- -1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))))
   (if (<= Vef -2.9e-33)
     t_1
     (if (<= Vef -2.15e-138)
       t_0
       (if (<= Vef 5.8e-199)
         (+
          (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))
          (/ NdChar (+ (exp (/ Ec (- KbT))) 1.0)))
         (if (<= Vef 1e+46) t_0 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	double t_1 = (NdChar / (exp((Vef / KbT)) + 1.0)) - (NaChar / (-1.0 - exp((((Vef + Ev) - mu) / KbT))));
	double tmp;
	if (Vef <= -2.9e-33) {
		tmp = t_1;
	} else if (Vef <= -2.15e-138) {
		tmp = t_0;
	} else if (Vef <= 5.8e-199) {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((Ec / -KbT)) + 1.0));
	} else if (Vef <= 1e+46) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (exp((((edonor + (mu + vef)) - ec) / kbt)) + 1.0d0)
    t_1 = (ndchar / (exp((vef / kbt)) + 1.0d0)) - (nachar / ((-1.0d0) - exp((((vef + ev) - mu) / kbt))))
    if (vef <= (-2.9d-33)) then
        tmp = t_1
    else if (vef <= (-2.15d-138)) then
        tmp = t_0
    else if (vef <= 5.8d-199) then
        tmp = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + (ndchar / (exp((ec / -kbt)) + 1.0d0))
    else if (vef <= 1d+46) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	double t_1 = (NdChar / (Math.exp((Vef / KbT)) + 1.0)) - (NaChar / (-1.0 - Math.exp((((Vef + Ev) - mu) / KbT))));
	double tmp;
	if (Vef <= -2.9e-33) {
		tmp = t_1;
	} else if (Vef <= -2.15e-138) {
		tmp = t_0;
	} else if (Vef <= 5.8e-199) {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (Math.exp((Ec / -KbT)) + 1.0));
	} else if (Vef <= 1e+46) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	t_1 = (NdChar / (math.exp((Vef / KbT)) + 1.0)) - (NaChar / (-1.0 - math.exp((((Vef + Ev) - mu) / KbT))))
	tmp = 0
	if Vef <= -2.9e-33:
		tmp = t_1
	elif Vef <= -2.15e-138:
		tmp = t_0
	elif Vef <= 5.8e-199:
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (math.exp((Ec / -KbT)) + 1.0))
	elif Vef <= 1e+46:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0))
	t_1 = Float64(Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)) - Float64(NaChar / Float64(-1.0 - exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)))))
	tmp = 0.0
	if (Vef <= -2.9e-33)
		tmp = t_1;
	elseif (Vef <= -2.15e-138)
		tmp = t_0;
	elseif (Vef <= 5.8e-199)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(Ec / Float64(-KbT))) + 1.0)));
	elseif (Vef <= 1e+46)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	t_1 = (NdChar / (exp((Vef / KbT)) + 1.0)) - (NaChar / (-1.0 - exp((((Vef + Ev) - mu) / KbT))));
	tmp = 0.0;
	if (Vef <= -2.9e-33)
		tmp = t_1;
	elseif (Vef <= -2.15e-138)
		tmp = t_0;
	elseif (Vef <= 5.8e-199)
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((Ec / -KbT)) + 1.0));
	elseif (Vef <= 1e+46)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] - N[(NaChar / N[(-1.0 - N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -2.9e-33], t$95$1, If[LessEqual[Vef, -2.15e-138], t$95$0, If[LessEqual[Vef, 5.8e-199], N[(N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1e+46], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -2.90000000000000003e-33 or 9.9999999999999999e45 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Vef around inf 85.4%

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

   6. Taylor expanded in EAccept around 0 80.5%

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

   if -2.90000000000000003e-33 < Vef < -2.15e-138 or 5.8e-199 < Vef < 9.9999999999999999e45

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 78.9%

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

   if -2.15e-138 < Vef < 5.8e-199

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 82.5%

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

   6. Taylor expanded in Ec around inf 74.6%

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

      1. associate-*r/ 74.6%

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

      2. mul-1-neg 74.6%

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

   8. Simplified 74.6%

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

4. Final simplification 78.7%

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

Alternative 5: 76.3% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ (exp (/ Vef KbT)) 1.0))))
   (if (<= Vef -4.2e-34)
     (+ (/ NaChar (+ (exp (/ (+ Vef (- Ev (- mu EAccept))) KbT)) 1.0)) t_0)
     (if (<= Vef -9.5e-80)
       (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0))
       (if (<= Vef 6.8e+124)
         (-
          (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))
          (/ NdChar (- -1.0 (exp (/ (- EDonor (- (- Ec Vef) mu)) KbT)))))
         (- t_0 (/ NaChar (- -1.0 (exp (/ (- (+ Vef Ev) mu) 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 / (exp((Vef / KbT)) + 1.0);
	double tmp;
	if (Vef <= -4.2e-34) {
		tmp = (NaChar / (exp(((Vef + (Ev - (mu - EAccept))) / KbT)) + 1.0)) + t_0;
	} else if (Vef <= -9.5e-80) {
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	} else if (Vef <= 6.8e+124) {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) - (NdChar / (-1.0 - exp(((EDonor - ((Ec - Vef) - mu)) / KbT))));
	} else {
		tmp = t_0 - (NaChar / (-1.0 - exp((((Vef + Ev) - mu) / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp((Vef / KbT)) + 1.0)
	tmp = 0
	if Vef <= -4.2e-34:
		tmp = (NaChar / (math.exp(((Vef + (Ev - (mu - EAccept))) / KbT)) + 1.0)) + t_0
	elif Vef <= -9.5e-80:
		tmp = NdChar / (math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0)
	elif Vef <= 6.8e+124:
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) - (NdChar / (-1.0 - math.exp(((EDonor - ((Ec - Vef) - mu)) / KbT))))
	else:
		tmp = t_0 - (NaChar / (-1.0 - math.exp((((Vef + Ev) - mu) / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0))
	tmp = 0.0
	if (Vef <= -4.2e-34)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev - Float64(mu - EAccept))) / KbT)) + 1.0)) + t_0);
	elseif (Vef <= -9.5e-80)
		tmp = Float64(NdChar / Float64(exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)) + 1.0));
	elseif (Vef <= 6.8e+124)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(EDonor - Float64(Float64(Ec - Vef) - mu)) / KbT)))));
	else
		tmp = Float64(t_0 - Float64(NaChar / Float64(-1.0 - exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (exp((Vef / KbT)) + 1.0);
	tmp = 0.0;
	if (Vef <= -4.2e-34)
		tmp = (NaChar / (exp(((Vef + (Ev - (mu - EAccept))) / KbT)) + 1.0)) + t_0;
	elseif (Vef <= -9.5e-80)
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	elseif (Vef <= 6.8e+124)
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) - (NdChar / (-1.0 - exp(((EDonor - ((Ec - Vef) - mu)) / KbT))));
	else
		tmp = t_0 - (NaChar / (-1.0 - exp((((Vef + Ev) - mu) / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if Vef < -4.2000000000000002e-34

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 82.4%

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

   if -4.2000000000000002e-34 < Vef < -9.5000000000000003e-80

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 85.2%

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

   if -9.5000000000000003e-80 < Vef < 6.8e124

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 82.0%

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

   if 6.8e124 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in Vef around inf 94.4%

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

   6. Taylor expanded in EAccept around 0 89.1%

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

4. Final simplification 83.2%

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

Alternative 6: 43.9% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{if}\;Vef \leq -1.85 \cdot 10^{-25}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq -3.2 \cdot 10^{-151}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{elif}\;Vef \leq -1.4 \cdot 10^{-234}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{elif}\;Vef \leq 1.35 \cdot 10^{+58}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{mu}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ (exp (/ Vef KbT)) 1.0))))
   (if (<= Vef -1.85e-25)
     t_0
     (if (<= Vef -3.2e-151)
       (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))
       (if (<= Vef -1.4e-234)
         (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
         (if (<= Vef 1.35e+58) (/ NdChar (+ (exp (/ mu KbT)) 1.0)) t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (exp((Vef / KbT)) + 1.0);
	double tmp;
	if (Vef <= -1.85e-25) {
		tmp = t_0;
	} else if (Vef <= -3.2e-151) {
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	} else if (Vef <= -1.4e-234) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else if (Vef <= 1.35e+58) {
		tmp = NdChar / (exp((mu / KbT)) + 1.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (exp((vef / kbt)) + 1.0d0)
    if (vef <= (-1.85d-25)) then
        tmp = t_0
    else if (vef <= (-3.2d-151)) then
        tmp = ndchar / (exp((edonor / kbt)) + 1.0d0)
    else if (vef <= (-1.4d-234)) then
        tmp = nachar / (exp((ev / kbt)) + 1.0d0)
    else if (vef <= 1.35d+58) then
        tmp = ndchar / (exp((mu / kbt)) + 1.0d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (Math.exp((Vef / KbT)) + 1.0);
	double tmp;
	if (Vef <= -1.85e-25) {
		tmp = t_0;
	} else if (Vef <= -3.2e-151) {
		tmp = NdChar / (Math.exp((EDonor / KbT)) + 1.0);
	} else if (Vef <= -1.4e-234) {
		tmp = NaChar / (Math.exp((Ev / KbT)) + 1.0);
	} else if (Vef <= 1.35e+58) {
		tmp = NdChar / (Math.exp((mu / KbT)) + 1.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (math.exp((Vef / KbT)) + 1.0)
	tmp = 0
	if Vef <= -1.85e-25:
		tmp = t_0
	elif Vef <= -3.2e-151:
		tmp = NdChar / (math.exp((EDonor / KbT)) + 1.0)
	elif Vef <= -1.4e-234:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	elif Vef <= 1.35e+58:
		tmp = NdChar / (math.exp((mu / KbT)) + 1.0)
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(exp(Float64(Vef / KbT)) + 1.0))
	tmp = 0.0
	if (Vef <= -1.85e-25)
		tmp = t_0;
	elseif (Vef <= -3.2e-151)
		tmp = Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0));
	elseif (Vef <= -1.4e-234)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	elseif (Vef <= 1.35e+58)
		tmp = Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (exp((Vef / KbT)) + 1.0);
	tmp = 0.0;
	if (Vef <= -1.85e-25)
		tmp = t_0;
	elseif (Vef <= -3.2e-151)
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	elseif (Vef <= -1.4e-234)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	elseif (Vef <= 1.35e+58)
		tmp = NdChar / (exp((mu / KbT)) + 1.0);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -1.85e-25], t$95$0, If[LessEqual[Vef, -3.2e-151], N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -1.4e-234], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.35e+58], N[(NdChar / N[(N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -1.85000000000000004e-25 or 1.3500000000000001e58 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 70.3%

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

   6. Taylor expanded in Vef around inf 57.0%

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

   if -1.85000000000000004e-25 < Vef < -3.20000000000000021e-151

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 87.5%

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

   6. Taylor expanded in EDonor around inf 58.6%

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

   if -3.20000000000000021e-151 < Vef < -1.3999999999999999e-234

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 77.0%

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

   6. Taylor expanded in Ev around inf 61.1%

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

   if -1.3999999999999999e-234 < Vef < 1.3500000000000001e58

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 70.3%

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

   6. Taylor expanded in mu around inf 50.4%

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

4. Final simplification 55.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -1.85 \cdot 10^{-25}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{elif}\;Vef \leq -3.2 \cdot 10^{-151}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{elif}\;Vef \leq -1.4 \cdot 10^{-234}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{elif}\;Vef \leq 1.35 \cdot 10^{+58}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{mu}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 69.0% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -2.2e+136) (not (<= NaChar 4.8e+59)))
   (/ NaChar (+ (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)) 1.0))
   (/ NdChar (+ (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)) 1.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -2.2e+136) || ~((NaChar <= 4.8e+59)))
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	else
		tmp = NdChar / (exp((((EDonor + (mu + Vef)) - Ec) / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.1999999999999999e136 or 4.8000000000000004e59 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 75.2%

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

   if -2.1999999999999999e136 < NaChar < 4.8000000000000004e59

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 72.4%

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

4. Final simplification 73.4%

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

Alternative 8: 58.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.72 \cdot 10^{-118} \lor \neg \left(NaChar \leq 2.4 \cdot 10^{-55}\right):\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Ec}{-KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.72e-118) (not (<= NaChar 2.4e-55)))
   (/ NaChar (+ (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)) 1.0))
   (/ NdChar (+ (exp (/ Ec (- KbT))) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -1.72e-118) || !(NaChar <= 2.4e-55)) {
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	} else {
		tmp = NdChar / (exp((Ec / -KbT)) + 1.0);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -1.72e-118) || ~((NaChar <= 2.4e-55)))
		tmp = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	else
		tmp = NdChar / (exp((Ec / -KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.72e-118], N[Not[LessEqual[NaChar, 2.4e-55]], $MachinePrecision]], N[(NaChar / N[(N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.72e-118 or 2.39999999999999991e-55 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 66.1%

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

   if -1.72e-118 < NaChar < 2.39999999999999991e-55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 82.6%

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

   6. Taylor expanded in Ec around inf 62.3%

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

      1. associate-*r/ 62.3%

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

      2. neg-mul-1 62.3%

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

   8. Simplified 62.3%

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

4. Final simplification 64.9%

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

Alternative 9: 49.8% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq -5.2 \cdot 10^{-91}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Ec}{-KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 8.5 \cdot 10^{+99}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(Vef + Ev\right) - mu}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 1.82 \cdot 10^{+202}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{mu}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept -5.2e-91)
   (/ NdChar (+ (exp (/ Ec (- KbT))) 1.0))
   (if (<= EAccept 8.5e+99)
     (/ NaChar (+ (exp (/ (- (+ Vef Ev) mu) KbT)) 1.0))
     (if (<= EAccept 1.82e+202)
       (/ NdChar (+ (exp (/ mu KbT)) 1.0))
       (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (EAccept <= -5.2e-91) {
		tmp = NdChar / (exp((Ec / -KbT)) + 1.0);
	} else if (EAccept <= 8.5e+99) {
		tmp = NaChar / (exp((((Vef + Ev) - mu) / KbT)) + 1.0);
	} else if (EAccept <= 1.82e+202) {
		tmp = NdChar / (exp((mu / KbT)) + 1.0);
	} else {
		tmp = NaChar / (exp((EAccept / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (eaccept <= (-5.2d-91)) then
        tmp = ndchar / (exp((ec / -kbt)) + 1.0d0)
    else if (eaccept <= 8.5d+99) then
        tmp = nachar / (exp((((vef + ev) - mu) / kbt)) + 1.0d0)
    else if (eaccept <= 1.82d+202) then
        tmp = ndchar / (exp((mu / kbt)) + 1.0d0)
    else
        tmp = nachar / (exp((eaccept / kbt)) + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (EAccept <= -5.2e-91) {
		tmp = NdChar / (Math.exp((Ec / -KbT)) + 1.0);
	} else if (EAccept <= 8.5e+99) {
		tmp = NaChar / (Math.exp((((Vef + Ev) - mu) / KbT)) + 1.0);
	} else if (EAccept <= 1.82e+202) {
		tmp = NdChar / (Math.exp((mu / KbT)) + 1.0);
	} else {
		tmp = NaChar / (Math.exp((EAccept / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if EAccept <= -5.2e-91:
		tmp = NdChar / (math.exp((Ec / -KbT)) + 1.0)
	elif EAccept <= 8.5e+99:
		tmp = NaChar / (math.exp((((Vef + Ev) - mu) / KbT)) + 1.0)
	elif EAccept <= 1.82e+202:
		tmp = NdChar / (math.exp((mu / KbT)) + 1.0)
	else:
		tmp = NaChar / (math.exp((EAccept / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (EAccept <= -5.2e-91)
		tmp = Float64(NdChar / Float64(exp(Float64(Ec / Float64(-KbT))) + 1.0));
	elseif (EAccept <= 8.5e+99)
		tmp = Float64(NaChar / Float64(exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)) + 1.0));
	elseif (EAccept <= 1.82e+202)
		tmp = Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0));
	else
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (EAccept <= -5.2e-91)
		tmp = NdChar / (exp((Ec / -KbT)) + 1.0);
	elseif (EAccept <= 8.5e+99)
		tmp = NaChar / (exp((((Vef + Ev) - mu) / KbT)) + 1.0);
	elseif (EAccept <= 1.82e+202)
		tmp = NdChar / (exp((mu / KbT)) + 1.0);
	else
		tmp = NaChar / (exp((EAccept / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EAccept, -5.2e-91], N[(NdChar / N[(N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 8.5e+99], N[(NaChar / N[(N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.82e+202], N[(NdChar / N[(N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if EAccept < -5.20000000000000028e-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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around inf 64.1%

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

   6. Taylor expanded in Ec around inf 45.9%

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

      1. associate-*r/ 45.9%

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

      2. neg-mul-1 45.9%

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

   8. Simplified 45.9%

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

   if -5.20000000000000028e-91 < EAccept < 8.49999999999999984e99

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 66.1%

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

   6. Taylor expanded in EAccept around 0 65.3%

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

   if 8.49999999999999984e99 < EAccept < 1.82e202

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 82.1%

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

   6. Taylor expanded in mu around inf 61.3%

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

   if 1.82e202 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 94.8%

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

   6. Taylor expanded in NdChar around 0 64.9%

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

4. Final simplification 59.2%

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

Alternative 10: 43.8% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{if}\;NaChar \leq -1.5 \cdot 10^{+116}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NaChar \leq 6.8 \cdot 10^{-248}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Ec}{-KbT}} + 1}\\ \mathbf{elif}\;NaChar \leq 1.05 \cdot 10^{+74}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ (exp (/ Vef KbT)) 1.0))))
   (if (<= NaChar -1.5e+116)
     t_0
     (if (<= NaChar 6.8e-248)
       (/ NdChar (+ (exp (/ Ec (- KbT))) 1.0))
       (if (<= NaChar 1.05e+74)
         (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))
         t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (exp((Vef / KbT)) + 1.0);
	double tmp;
	if (NaChar <= -1.5e+116) {
		tmp = t_0;
	} else if (NaChar <= 6.8e-248) {
		tmp = NdChar / (exp((Ec / -KbT)) + 1.0);
	} else if (NaChar <= 1.05e+74) {
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.5e+116], t$95$0, If[LessEqual[NaChar, 6.8e-248], N[(NdChar / N[(N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.05e+74], N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.4999999999999999e116 or 1.0499999999999999e74 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 73.3%

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

   6. Taylor expanded in Vef around inf 57.0%

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

   if -1.4999999999999999e116 < NaChar < 6.7999999999999996e-248

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 72.2%

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

   6. Taylor expanded in Ec around inf 55.4%

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

      1. associate-*r/ 55.4%

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

      2. neg-mul-1 55.4%

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

   8. Simplified 55.4%

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

   if 6.7999999999999996e-248 < NaChar < 1.0499999999999999e74

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 72.9%

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

   6. Taylor expanded in EDonor around inf 53.2%

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

4. Final simplification 55.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.5 \cdot 10^{+116}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{elif}\;NaChar \leq 6.8 \cdot 10^{-248}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Ec}{-KbT}} + 1}\\ \mathbf{elif}\;NaChar \leq 1.05 \cdot 10^{+74}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 44.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{Vef}{KbT}} + 1\\ t_1 := \frac{NaChar}{t\_0}\\ \mathbf{if}\;NaChar \leq -3.2 \cdot 10^{+131}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;NaChar \leq 2.15 \cdot 10^{-247}:\\ \;\;\;\;\frac{NdChar}{t\_0}\\ \mathbf{elif}\;NaChar \leq 1.35 \cdot 10^{+74}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (exp (/ Vef KbT)) 1.0)) (t_1 (/ NaChar t_0)))
   (if (<= NaChar -3.2e+131)
     t_1
     (if (<= NaChar 2.15e-247)
       (/ NdChar t_0)
       (if (<= NaChar 1.35e+74)
         (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = exp((Vef / KbT)) + 1.0;
	double t_1 = NaChar / t_0;
	double tmp;
	if (NaChar <= -3.2e+131) {
		tmp = t_1;
	} else if (NaChar <= 2.15e-247) {
		tmp = NdChar / t_0;
	} else if (NaChar <= 1.35e+74) {
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = Math.exp((Vef / KbT)) + 1.0;
	double t_1 = NaChar / t_0;
	double tmp;
	if (NaChar <= -3.2e+131) {
		tmp = t_1;
	} else if (NaChar <= 2.15e-247) {
		tmp = NdChar / t_0;
	} else if (NaChar <= 1.35e+74) {
		tmp = NdChar / (Math.exp((EDonor / KbT)) + 1.0);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = math.exp((Vef / KbT)) + 1.0
	t_1 = NaChar / t_0
	tmp = 0
	if NaChar <= -3.2e+131:
		tmp = t_1
	elif NaChar <= 2.15e-247:
		tmp = NdChar / t_0
	elif NaChar <= 1.35e+74:
		tmp = NdChar / (math.exp((EDonor / KbT)) + 1.0)
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(exp(Float64(Vef / KbT)) + 1.0)
	t_1 = Float64(NaChar / t_0)
	tmp = 0.0
	if (NaChar <= -3.2e+131)
		tmp = t_1;
	elseif (NaChar <= 2.15e-247)
		tmp = Float64(NdChar / t_0);
	elseif (NaChar <= 1.35e+74)
		tmp = Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp((Vef / KbT)) + 1.0;
	t_1 = NaChar / t_0;
	tmp = 0.0;
	if (NaChar <= -3.2e+131)
		tmp = t_1;
	elseif (NaChar <= 2.15e-247)
		tmp = NdChar / t_0;
	elseif (NaChar <= 1.35e+74)
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / t$95$0), $MachinePrecision]}, If[LessEqual[NaChar, -3.2e+131], t$95$1, If[LessEqual[NaChar, 2.15e-247], N[(NdChar / t$95$0), $MachinePrecision], If[LessEqual[NaChar, 1.35e+74], N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -3.2000000000000002e131 or 1.3499999999999999e74 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 75.7%

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

   6. Taylor expanded in Vef around inf 58.3%

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

   if -3.2000000000000002e131 < NaChar < 2.15000000000000003e-247

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 69.7%

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

   6. Taylor expanded in NdChar around inf 50.4%

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

   if 2.15000000000000003e-247 < NaChar < 1.3499999999999999e74

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 72.9%

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

   6. Taylor expanded in EDonor around inf 53.2%

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

4. Final simplification 53.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -3.2 \cdot 10^{+131}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{elif}\;NaChar \leq 2.15 \cdot 10^{-247}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{elif}\;NaChar \leq 1.35 \cdot 10^{+74}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 44.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -5 \cdot 10^{+115} \lor \neg \left(NaChar \leq 1.35 \cdot 10^{+72}\right):\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -5e+115) (not (<= NaChar 1.35e+72)))
   (/ NaChar (+ (exp (/ Vef KbT)) 1.0))
   (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -5e+115) || !(NaChar <= 1.35e+72)) {
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	} else {
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -5e+115) || ~((NaChar <= 1.35e+72)))
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	else
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -5e+115], N[Not[LessEqual[NaChar, 1.35e+72]], $MachinePrecision]], N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -5.00000000000000008e115 or 1.35e72 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 73.3%

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

   6. Taylor expanded in Vef around inf 57.0%

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

   if -5.00000000000000008e115 < NaChar < 1.35e72

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 72.4%

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

   6. Taylor expanded in EDonor around inf 45.3%

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

4. Final simplification 49.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -5 \cdot 10^{+115} \lor \neg \left(NaChar \leq 1.35 \cdot 10^{+72}\right):\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 40.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -3.7 \cdot 10^{+109} \lor \neg \left(KbT \leq 4 \cdot 10^{+71}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -3.7e+109) (not (<= KbT 4e+71)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -3.7e+109], N[Not[LessEqual[KbT, 4e+71]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -3.7000000000000002e109 or 4.0000000000000002e71 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 57.9%

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

      1. distribute-lft-out 57.9%

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

   7. Simplified 57.9%

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

   if -3.7000000000000002e109 < KbT < 4.0000000000000002e71

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 68.8%

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

   6. Taylor expanded in NdChar around 0 35.4%

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

4. Final simplification 44.4%

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

Alternative 14: 39.2% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -1.5 \cdot 10^{+74}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{elif}\;Ev \leq 2.35 \cdot 10^{-275}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -1.5e+74)
   (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
   (if (<= Ev 2.35e-275)
     (/ NaChar (+ (exp (/ Vef KbT)) 1.0))
     (/ NaChar (+ (exp (/ EAccept KbT)) 1.0)))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Ev <= -1.5e+74:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	elif Ev <= 2.35e-275:
		tmp = NaChar / (math.exp((Vef / KbT)) + 1.0)
	else:
		tmp = NaChar / (math.exp((EAccept / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Ev <= -1.5e+74)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	elseif (Ev <= 2.35e-275)
		tmp = Float64(NaChar / Float64(exp(Float64(Vef / KbT)) + 1.0));
	else
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Ev <= -1.5e+74)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	elseif (Ev <= 2.35e-275)
		tmp = NaChar / (exp((Vef / KbT)) + 1.0);
	else
		tmp = NaChar / (exp((EAccept / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -1.5e74

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 53.5%

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

   6. Taylor expanded in Ev around inf 42.5%

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

   if -1.5e74 < Ev < 2.3499999999999999e-275

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 63.7%

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

   6. Taylor expanded in Vef around inf 49.8%

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

   if 2.3499999999999999e-275 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 74.2%

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

   6. Taylor expanded in NdChar around 0 39.1%

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

4. Final simplification 43.5%

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

Alternative 15: 37.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -15000:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -15000

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 57.0%

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

   6. Taylor expanded in Ev around inf 42.9%

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

   if -15000 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 76.2%

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

   6. Taylor expanded in NdChar around 0 41.8%

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

4. Final simplification 42.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -15000:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 32.0% accurate, 6.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.95 \cdot 10^{-33} \lor \neg \left(KbT \leq 2.7 \cdot 10^{+96}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{mu \cdot \left(\frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)}{mu} + \frac{-1}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -2.95e-33) (not (<= KbT 2.7e+96)))
   (* 0.5 (+ NdChar NaChar))
   (/
    NaChar
    (*
     mu
     (+
      (/ (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT)))) mu)
      (/ -1.0 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 <= -2.95e-33) || !(KbT <= 2.7e+96)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (mu * (((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) / mu) + (-1.0 / 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 <= (-2.95d-33)) .or. (.not. (kbt <= 2.7d+96))) then
        tmp = 0.5d0 * (ndchar + nachar)
    else
        tmp = nachar / (mu * (((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) / mu) + ((-1.0d0) / 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 <= -2.95e-33) || !(KbT <= 2.7e+96)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (mu * (((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) / mu) + (-1.0 / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -2.95e-33) or not (KbT <= 2.7e+96):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / (mu * (((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) / mu) + (-1.0 / KbT)))
	return tmp

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -2.95e-33], N[Not[LessEqual[KbT, 2.7e+96]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(mu * N[(N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -2.94999999999999993e-33 or 2.70000000000000022e96 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 50.4%

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

      1. distribute-lft-out 50.4%

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

   7. Simplified 50.4%

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

   if -2.94999999999999993e-33 < KbT < 2.70000000000000022e96

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 59.8%

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

   6. Taylor expanded in KbT around inf 24.5%

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

   7. Taylor expanded in mu around -inf 26.2%

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

      1. associate-*r* 26.2%

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

      2. mul-1-neg 26.2%

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

      3. +-commutative 26.2%

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

      4. mul-1-neg 26.2%

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

      5. unsub-neg 26.2%

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

      6. +-commutative 26.2%

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

   9. Simplified 26.2%

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

4. Final simplification 38.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.95 \cdot 10^{-33} \lor \neg \left(KbT \leq 2.7 \cdot 10^{+96}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{mu \cdot \left(\frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)}{mu} + \frac{-1}{KbT}\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 30.8% accurate, 6.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -3.4e-36) or not (KbT <= 3.8e+96):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / ((2.0 + ((EAccept / KbT) + (Ev * ((Vef / (KbT * Ev)) - (-1.0 / KbT))))) - (mu / KbT))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -3.4000000000000003e-36 or 3.8000000000000002e96 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 50.4%

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

      1. distribute-lft-out 50.4%

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

   7. Simplified 50.4%

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

   if -3.4000000000000003e-36 < KbT < 3.8000000000000002e96

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 59.8%

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

   6. Taylor expanded in KbT around inf 24.5%

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

   7. Taylor expanded in Ev around inf 26.8%

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

4. Final simplification 38.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.4 \cdot 10^{-36} \lor \neg \left(KbT \leq 3.8 \cdot 10^{+96}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + Ev \cdot \left(\frac{Vef}{KbT \cdot Ev} - \frac{-1}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 32.0% accurate, 9.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -5.7e-36) (not (<= KbT 3.4e+96)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (+ 2.0 (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -5.7e-36) or not (KbT <= 3.4e+96):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / (2.0 + (((EAccept + (Vef + Ev)) - mu) / KbT))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -5.6999999999999999e-36 or 3.4000000000000001e96 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 50.4%

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

      1. distribute-lft-out 50.4%

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

   7. Simplified 50.4%

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

   if -5.6999999999999999e-36 < KbT < 3.4000000000000001e96

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 59.8%

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

   6. Taylor expanded in KbT around inf 24.5%

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

   7. Taylor expanded in KbT around -inf 25.4%

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

      1. mul-1-neg 25.4%

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

      2. unsub-neg 25.4%

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

      3. sub-neg 25.4%

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

      4. +-commutative 25.4%

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

      5. mul-1-neg 25.4%

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

      6. unsub-neg 25.4%

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

      7. +-commutative 25.4%

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

      8. mul-1-neg 25.4%

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

      9. unsub-neg 25.4%

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

      10. mul-1-neg 25.4%

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

      11. mul-1-neg 25.4%

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

      12. remove-double-neg 25.4%

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

   9. Simplified 25.4%

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

4. Final simplification 38.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -5.7 \cdot 10^{-36} \lor \neg \left(KbT \leq 3.4 \cdot 10^{+96}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2 + \frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 19: 30.4% accurate, 9.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -3.6 \cdot 10^{-34} \lor \neg \left(KbT \leq 2.5 \cdot 10^{+96}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2 - \left(\frac{mu - Vef}{KbT} - \frac{Ev}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -3.6e-34) (not (<= KbT 2.5e+96)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (- 2.0 (- (/ (- mu Vef) KbT) (/ Ev 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 <= -3.6e-34) || !(KbT <= 2.5e+96)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (2.0 - (((mu - Vef) / KbT) - (Ev / 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 <= (-3.6d-34)) .or. (.not. (kbt <= 2.5d+96))) then
        tmp = 0.5d0 * (ndchar + nachar)
    else
        tmp = nachar / (2.0d0 - (((mu - vef) / kbt) - (ev / 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 <= -3.6e-34) || !(KbT <= 2.5e+96)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (2.0 - (((mu - Vef) / KbT) - (Ev / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -3.6e-34) or not (KbT <= 2.5e+96):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / (2.0 - (((mu - Vef) / KbT) - (Ev / KbT)))
	return tmp

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -3.6e-34], N[Not[LessEqual[KbT, 2.5e+96]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(2.0 - N[(N[(N[(mu - Vef), $MachinePrecision] / KbT), $MachinePrecision] - N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -3.60000000000000008e-34 or 2.5000000000000002e96 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 50.4%

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

      1. distribute-lft-out 50.4%

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

   7. Simplified 50.4%

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

   if -3.60000000000000008e-34 < KbT < 2.5000000000000002e96

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 59.8%

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

   6. Taylor expanded in KbT around inf 24.5%

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

   7. Taylor expanded in EAccept around 0 20.8%

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

      1. associate--l+ 20.8%

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

      2. associate--l+ 20.8%

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

      3. div-sub 20.9%

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

   9. Simplified 20.9%

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

4. Final simplification 35.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.6 \cdot 10^{-34} \lor \neg \left(KbT \leq 2.5 \cdot 10^{+96}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2 - \left(\frac{mu - Vef}{KbT} - \frac{Ev}{KbT}\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 20: 28.2% accurate, 13.4× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -1e-207) (not (<= KbT 6.5e+70)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (+ (/ EAccept KbT) 2.0))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -1e-207) or not (KbT <= 6.5e+70):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / ((EAccept / KbT) + 2.0)
	return tmp

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -1e-207], N[Not[LessEqual[KbT, 6.5e+70]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -9.99999999999999925e-208 or 6.49999999999999978e70 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 41.8%

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

      1. distribute-lft-out 41.8%

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

   7. Simplified 41.8%

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

   if -9.99999999999999925e-208 < KbT < 6.49999999999999978e70

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 74.2%

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

   6. Taylor expanded in NdChar around 0 41.5%

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

   7. Taylor expanded in EAccept around 0 23.3%

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

4. Final simplification 35.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1 \cdot 10^{-207} \lor \neg \left(KbT \leq 6.5 \cdot 10^{+70}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 21: 29.2% accurate, 15.2× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -9.5e-106) (not (<= KbT 1.65e-77)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (/ Vef 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 <= -9.5e-106) || !(KbT <= 1.65e-77)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (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) :: tmp
    if ((kbt <= (-9.5d-106)) .or. (.not. (kbt <= 1.65d-77))) then
        tmp = 0.5d0 * (ndchar + nachar)
    else
        tmp = nachar / (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 tmp;
	if ((KbT <= -9.5e-106) || !(KbT <= 1.65e-77)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (Vef / KbT);
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -9.5e-106) || !(KbT <= 1.65e-77))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar / Float64(Vef / KbT));
	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-106) || ~((KbT <= 1.65e-77)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar / (Vef / KbT);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -9.4999999999999994e-106 or 1.64999999999999996e-77 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 40.8%

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

      1. distribute-lft-out 40.8%

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

   7. Simplified 40.8%

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

   if -9.4999999999999994e-106 < KbT < 1.64999999999999996e-77

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 53.6%

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

   6. Taylor expanded in KbT around inf 27.9%

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

   7. Taylor expanded in Vef around inf 22.3%

      \[\leadsto \frac{NaChar}{\color{blue}{\frac{Vef}{KbT}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 35.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -9.5 \cdot 10^{-106} \lor \neg \left(KbT \leq 1.65 \cdot 10^{-77}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Vef}{KbT}}\\ \end{array} \]
5. Add Preprocessing

Alternative 22: 22.8% accurate, 17.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -5.2 \cdot 10^{+35} \lor \neg \left(NaChar \leq 5.4 \cdot 10^{+58}\right):\\ \;\;\;\;\frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -5.2e+35) (not (<= NaChar 5.4e+58)))
   (/ NaChar 2.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 tmp;
	if ((NaChar <= -5.2e+35) || !(NaChar <= 5.4e+58)) {
		tmp = NaChar / 2.0;
	} else {
		tmp = 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 ((nachar <= (-5.2d+35)) .or. (.not. (nachar <= 5.4d+58))) then
        tmp = nachar / 2.0d0
    else
        tmp = 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 ((NaChar <= -5.2e+35) || !(NaChar <= 5.4e+58)) {
		tmp = NaChar / 2.0;
	} else {
		tmp = NdChar * 0.5;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -5.2e+35) or not (NaChar <= 5.4e+58):
		tmp = NaChar / 2.0
	else:
		tmp = NdChar * 0.5
	return tmp

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -5.2e+35], N[Not[LessEqual[NaChar, 5.4e+58]], $MachinePrecision]], N[(NaChar / 2.0), $MachinePrecision], N[(NdChar * 0.5), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -5.20000000000000013e35 or 5.4000000000000002e58 < 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
   4. Add Preprocessing

   5. Taylor expanded in NdChar around 0 70.2%

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

   6. Taylor expanded in KbT around inf 28.7%

      \[\leadsto \frac{NaChar}{\color{blue}{2}} \]

   if -5.20000000000000013e35 < NaChar < 5.4000000000000002e58

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 32.6%

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

      1. distribute-lft-out 32.6%

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

   7. Simplified 32.6%

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

   8. Taylor expanded in NaChar around 0 29.1%

      \[\leadsto \color{blue}{0.5 \cdot NdChar} \]
   9. Step-by-step derivation

      1. *-commutative 29.1%

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

   10. Simplified 29.1%

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

4. Final simplification 28.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -5.2 \cdot 10^{+35} \lor \neg \left(NaChar \leq 5.4 \cdot 10^{+58}\right):\\ \;\;\;\;\frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 23: 27.6% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 31.5%

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

   1. distribute-lft-out 31.5%

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

7. Simplified 31.5%

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

8. Final simplification 31.5%

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

Alternative 24: 18.5% 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{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}} \]
4. Add Preprocessing

5. Taylor expanded in KbT around inf 31.5%

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

   1. distribute-lft-out 31.5%

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

7. Simplified 31.5%

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

8. Taylor expanded in NaChar around 0 19.1%

   \[\leadsto \color{blue}{0.5 \cdot NdChar} \]
9. Step-by-step derivation

   1. *-commutative 19.1%

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

10. Simplified 19.1%

    \[\leadsto \color{blue}{NdChar \cdot 0.5} \]
11. Add Preprocessing

Reproduce

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