Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 20.3s

Alternatives: 18

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = 4.243548018637986e+169
  2. Ec = 4.4874745186712095e-131
  3. Vef = -4.685439889743892e+235
  4. EDonor = 1.2030445401165449e-36
  5. mu = -1.5632344430259842e-205
  6. KbT = 3.8656449978044834e-145
  7. NaChar = -1.1713085929027608e+169
  8. Ev = 1.2513376172414729e+119
  9. EAccept = -3.334905707105043e+307

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, 0.5× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (exp (log1p (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)))))
  (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- 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 / exp(log1p(exp(((EDonor + (mu + (Vef - Ec))) / KbT))))) + (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))));
}

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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. Step-by-step derivation

   1. add-exp-log 100.0%

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

   2. log1p-define 100.0%

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

6. Applied egg-rr 100.0%

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

Alternative 2: 70.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;EDonor \leq -3.5 \cdot 10^{+24}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;EDonor \leq -1.08 \cdot 10^{-164}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;EDonor \leq 1.25 \cdot 10^{-296}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 6.8 \cdot 10^{-230}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;EDonor \leq 4.2 \cdot 10^{+62}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= EDonor -3.5e+24)
     t_1
     (if (<= EDonor -1.08e-164)
       t_0
       (if (<= EDonor 1.25e-296)
         (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
         (if (<= EDonor 6.8e-230)
           t_0
           (if (<= EDonor 4.2e+62)
             (+
              (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
              (/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))
             t_1)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -3.5e+24) {
		tmp = t_1;
	} else if (EDonor <= -1.08e-164) {
		tmp = t_0;
	} else if (EDonor <= 1.25e-296) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (EDonor <= 6.8e-230) {
		tmp = t_0;
	} else if (EDonor <= 4.2e+62) {
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    if (edonor <= (-3.5d+24)) then
        tmp = t_1
    else if (edonor <= (-1.08d-164)) then
        tmp = t_0
    else if (edonor <= 1.25d-296) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else if (edonor <= 6.8d-230) then
        tmp = t_0
    else if (edonor <= 4.2d+62) then
        tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -3.5e+24) {
		tmp = t_1;
	} else if (EDonor <= -1.08e-164) {
		tmp = t_0;
	} else if (EDonor <= 1.25e-296) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (EDonor <= 6.8e-230) {
		tmp = t_0;
	} else if (EDonor <= 4.2e+62) {
		tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if EDonor <= -3.5e+24:
		tmp = t_1
	elif EDonor <= -1.08e-164:
		tmp = t_0
	elif EDonor <= 1.25e-296:
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	elif EDonor <= 6.8e-230:
		tmp = t_0
	elif EDonor <= 4.2e+62:
		tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (EDonor <= -3.5e+24)
		tmp = t_1;
	elseif (EDonor <= -1.08e-164)
		tmp = t_0;
	elseif (EDonor <= 1.25e-296)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	elseif (EDonor <= 6.8e-230)
		tmp = t_0;
	elseif (EDonor <= 4.2e+62)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (EDonor <= -3.5e+24)
		tmp = t_1;
	elseif (EDonor <= -1.08e-164)
		tmp = t_0;
	elseif (EDonor <= 1.25e-296)
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	elseif (EDonor <= 6.8e-230)
		tmp = t_0;
	elseif (EDonor <= 4.2e+62)
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -3.5e+24], t$95$1, If[LessEqual[EDonor, -1.08e-164], t$95$0, If[LessEqual[EDonor, 1.25e-296], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 6.8e-230], t$95$0, If[LessEqual[EDonor, 4.2e+62], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]

Derivation

1. Split input into 4 regimes

2. if EDonor < -3.5000000000000002e24 or 4.2e62 < EDonor

   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 EDonor around inf 88.8%

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

   if -3.5000000000000002e24 < EDonor < -1.0799999999999999e-164 or 1.25000000000000008e-296 < EDonor < 6.8e-230

   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 82.4%

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

   if -1.0799999999999999e-164 < EDonor < 1.25000000000000008e-296

   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 74.1%

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

   if 6.8e-230 < EDonor < 4.2e62

   1. Initial program 99.9%

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

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 83.9%

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

      \[\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.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EDonor \leq -3.5 \cdot 10^{+24}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;EDonor \leq -1.08 \cdot 10^{-164}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 1.25 \cdot 10^{-296}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 6.8 \cdot 10^{-230}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 4.2 \cdot 10^{+62}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 67.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + t\_1\\ \mathbf{if}\;EDonor \leq -3.5 \cdot 10^{+23}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;EDonor \leq -5.8 \cdot 10^{-165}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;EDonor \leq 1.02 \cdot 10^{-296}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 1.55 \cdot 10^{-231}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;EDonor \leq 1.45 \cdot 10^{+63}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))
        (t_2 (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) t_1)))
   (if (<= EDonor -3.5e+23)
     t_2
     (if (<= EDonor -5.8e-165)
       t_0
       (if (<= EDonor 1.02e-296)
         (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
         (if (<= EDonor 1.55e-231)
           t_0
           (if (<= EDonor 1.45e+63)
             (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) t_1)
             t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT)));
	double t_2 = (NdChar / (1.0 + exp((EDonor / KbT)))) + t_1;
	double tmp;
	if (EDonor <= -3.5e+23) {
		tmp = t_2;
	} else if (EDonor <= -5.8e-165) {
		tmp = t_0;
	} else if (EDonor <= 1.02e-296) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (EDonor <= 1.55e-231) {
		tmp = t_0;
	} else if (EDonor <= 1.45e+63) {
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    t_1 = nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt)))
    t_2 = (ndchar / (1.0d0 + exp((edonor / kbt)))) + t_1
    if (edonor <= (-3.5d+23)) then
        tmp = t_2
    else if (edonor <= (-5.8d-165)) then
        tmp = t_0
    else if (edonor <= 1.02d-296) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else if (edonor <= 1.55d-231) then
        tmp = t_0
    else if (edonor <= 1.45d+63) then
        tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT)));
	double t_2 = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + t_1;
	double tmp;
	if (EDonor <= -3.5e+23) {
		tmp = t_2;
	} else if (EDonor <= -5.8e-165) {
		tmp = t_0;
	} else if (EDonor <= 1.02e-296) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (EDonor <= 1.55e-231) {
		tmp = t_0;
	} else if (EDonor <= 1.45e+63) {
		tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)))
	t_1 = NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT)))
	t_2 = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + t_1
	tmp = 0
	if EDonor <= -3.5e+23:
		tmp = t_2
	elif EDonor <= -5.8e-165:
		tmp = t_0
	elif EDonor <= 1.02e-296:
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	elif EDonor <= 1.55e-231:
		tmp = t_0
	elif EDonor <= 1.45e+63:
		tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT))))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + t_1)
	tmp = 0.0
	if (EDonor <= -3.5e+23)
		tmp = t_2;
	elseif (EDonor <= -5.8e-165)
		tmp = t_0;
	elseif (EDonor <= 1.02e-296)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	elseif (EDonor <= 1.55e-231)
		tmp = t_0;
	elseif (EDonor <= 1.45e+63)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_1);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	t_1 = NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT)));
	t_2 = (NdChar / (1.0 + exp((EDonor / KbT)))) + t_1;
	tmp = 0.0;
	if (EDonor <= -3.5e+23)
		tmp = t_2;
	elseif (EDonor <= -5.8e-165)
		tmp = t_0;
	elseif (EDonor <= 1.02e-296)
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	elseif (EDonor <= 1.55e-231)
		tmp = t_0;
	elseif (EDonor <= 1.45e+63)
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[LessEqual[EDonor, -3.5e+23], t$95$2, If[LessEqual[EDonor, -5.8e-165], t$95$0, If[LessEqual[EDonor, 1.02e-296], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 1.55e-231], t$95$0, If[LessEqual[EDonor, 1.45e+63], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], t$95$2]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if EDonor < -3.5000000000000002e23 or 1.45e63 < EDonor

   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 EDonor around inf 88.8%

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

   6. Taylor expanded in EAccept around 0 78.3%

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

   if -3.5000000000000002e23 < EDonor < -5.8e-165 or 1.02000000000000002e-296 < EDonor < 1.54999999999999994e-231

   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 82.4%

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

   if -5.8e-165 < EDonor < 1.02000000000000002e-296

   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 74.1%

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

   if 1.54999999999999994e-231 < EDonor < 1.45e63

   1. Initial program 99.9%

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

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 83.9%

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

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

   \[\leadsto \begin{array}{l} \mathbf{if}\;EDonor \leq -3.5 \cdot 10^{+23}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq -5.8 \cdot 10^{-165}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 1.02 \cdot 10^{-296}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 1.55 \cdot 10^{-231}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 1.45 \cdot 10^{+63}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 65.3% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{if}\;EDonor \leq -7.2 \cdot 10^{+23}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;EDonor \leq -6 \cdot 10^{-165}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;EDonor \leq 1.65 \cdot 10^{-296}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;EDonor \leq 1.1 \cdot 10^{-137}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;EDonor \leq 8 \cdot 10^{+84}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))))
   (if (<= EDonor -7.2e+23)
     t_2
     (if (<= EDonor -6e-165)
       t_0
       (if (<= EDonor 1.65e-296)
         t_1
         (if (<= EDonor 1.1e-137) t_0 (if (<= EDonor 8e+84) t_1 t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_2 = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	double tmp;
	if (EDonor <= -7.2e+23) {
		tmp = t_2;
	} else if (EDonor <= -6e-165) {
		tmp = t_0;
	} else if (EDonor <= 1.65e-296) {
		tmp = t_1;
	} else if (EDonor <= 1.1e-137) {
		tmp = t_0;
	} else if (EDonor <= 8e+84) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    t_1 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    t_2 = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
    if (edonor <= (-7.2d+23)) then
        tmp = t_2
    else if (edonor <= (-6d-165)) then
        tmp = t_0
    else if (edonor <= 1.65d-296) then
        tmp = t_1
    else if (edonor <= 1.1d-137) then
        tmp = t_0
    else if (edonor <= 8d+84) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_2 = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
	double tmp;
	if (EDonor <= -7.2e+23) {
		tmp = t_2;
	} else if (EDonor <= -6e-165) {
		tmp = t_0;
	} else if (EDonor <= 1.65e-296) {
		tmp = t_1;
	} else if (EDonor <= 1.1e-137) {
		tmp = t_0;
	} else if (EDonor <= 8e+84) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)))
	t_1 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	t_2 = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT))))
	tmp = 0
	if EDonor <= -7.2e+23:
		tmp = t_2
	elif EDonor <= -6e-165:
		tmp = t_0
	elif EDonor <= 1.65e-296:
		tmp = t_1
	elif EDonor <= 1.1e-137:
		tmp = t_0
	elif EDonor <= 8e+84:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT)))))
	tmp = 0.0
	if (EDonor <= -7.2e+23)
		tmp = t_2;
	elseif (EDonor <= -6e-165)
		tmp = t_0;
	elseif (EDonor <= 1.65e-296)
		tmp = t_1;
	elseif (EDonor <= 1.1e-137)
		tmp = t_0;
	elseif (EDonor <= 8e+84)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	t_1 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	t_2 = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
	tmp = 0.0;
	if (EDonor <= -7.2e+23)
		tmp = t_2;
	elseif (EDonor <= -6e-165)
		tmp = t_0;
	elseif (EDonor <= 1.65e-296)
		tmp = t_1;
	elseif (EDonor <= 1.1e-137)
		tmp = t_0;
	elseif (EDonor <= 8e+84)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $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[EDonor, -7.2e+23], t$95$2, If[LessEqual[EDonor, -6e-165], t$95$0, If[LessEqual[EDonor, 1.65e-296], t$95$1, If[LessEqual[EDonor, 1.1e-137], t$95$0, If[LessEqual[EDonor, 8e+84], t$95$1, t$95$2]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if EDonor < -7.1999999999999997e23 or 8.00000000000000046e84 < EDonor

   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 EDonor around inf 88.6%

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

   6. Taylor expanded in EAccept around 0 78.8%

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

   if -7.1999999999999997e23 < EDonor < -5.99999999999999958e-165 or 1.65e-296 < EDonor < 1.1000000000000001e-137

   1. Initial program 99.9%

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

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 78.5%

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

   if -5.99999999999999958e-165 < EDonor < 1.65e-296 or 1.1000000000000001e-137 < EDonor < 8.00000000000000046e84

   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 73.1%

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

4. Final simplification 76.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EDonor \leq -7.2 \cdot 10^{+23}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq -6 \cdot 10^{-165}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 1.65 \cdot 10^{-296}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 1.1 \cdot 10^{-137}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 8 \cdot 10^{+84}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 76.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ \mathbf{if}\;EDonor \leq -1 \cdot 10^{+26} \lor \neg \left(EDonor \leq 1.55 \cdot 10^{+63}\right):\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))))
   (if (or (<= EDonor -1e+26) (not (<= EDonor 1.55e+63)))
     (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
     (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double tmp;
	if ((EDonor <= -1e+26) || !(EDonor <= 1.55e+63)) {
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	tmp = 0
	if (EDonor <= -1e+26) or not (EDonor <= 1.55e+63):
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	tmp = 0.0
	if ((EDonor <= -1e+26) || !(EDonor <= 1.55e+63))
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	tmp = 0.0;
	if ((EDonor <= -1e+26) || ~((EDonor <= 1.55e+63)))
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EDonor < -1.00000000000000005e26 or 1.55e63 < EDonor

   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 EDonor around inf 88.7%

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

   if -1.00000000000000005e26 < EDonor < 1.55e63

   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 77.1%

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

4. Final simplification 81.8%

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

Alternative 6: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

Alternative 7: 43.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;Vef \leq -8 \cdot 10^{+144}:\\ \;\;\;\;\frac{NdChar}{t\_0}\\ \mathbf{elif}\;Vef \leq -1.02 \cdot 10^{-203}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.25 \cdot 10^{-81}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{t\_0}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 1.0 (exp (/ Vef KbT)))))
   (if (<= Vef -8e+144)
     (/ NdChar t_0)
     (if (<= Vef -1.02e-203)
       (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
       (if (<= Vef 1.25e-81)
         (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
         (/ NaChar t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + exp((Vef / KbT));
	double tmp;
	if (Vef <= -8e+144) {
		tmp = NdChar / t_0;
	} else if (Vef <= -1.02e-203) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else if (Vef <= 1.25e-81) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else {
		tmp = NaChar / 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 = 1.0d0 + exp((vef / kbt))
    if (vef <= (-8d+144)) then
        tmp = ndchar / t_0
    else if (vef <= (-1.02d-203)) then
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    else if (vef <= 1.25d-81) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else
        tmp = nachar / 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 = 1.0 + Math.exp((Vef / KbT));
	double tmp;
	if (Vef <= -8e+144) {
		tmp = NdChar / t_0;
	} else if (Vef <= -1.02e-203) {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	} else if (Vef <= 1.25e-81) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else {
		tmp = NaChar / t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	tmp = 0
	if Vef <= -8e+144:
		tmp = NdChar / t_0
	elif Vef <= -1.02e-203:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	elif Vef <= 1.25e-81:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	else:
		tmp = NaChar / t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + exp(Float64(Vef / KbT)))
	tmp = 0.0
	if (Vef <= -8e+144)
		tmp = Float64(NdChar / t_0);
	elseif (Vef <= -1.02e-203)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	elseif (Vef <= 1.25e-81)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	else
		tmp = Float64(NaChar / t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	tmp = 0.0;
	if (Vef <= -8e+144)
		tmp = NdChar / t_0;
	elseif (Vef <= -1.02e-203)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	elseif (Vef <= 1.25e-81)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	else
		tmp = NaChar / t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -8e+144], N[(NdChar / t$95$0), $MachinePrecision], If[LessEqual[Vef, -1.02e-203], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.25e-81], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / t$95$0), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -8.00000000000000019e144

   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 92.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 NdChar around inf 68.1%

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

   if -8.00000000000000019e144 < Vef < -1.02000000000000005e-203

   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 67.2%

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

   6. Taylor expanded in Ev around inf 43.8%

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

   if -1.02000000000000005e-203 < Vef < 1.24999999999999995e-81

   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 60.5%

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

   6. Taylor expanded in Ev around 0 54.6%

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

   7. Taylor expanded in EAccept around inf 48.4%

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

   if 1.24999999999999995e-81 < 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 63.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 49.0%

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

Alternative 8: 69.8% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -8.6e-25) (not (<= NaChar 1.22e+87)))
   (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
   (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -8.6e-25) || !(NaChar <= 1.22e+87)) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	} else {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -8.6e-25) || ~((NaChar <= 1.22e+87)))
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	else
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -8.59999999999999953e-25 or 1.2200000000000001e87 < 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 77.9%

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

   if -8.59999999999999953e-25 < NaChar < 1.2200000000000001e87

   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 67.2%

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

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

Alternative 9: 37.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -7.8 \cdot 10^{+206}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -2 \cdot 10^{-167}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Ev \leq 1.5 \cdot 10^{-285}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -7.8e+206)
   (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
   (if (<= Ev -2e-167)
     (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
     (if (<= Ev 1.5e-285)
       (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
       (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Ev <= -7.8e+206) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else if (Ev <= -2e-167) {
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	} else if (Ev <= 1.5e-285) {
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	} else {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (Ev <= -7.8e+206)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	elseif (Ev <= -2e-167)
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	elseif (Ev <= 1.5e-285)
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	else
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -7.8e+206], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -2e-167], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 1.5e-285], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if Ev < -7.8e206

   1. Initial program 99.9%

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

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 60.6%

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

   6. Taylor expanded in Ev around inf 60.6%

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

   if -7.8e206 < Ev < -2e-167

   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 68.8%

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

   6. Taylor expanded in Vef around inf 51.3%

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

   if -2e-167 < Ev < 1.50000000000000002e-285

   1. Initial program 99.9%

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

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 EDonor around inf 80.6%

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

   6. Taylor expanded in NdChar around inf 34.1%

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

   if 1.50000000000000002e-285 < 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 NdChar around 0 60.3%

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

   6. Taylor expanded in EAccept around inf 37.1%

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

Alternative 10: 62.5% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < 4.5000000000000002e173

   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.0%

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

   if 4.5000000000000002e173 < 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 87.8%

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

   6. Taylor expanded in Ev around 0 87.3%

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

   7. Taylor expanded in EAccept around inf 83.3%

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

4. Final simplification 64.6%

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

Alternative 11: 42.6% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;Vef \leq -2.5 \cdot 10^{+138}:\\ \;\;\;\;\frac{NdChar}{t\_0}\\ \mathbf{elif}\;Vef \leq 4.2 \cdot 10^{-147}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{t\_0}\\ \end{array} \end{array} \]

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + exp((Vef / KbT));
	double tmp;
	if (Vef <= -2.5e+138) {
		tmp = NdChar / t_0;
	} else if (Vef <= 4.2e-147) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else {
		tmp = NaChar / 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 = 1.0d0 + exp((vef / kbt))
    if (vef <= (-2.5d+138)) then
        tmp = ndchar / t_0
    else if (vef <= 4.2d-147) then
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    else
        tmp = nachar / 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 = 1.0 + Math.exp((Vef / KbT));
	double tmp;
	if (Vef <= -2.5e+138) {
		tmp = NdChar / t_0;
	} else if (Vef <= 4.2e-147) {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	} else {
		tmp = NaChar / t_0;
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Vef < -2.50000000000000008e138

   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 92.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 NdChar around inf 68.1%

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

   if -2.50000000000000008e138 < Vef < 4.2e-147

   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 65.8%

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

   6. Taylor expanded in Ev around inf 41.9%

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

   if 4.2e-147 < 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 61.2%

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

   6. Taylor expanded in Vef around inf 47.2%

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

Alternative 12: 38.6% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -1.62 \cdot 10^{+208}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -4.8 \cdot 10^{-192}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -1.62e+208)
   (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
   (if (<= Ev -4.8e-192)
     (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
     (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -1.62e208

   1. Initial program 99.9%

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

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 60.6%

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

   6. Taylor expanded in Ev around inf 60.6%

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

   if -1.62e208 < Ev < -4.7999999999999998e-192

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

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

   6. Taylor expanded in Vef around inf 50.2%

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

   if -4.7999999999999998e-192 < 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 NdChar around 0 60.4%

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

   6. Taylor expanded in EAccept around inf 37.4%

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

Alternative 13: 38.2% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 3.0000000000000001e155

   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 62.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 37.4%

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

   if 3.0000000000000001e155 < 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 NdChar around 0 62.5%

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

   6. Taylor expanded in EAccept around inf 55.6%

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

Alternative 14: 36.6% accurate, 2.0× speedup

Math

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

FPCore

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < 1.14999999999999992e-30

   1. Initial program 100.0%

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

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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.3%

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

   6. Taylor expanded in EAccept around inf 33.8%

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

   if 1.14999999999999992e-30 < 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 49.7%

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

      1. distribute-lft-out 49.7%

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

   7. Simplified 49.7%

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

4. Final simplification 37.1%

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

Alternative 15: 27.6% accurate, 14.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -7.5 \cdot 10^{+186}:\\ \;\;\;\;Vef \cdot \left(0.25 \cdot \left(NaChar \cdot \frac{mu}{Vef \cdot KbT}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Vef -7.5e+186)
   (* Vef (* 0.25 (* NaChar (/ mu (* Vef KbT)))))
   (* 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) {
	double tmp;
	if (Vef <= -7.5e+186) {
		tmp = Vef * (0.25 * (NaChar * (mu / (Vef * KbT))));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (Vef <= -7.5e+186) {
		tmp = Vef * (0.25 * (NaChar * (mu / (Vef * KbT))));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -7.4999999999999998e186

   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 67.9%

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

   6. Taylor expanded in KbT around inf 3.7%

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

   7. Taylor expanded in Vef around inf 9.1%

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

   8. Taylor expanded in mu around inf 26.1%

      \[\leadsto Vef \cdot \color{blue}{\left(0.25 \cdot \frac{NaChar \cdot mu}{KbT \cdot Vef}\right)} \]
   9. Step-by-step derivation

      1. associate-/l* 29.7%

         \[\leadsto Vef \cdot \left(0.25 \cdot \color{blue}{\left(NaChar \cdot \frac{mu}{KbT \cdot Vef}\right)}\right) \]

      2. *-commutative 29.7%

         \[\leadsto Vef \cdot \left(0.25 \cdot \left(NaChar \cdot \frac{mu}{\color{blue}{Vef \cdot KbT}}\right)\right) \]

   10. Simplified 29.7%

       \[\leadsto Vef \cdot \color{blue}{\left(0.25 \cdot \left(NaChar \cdot \frac{mu}{Vef \cdot KbT}\right)\right)} \]

   if -7.4999999999999998e186 < 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 KbT around inf 29.9%

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

      1. distribute-lft-out 29.9%

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

   7. Simplified 29.9%

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

4. Final simplification 29.8%

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

Alternative 16: 19.0% accurate, 28.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -2.2 \cdot 10^{+170}:\\ \;\;\;\;NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -2.19999999999999989e170

   1. Initial program 99.9%

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

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{NdChar}{1 + e^{\frac{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 11.9%

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

      1. distribute-lft-out 11.9%

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

   7. Simplified 11.9%

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

   8. Taylor expanded in NaChar around 0 12.4%

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

   if -2.19999999999999989e170 < 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 KbT around inf 29.9%

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

      1. distribute-lft-out 29.9%

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

   7. Simplified 29.9%

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

   8. Taylor expanded in NaChar around inf 23.9%

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

      1. *-commutative 23.9%

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

   10. Simplified 23.9%

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

4. Final simplification 22.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -2.2 \cdot 10^{+170}:\\ \;\;\;\;NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NaChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 27.0% 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 27.8%

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

   1. distribute-lft-out 27.8%

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

7. Simplified 27.8%

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

8. Final simplification 27.8%

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

Alternative 18: 18.0% 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 27.8%

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

   1. distribute-lft-out 27.8%

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

7. Simplified 27.8%

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

8. Taylor expanded in NaChar around 0 14.7%

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

9. Final simplification 14.7%

   \[\leadsto NdChar \cdot 0.5 \]
10. Add Preprocessing

Reproduce

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