Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 18.5s

Alternatives: 18

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \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 (+ 1.0 (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 / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp(((Vef + (Ev + (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(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp(((vef + (ev + (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(((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 / (1.0 + 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 / Float64(1.0 + 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

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp(((Vef + (Ev + (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[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $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. Add Preprocessing

Alternative 2: 42.6% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ \mathbf{if}\;mu \leq -8.5 \cdot 10^{+39}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq 4 \cdot 10^{-251}:\\ \;\;\;\;\frac{NdChar}{t\_0}\\ \mathbf{elif}\;mu \leq 5 \cdot 10^{-34}:\\ \;\;\;\;\frac{NaChar}{t\_0}\\ \mathbf{elif}\;mu \leq 3.4 \cdot 10^{+79}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{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 (+ 1.0 (exp (/ Vef KbT))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ mu (- KbT)))))))
   (if (<= mu -8.5e+39)
     t_1
     (if (<= mu 4e-251)
       (/ NdChar t_0)
       (if (<= mu 5e-34)
         (/ NaChar t_0)
         (if (<= mu 3.4e+79) (/ NdChar (+ 1.0 (exp (/ EDonor 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 = 1.0 + exp((Vef / KbT));
	double t_1 = NaChar / (1.0 + exp((mu / -KbT)));
	double tmp;
	if (mu <= -8.5e+39) {
		tmp = t_1;
	} else if (mu <= 4e-251) {
		tmp = NdChar / t_0;
	} else if (mu <= 5e-34) {
		tmp = NaChar / t_0;
	} else if (mu <= 3.4e+79) {
		tmp = NdChar / (1.0 + exp((EDonor / 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 = 1.0d0 + exp((vef / kbt))
    t_1 = nachar / (1.0d0 + exp((mu / -kbt)))
    if (mu <= (-8.5d+39)) then
        tmp = t_1
    else if (mu <= 4d-251) then
        tmp = ndchar / t_0
    else if (mu <= 5d-34) then
        tmp = nachar / t_0
    else if (mu <= 3.4d+79) then
        tmp = ndchar / (1.0d0 + exp((edonor / 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 = 1.0 + Math.exp((Vef / KbT));
	double t_1 = NaChar / (1.0 + Math.exp((mu / -KbT)));
	double tmp;
	if (mu <= -8.5e+39) {
		tmp = t_1;
	} else if (mu <= 4e-251) {
		tmp = NdChar / t_0;
	} else if (mu <= 5e-34) {
		tmp = NaChar / t_0;
	} else if (mu <= 3.4e+79) {
		tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	t_1 = NaChar / (1.0 + math.exp((mu / -KbT)))
	tmp = 0
	if mu <= -8.5e+39:
		tmp = t_1
	elif mu <= 4e-251:
		tmp = NdChar / t_0
	elif mu <= 5e-34:
		tmp = NaChar / t_0
	elif mu <= 3.4e+79:
		tmp = NdChar / (1.0 + math.exp((EDonor / KbT)))
	else:
		tmp = t_1
	return tmp

Julia

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

Derivation

1. Split input into 4 regimes

2. if mu < -8.49999999999999971e39 or 3.40000000000000032e79 < mu

   1. Initial program 100.0%

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

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

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

   6. Taylor expanded in mu around inf 56.8%

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

      1. associate-*r/ 56.8%

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

      2. neg-mul-1 56.8%

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

   8. Simplified 56.8%

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

   if -8.49999999999999971e39 < mu < 4.00000000000000006e-251

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 72.6%

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

   6. Taylor expanded in EDonor around 0 69.7%

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

   7. Taylor expanded in Vef around inf 57.2%

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

   if 4.00000000000000006e-251 < mu < 5.0000000000000003e-34

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 70.4%

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

   6. Taylor expanded in Vef around inf 56.4%

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

   if 5.0000000000000003e-34 < mu < 3.40000000000000032e79

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

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

   6. Taylor expanded in EDonor around inf 65.1%

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

4. Final simplification 57.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -8.5 \cdot 10^{+39}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ \mathbf{elif}\;mu \leq 4 \cdot 10^{-251}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 5 \cdot 10^{-34}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 3.4 \cdot 10^{+79}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{mu}{-KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 42.0% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ t_1 := 0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{if}\;KbT \leq -1.75 \cdot 10^{+117}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;KbT \leq -9 \cdot 10^{-197}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 1.32 \cdot 10^{-260}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.9 \cdot 10^{+162}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1 - -0.25 \cdot \left(Ec \cdot \frac{NdChar}{KbT}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
        (t_1 (* 0.5 (+ NdChar NaChar))))
   (if (<= KbT -1.75e+117)
     t_1
     (if (<= KbT -9e-197)
       t_0
       (if (<= KbT 1.32e-260)
         (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
         (if (<= KbT 2.9e+162)
           t_0
           (- t_1 (* -0.25 (* Ec (/ NdChar 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((EAccept / KbT)));
	double t_1 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -1.75e+117) {
		tmp = t_1;
	} else if (KbT <= -9e-197) {
		tmp = t_0;
	} else if (KbT <= 1.32e-260) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else if (KbT <= 2.9e+162) {
		tmp = t_0;
	} else {
		tmp = t_1 - (-0.25 * (Ec * (NdChar / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((eaccept / kbt)))
    t_1 = 0.5d0 * (ndchar + nachar)
    if (kbt <= (-1.75d+117)) then
        tmp = t_1
    else if (kbt <= (-9d-197)) then
        tmp = t_0
    else if (kbt <= 1.32d-260) then
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    else if (kbt <= 2.9d+162) then
        tmp = t_0
    else
        tmp = t_1 - ((-0.25d0) * (ec * (ndchar / 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((EAccept / KbT)));
	double t_1 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -1.75e+117) {
		tmp = t_1;
	} else if (KbT <= -9e-197) {
		tmp = t_0;
	} else if (KbT <= 1.32e-260) {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	} else if (KbT <= 2.9e+162) {
		tmp = t_0;
	} else {
		tmp = t_1 - (-0.25 * (Ec * (NdChar / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((EAccept / KbT)))
	t_1 = 0.5 * (NdChar + NaChar)
	tmp = 0
	if KbT <= -1.75e+117:
		tmp = t_1
	elif KbT <= -9e-197:
		tmp = t_0
	elif KbT <= 1.32e-260:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	elif KbT <= 2.9e+162:
		tmp = t_0
	else:
		tmp = t_1 - (-0.25 * (Ec * (NdChar / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))
	t_1 = Float64(0.5 * Float64(NdChar + NaChar))
	tmp = 0.0
	if (KbT <= -1.75e+117)
		tmp = t_1;
	elseif (KbT <= -9e-197)
		tmp = t_0;
	elseif (KbT <= 1.32e-260)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	elseif (KbT <= 2.9e+162)
		tmp = t_0;
	else
		tmp = Float64(t_1 - Float64(-0.25 * Float64(Ec * Float64(NdChar / 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((EAccept / KbT)));
	t_1 = 0.5 * (NdChar + NaChar);
	tmp = 0.0;
	if (KbT <= -1.75e+117)
		tmp = t_1;
	elseif (KbT <= -9e-197)
		tmp = t_0;
	elseif (KbT <= 1.32e-260)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	elseif (KbT <= 2.9e+162)
		tmp = t_0;
	else
		tmp = t_1 - (-0.25 * (Ec * (NdChar / 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[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.75e+117], t$95$1, If[LessEqual[KbT, -9e-197], t$95$0, If[LessEqual[KbT, 1.32e-260], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.9e+162], t$95$0, N[(t$95$1 - N[(-0.25 * N[(Ec * N[(NdChar / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -1.74999999999999991e117

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

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

      1. distribute-lft-out 64.7%

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

   7. Simplified 64.7%

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

   if -1.74999999999999991e117 < KbT < -9.0000000000000002e-197 or 1.31999999999999992e-260 < KbT < 2.90000000000000006e162

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

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

   6. Taylor expanded in EAccept around inf 32.1%

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

   if -9.0000000000000002e-197 < KbT < 1.31999999999999992e-260

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 73.7%

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

   6. Taylor expanded in Ev around inf 40.1%

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

   if 2.90000000000000006e162 < 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 32.6%

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

   7. Simplified 32.6%

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

   8. Taylor expanded in Ec around inf 61.1%

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

      1. associate-/l* 64.5%

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

   10. Simplified 64.5%

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

4. Final simplification 43.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.75 \cdot 10^{+117}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;KbT \leq -9 \cdot 10^{-197}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.32 \cdot 10^{-260}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.9 \cdot 10^{+162}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right) - -0.25 \cdot \left(Ec \cdot \frac{NdChar}{KbT}\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 67.7% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -1.25e+122) (not (<= NdChar 7.2e-168)))
   (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
   (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -1.25e+122) || !(NdChar <= 7.2e-168)) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -1.25e+122) || ~((NdChar <= 7.2e-168)))
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	else
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -1.24999999999999997e122 or 7.1999999999999998e-168 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

   if -1.24999999999999997e122 < NdChar < 7.1999999999999998e-168

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

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

4. Final simplification 75.0%

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

Alternative 5: 65.5% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -3.2e+121) (not (<= NdChar 1.4e-36)))
   (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))
   (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -3.2e+121) || !(NdChar <= 1.4e-36)) {
		tmp = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	} else {
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -3.2e+121) || ~((NdChar <= 1.4e-36)))
		tmp = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	else
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -3.1999999999999999e121 or 1.4000000000000001e-36 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

   6. Taylor expanded in EDonor around 0 69.8%

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

   if -3.1999999999999999e121 < NdChar < 1.4000000000000001e-36

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

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

4. Final simplification 72.4%

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

Alternative 6: 52.3% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= mu -1.85e+267) (not (<= mu 2.4e+142)))
   (/ NaChar (+ 1.0 (exp (/ mu (- KbT)))))
   (/ NdChar (+ 1.0 (exp (/ (- (+ 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 ((mu <= -1.85e+267) || !(mu <= 2.4e+142)) {
		tmp = NaChar / (1.0 + exp((mu / -KbT)));
	} else {
		tmp = NdChar / (1.0 + exp((((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 ((mu <= (-1.85d+267)) .or. (.not. (mu <= 2.4d+142))) then
        tmp = nachar / (1.0d0 + exp((mu / -kbt)))
    else
        tmp = ndchar / (1.0d0 + exp((((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 ((mu <= -1.85e+267) || !(mu <= 2.4e+142)) {
		tmp = NaChar / (1.0 + Math.exp((mu / -KbT)));
	} else {
		tmp = NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)));
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((mu <= -1.85e+267) || !(mu <= 2.4e+142))
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(mu / Float64(-KbT)))));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(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 ((mu <= -1.85e+267) || ~((mu <= 2.4e+142)))
		tmp = NaChar / (1.0 + exp((mu / -KbT)));
	else
		tmp = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if mu < -1.85e267 or 2.3999999999999999e142 < mu

   1. Initial program 100.0%

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

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

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

   6. Taylor expanded in mu around inf 74.4%

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

      1. associate-*r/ 74.4%

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

      2. neg-mul-1 74.4%

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

   8. Simplified 74.4%

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

   if -1.85e267 < mu < 2.3999999999999999e142

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

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

   6. Taylor expanded in EDonor around 0 60.4%

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

4. Final simplification 62.6%

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

Alternative 7: 45.9% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;NaChar \leq -115000000000 \lor \neg \left(NaChar \leq 7 \cdot 10^{-20}\right):\\ \;\;\;\;\frac{NaChar}{t\_0}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{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 (or (<= NaChar -115000000000.0) (not (<= NaChar 7e-20)))
     (/ NaChar t_0)
     (/ NdChar 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 ((NaChar <= -115000000000.0) || !(NaChar <= 7e-20)) {
		tmp = NaChar / t_0;
	} else {
		tmp = NdChar / 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 ((nachar <= (-115000000000.0d0)) .or. (.not. (nachar <= 7d-20))) then
        tmp = nachar / t_0
    else
        tmp = ndchar / 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 ((NaChar <= -115000000000.0) || !(NaChar <= 7e-20)) {
		tmp = NaChar / t_0;
	} else {
		tmp = NdChar / 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 (NaChar <= -115000000000.0) or not (NaChar <= 7e-20):
		tmp = NaChar / t_0
	else:
		tmp = NdChar / 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 ((NaChar <= -115000000000.0) || !(NaChar <= 7e-20))
		tmp = Float64(NaChar / t_0);
	else
		tmp = Float64(NdChar / 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 ((NaChar <= -115000000000.0) || ~((NaChar <= 7e-20)))
		tmp = NaChar / t_0;
	else
		tmp = NdChar / 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[Or[LessEqual[NaChar, -115000000000.0], N[Not[LessEqual[NaChar, 7e-20]], $MachinePrecision]], N[(NaChar / t$95$0), $MachinePrecision], N[(NdChar / t$95$0), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.15e11 or 7.00000000000000007e-20 < 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 71.7%

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

   6. Taylor expanded in Vef around inf 48.2%

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

   if -1.15e11 < NaChar < 7.00000000000000007e-20

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

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

   6. Taylor expanded in EDonor around 0 68.1%

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

   7. Taylor expanded in Vef around inf 54.8%

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

4. Final simplification 51.3%

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

Alternative 8: 44.3% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -5.2e+26) (not (<= Vef 2.45e+84)))
   (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
   (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -5.20000000000000004e26 or 2.45e84 < 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 71.6%

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

   6. Taylor expanded in Vef around inf 57.4%

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

   if -5.20000000000000004e26 < Vef < 2.45e84

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

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

   6. Taylor expanded in EDonor around inf 45.3%

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

4. Final simplification 50.6%

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

Alternative 9: 43.9% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{if}\;KbT \leq -8.2 \cdot 10^{+117}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 2.2 \cdot 10^{+186}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_0 - -0.25 \cdot \left(Ec \cdot \frac{NdChar}{KbT}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* 0.5 (+ NdChar NaChar))))
   (if (<= KbT -8.2e+117)
     t_0
     (if (<= KbT 2.2e+186)
       (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
       (- t_0 (* -0.25 (* Ec (/ NdChar 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 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -8.2e+117) {
		tmp = t_0;
	} else if (KbT <= 2.2e+186) {
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	} else {
		tmp = t_0 - (-0.25 * (Ec * (NdChar / 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 = 0.5d0 * (ndchar + nachar)
    if (kbt <= (-8.2d+117)) then
        tmp = t_0
    else if (kbt <= 2.2d+186) then
        tmp = nachar / (1.0d0 + exp((vef / kbt)))
    else
        tmp = t_0 - ((-0.25d0) * (ec * (ndchar / 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 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -8.2e+117) {
		tmp = t_0;
	} else if (KbT <= 2.2e+186) {
		tmp = NaChar / (1.0 + Math.exp((Vef / KbT)));
	} else {
		tmp = t_0 - (-0.25 * (Ec * (NdChar / KbT)));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -8.2e+117], t$95$0, If[LessEqual[KbT, 2.2e+186], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 - N[(-0.25 * N[(Ec * N[(NdChar / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -8.1999999999999999e117

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

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

      1. distribute-lft-out 66.1%

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

   7. Simplified 66.1%

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

   if -8.1999999999999999e117 < KbT < 2.1999999999999998e186

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

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

   6. Taylor expanded in Vef around inf 38.5%

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

   if 2.1999999999999998e186 < 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 35.7%

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

   7. Simplified 35.7%

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

   8. Taylor expanded in Ec around inf 63.5%

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

      1. associate-/l* 67.2%

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

   10. Simplified 67.2%

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

4. Final simplification 47.0%

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

Alternative 10: 42.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{if}\;KbT \leq -2.15 \cdot 10^{+117}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 4.8 \cdot 10^{+161}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_0 - -0.25 \cdot \left(Ec \cdot \frac{NdChar}{KbT}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* 0.5 (+ NdChar NaChar))))
   (if (<= KbT -2.15e+117)
     t_0
     (if (<= KbT 4.8e+161)
       (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
       (- t_0 (* -0.25 (* Ec (/ NdChar 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 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -2.15e+117) {
		tmp = t_0;
	} else if (KbT <= 4.8e+161) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else {
		tmp = t_0 - (-0.25 * (Ec * (NdChar / 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 = 0.5d0 * (ndchar + nachar)
    if (kbt <= (-2.15d+117)) then
        tmp = t_0
    else if (kbt <= 4.8d+161) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else
        tmp = t_0 - ((-0.25d0) * (ec * (ndchar / 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 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -2.15e+117) {
		tmp = t_0;
	} else if (KbT <= 4.8e+161) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else {
		tmp = t_0 - (-0.25 * (Ec * (NdChar / KbT)));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.15e+117], t$95$0, If[LessEqual[KbT, 4.8e+161], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 - N[(-0.25 * N[(Ec * N[(NdChar / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.14999999999999999e117

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

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

      1. distribute-lft-out 64.7%

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

   7. Simplified 64.7%

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

   if -2.14999999999999999e117 < KbT < 4.7999999999999998e161

   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 EAccept around inf 35.6%

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

   if 4.7999999999999998e161 < 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 32.6%

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

   7. Simplified 32.6%

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

   8. Taylor expanded in Ec around inf 61.1%

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

      1. associate-/l* 64.5%

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

   10. Simplified 64.5%

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

4. Final simplification 44.9%

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

Alternative 11: 33.5% accurate, 6.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{if}\;KbT \leq -2.8 \cdot 10^{+117}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq -6.5 \cdot 10^{-144}:\\ \;\;\;\;\frac{NaChar}{mu \cdot \left(\frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 7.4 \cdot 10^{-57}:\\ \;\;\;\;\frac{NaChar}{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* 0.5 (+ NdChar NaChar))))
   (if (<= KbT -2.8e+117)
     t_0
     (if (<= KbT -6.5e-144)
       (/
        NaChar
        (*
         mu
         (+
          (/ (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT)))) mu)
          (/ -1.0 KbT))))
       (if (<= KbT 7.4e-57)
         (/ NaChar (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))
         t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -2.8e+117) {
		tmp = t_0;
	} else if (KbT <= -6.5e-144) {
		tmp = NaChar / (mu * (((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) / mu) + (-1.0 / KbT)));
	} else if (KbT <= 7.4e-57) {
		tmp = NaChar / (((EAccept + (Vef + Ev)) - mu) / KbT);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = 0.5d0 * (ndchar + nachar)
    if (kbt <= (-2.8d+117)) then
        tmp = t_0
    else if (kbt <= (-6.5d-144)) then
        tmp = nachar / (mu * (((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) / mu) + ((-1.0d0) / kbt)))
    else if (kbt <= 7.4d-57) then
        tmp = nachar / (((eaccept + (vef + ev)) - mu) / kbt)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -2.8e+117) {
		tmp = t_0;
	} else if (KbT <= -6.5e-144) {
		tmp = NaChar / (mu * (((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) / mu) + (-1.0 / KbT)));
	} else if (KbT <= 7.4e-57) {
		tmp = NaChar / (((EAccept + (Vef + Ev)) - mu) / KbT);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 0.5 * (NdChar + NaChar)
	tmp = 0
	if KbT <= -2.8e+117:
		tmp = t_0
	elif KbT <= -6.5e-144:
		tmp = NaChar / (mu * (((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) / mu) + (-1.0 / KbT)))
	elif KbT <= 7.4e-57:
		tmp = NaChar / (((EAccept + (Vef + Ev)) - mu) / KbT)
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(0.5 * Float64(NdChar + NaChar))
	tmp = 0.0
	if (KbT <= -2.8e+117)
		tmp = t_0;
	elseif (KbT <= -6.5e-144)
		tmp = Float64(NaChar / Float64(mu * Float64(Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) / mu) + Float64(-1.0 / KbT))));
	elseif (KbT <= 7.4e-57)
		tmp = Float64(NaChar / Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 0.5 * (NdChar + NaChar);
	tmp = 0.0;
	if (KbT <= -2.8e+117)
		tmp = t_0;
	elseif (KbT <= -6.5e-144)
		tmp = NaChar / (mu * (((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) / mu) + (-1.0 / KbT)));
	elseif (KbT <= 7.4e-57)
		tmp = NaChar / (((EAccept + (Vef + Ev)) - mu) / KbT);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.8e+117], t$95$0, If[LessEqual[KbT, -6.5e-144], N[(NaChar / N[(mu * N[(N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision] + N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 7.4e-57], N[(NaChar / N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.79999999999999997e117 or 7.4e-57 < 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.9%

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

      1. distribute-lft-out 49.9%

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

   7. Simplified 49.9%

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

   if -2.79999999999999997e117 < KbT < -6.49999999999999968e-144

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

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

   6. Taylor expanded in KbT around inf 12.5%

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

   7. Taylor expanded in mu around -inf 23.3%

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

      1. mul-1-neg 23.3%

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

      2. distribute-rgt-neg-in 23.3%

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

      3. +-commutative 23.3%

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

      4. mul-1-neg 23.3%

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

      5. unsub-neg 23.3%

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

      6. +-commutative 23.3%

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

      7. +-commutative 23.3%

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

   9. Simplified 23.3%

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

   if -6.49999999999999968e-144 < KbT < 7.4e-57

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 73.8%

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

   6. Taylor expanded in KbT around inf 21.8%

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

   7. Taylor expanded in KbT around 0 32.7%

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

4. Final simplification 39.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2.8 \cdot 10^{+117}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;KbT \leq -6.5 \cdot 10^{-144}:\\ \;\;\;\;\frac{NaChar}{mu \cdot \left(\frac{2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)}{mu} + \frac{-1}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 7.4 \cdot 10^{-57}:\\ \;\;\;\;\frac{NaChar}{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 33.2% accurate, 10.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -7.2 \cdot 10^{-22} \lor \neg \left(KbT \leq 5.2 \cdot 10^{-55}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -7.2e-22) (not (<= KbT 5.2e-55)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -7.2e-22) || !(KbT <= 5.2e-55)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (((EAccept + (Vef + Ev)) - mu) / KbT);
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -7.2e-22) || !(KbT <= 5.2e-55)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar / (((EAccept + (Vef + Ev)) - mu) / KbT);
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -7.2e-22) || !(KbT <= 5.2e-55))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar / Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -7.2e-22) || ~((KbT <= 5.2e-55)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar / (((EAccept + (Vef + Ev)) - mu) / KbT);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -7.1999999999999996e-22 or 5.1999999999999998e-55 < 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 43.5%

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

      1. distribute-lft-out 43.5%

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

   7. Simplified 43.5%

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

   if -7.1999999999999996e-22 < KbT < 5.1999999999999998e-55

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 71.5%

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

   6. Taylor expanded in KbT around inf 18.6%

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

   7. Taylor expanded in KbT around 0 27.1%

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

4. Final simplification 36.8%

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

Alternative 13: 30.2% accurate, 11.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{if}\;KbT \leq -3.5 \cdot 10^{+25}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq -9 \cdot 10^{-293}:\\ \;\;\;\;\frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq 1.95 \cdot 10^{-57}:\\ \;\;\;\;\frac{NaChar}{\frac{EAccept}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* 0.5 (+ NdChar NaChar))))
   (if (<= KbT -3.5e+25)
     t_0
     (if (<= KbT -9e-293)
       (/ NdChar (+ (/ Vef KbT) 2.0))
       (if (<= KbT 1.95e-57) (/ NaChar (/ EAccept KbT)) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -3.5e+25) {
		tmp = t_0;
	} else if (KbT <= -9e-293) {
		tmp = NdChar / ((Vef / KbT) + 2.0);
	} else if (KbT <= 1.95e-57) {
		tmp = NaChar / (EAccept / KbT);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = 0.5d0 * (ndchar + nachar)
    if (kbt <= (-3.5d+25)) then
        tmp = t_0
    else if (kbt <= (-9d-293)) then
        tmp = ndchar / ((vef / kbt) + 2.0d0)
    else if (kbt <= 1.95d-57) then
        tmp = nachar / (eaccept / kbt)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -3.5e+25) {
		tmp = t_0;
	} else if (KbT <= -9e-293) {
		tmp = NdChar / ((Vef / KbT) + 2.0);
	} else if (KbT <= 1.95e-57) {
		tmp = NaChar / (EAccept / KbT);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 0.5 * (NdChar + NaChar)
	tmp = 0
	if KbT <= -3.5e+25:
		tmp = t_0
	elif KbT <= -9e-293:
		tmp = NdChar / ((Vef / KbT) + 2.0)
	elif KbT <= 1.95e-57:
		tmp = NaChar / (EAccept / KbT)
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(0.5 * Float64(NdChar + NaChar))
	tmp = 0.0
	if (KbT <= -3.5e+25)
		tmp = t_0;
	elseif (KbT <= -9e-293)
		tmp = Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0));
	elseif (KbT <= 1.95e-57)
		tmp = Float64(NaChar / Float64(EAccept / KbT));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 0.5 * (NdChar + NaChar);
	tmp = 0.0;
	if (KbT <= -3.5e+25)
		tmp = t_0;
	elseif (KbT <= -9e-293)
		tmp = NdChar / ((Vef / KbT) + 2.0);
	elseif (KbT <= 1.95e-57)
		tmp = NaChar / (EAccept / KbT);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -3.5e+25], t$95$0, If[LessEqual[KbT, -9e-293], N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.95e-57], N[(NaChar / N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -3.49999999999999999e25 or 1.95000000000000003e-57 < 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 45.2%

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

      1. distribute-lft-out 45.2%

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

   7. Simplified 45.2%

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

   if -3.49999999999999999e25 < KbT < -9.0000000000000005e-293

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

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

   6. Taylor expanded in EDonor around 0 55.5%

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

   7. Taylor expanded in Vef around inf 39.3%

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

   8. Taylor expanded in Vef around 0 26.2%

      \[\leadsto \frac{NdChar}{\color{blue}{2 + \frac{Vef}{KbT}}} \]

   if -9.0000000000000005e-293 < KbT < 1.95000000000000003e-57

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

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

   6. Taylor expanded in KbT around inf 17.6%

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

   7. Taylor expanded in EAccept around inf 24.0%

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

4. Final simplification 36.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.5 \cdot 10^{+25}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;KbT \leq -9 \cdot 10^{-293}:\\ \;\;\;\;\frac{NdChar}{\frac{Vef}{KbT} + 2}\\ \mathbf{elif}\;KbT \leq 1.95 \cdot 10^{-57}:\\ \;\;\;\;\frac{NaChar}{\frac{EAccept}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 29.6% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -5.2 \cdot 10^{-151} \lor \neg \left(KbT \leq 1.1 \cdot 10^{-54}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{EAccept}{KbT}}\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -5.2e-151], N[Not[LessEqual[KbT, 1.1e-54]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -5.2000000000000001e-151 or 1.1e-54 < 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 38.3%

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

      1. distribute-lft-out 38.3%

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

   7. Simplified 38.3%

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

   if -5.2000000000000001e-151 < KbT < 1.1e-54

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

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

   6. Taylor expanded in KbT around inf 22.1%

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

   7. Taylor expanded in EAccept around inf 24.8%

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

4. Final simplification 34.2%

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

Alternative 15: 28.9% accurate, 15.2× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -2.2e-16) (not (<= KbT 1.75e-57)))
   (* 0.5 (+ NdChar NaChar))
   (* KbT (/ NaChar Vef))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -2.2e-16 or 1.74999999999999996e-57 < 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 43.8%

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

      1. distribute-lft-out 43.8%

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

   7. Simplified 43.8%

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

   if -2.2e-16 < KbT < 1.74999999999999996e-57

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

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

   6. Taylor expanded in KbT around inf 18.5%

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

   7. Taylor expanded in Vef around inf 18.1%

      \[\leadsto \color{blue}{\frac{KbT \cdot NaChar}{Vef}} \]
   8. Step-by-step derivation

      1. associate-/l* 17.1%

         \[\leadsto \color{blue}{KbT \cdot \frac{NaChar}{Vef}} \]

   9. Simplified 17.1%

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

4. Final simplification 32.8%

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

Alternative 16: 23.0% accurate, 17.6× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -5.4e+121) (not (<= NdChar 3e-81)))
   (* NdChar 0.5)
   (/ NaChar 2.0)))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -5.4000000000000004e121 or 2.9999999999999999e-81 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

      1. distribute-lft-out 30.1%

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

   7. Simplified 30.1%

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

   8. Taylor expanded in NaChar around 0 28.2%

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

   if -5.4000000000000004e121 < NdChar < 2.9999999999999999e-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 NdChar around 0 73.7%

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

   6. Taylor expanded in KbT around inf 25.2%

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

4. Final simplification 26.6%

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

Alternative 17: 28.4% 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 29.5%

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

   1. distribute-lft-out 29.5%

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

7. Simplified 29.5%

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

8. Final simplification 29.5%

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

Alternative 18: 18.3% 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 29.5%

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

   1. distribute-lft-out 29.5%

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

7. Simplified 29.5%

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

8. Taylor expanded in NaChar around 0 18.7%

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

9. Final simplification 18.7%

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

Reproduce

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