Bulmash initializePoisson

Percentage Accurate: 100.0% → 99.9%

Time: 19.7s

Alternatives: 23

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -5.1661734175323405e+36
  2. Ec = 3748202022328.3833
  3. Vef = 5.205679184401494e+259
  4. EDonor = -1.5369202960209733e-12
  5. mu = -1.3249769611642364e-70
  6. KbT = -6.528382443293314e-34
  7. NaChar = 1.0885314300652928e+36
  8. Ev = 3.968904376199867e-175
  9. EAccept = -1.6365719843391709e-122

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: 99.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\sqrt[3]{{\left(1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}\right)}^{3}}} \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
   (cbrt (pow (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))) 3.0)))))

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 / cbrt(pow((1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT))), 3.0)));
}

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 / Math.cbrt(Math.pow((1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT))), 3.0)));
}

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 / cbrt((Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))) ^ 3.0))))
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[Power[N[Power[N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.9%

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

3. Simplified 99.9%

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

   1. add-cbrt-cube 100.0%

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

   2. pow3 100.0%

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

6. Applied egg-rr 100.0%

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

Alternative 2: 69.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -8000000000 \lor \neg \left(Vef \leq 9.8 \cdot 10^{-70}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{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 (<= Vef -8000000000.0) (not (<= Vef 9.8e-70)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
    (/ NaChar (+ 1.0 (exp (/ Vef 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 ((Vef <= -8000000000.0) || !(Vef <= 9.8e-70)) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((Vef / 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 ((vef <= (-8000000000.0d0)) .or. (.not. (vef <= 9.8d-70))) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp((vef / 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 ((Vef <= -8000000000.0) || !(Vef <= 9.8e-70)) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp((Vef / 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 (Vef <= -8000000000.0) or not (Vef <= 9.8e-70):
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + math.exp((Vef / 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 ((Vef <= -8000000000.0) || !(Vef <= 9.8e-70))
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / 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 ((Vef <= -8000000000.0) || ~((Vef <= 9.8e-70)))
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((Vef / 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[Vef, -8000000000.0], N[Not[LessEqual[Vef, 9.8e-70]], $MachinePrecision]], 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[(Vef / KbT), $MachinePrecision]], $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 Vef < -8e9 or 9.8000000000000001e-70 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in Vef around inf 82.3%

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

   if -8e9 < Vef < 9.8000000000000001e-70

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 75.6%

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

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

Alternative 3: 66.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -5.1 \cdot 10^{+26} \lor \neg \left(Vef \leq 3.9 \cdot 10^{-47}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \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 (<= Vef -5.1e+26) (not (<= Vef 3.9e-47)))
   (+
    (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
    (/ 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 ((Vef <= -5.1e+26) || !(Vef <= 3.9e-47)) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (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 ((vef <= (-5.1d+26)) .or. (.not. (vef <= 3.9d-47))) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (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 ((Vef <= -5.1e+26) || !(Vef <= 3.9e-47)) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (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 (Vef <= -5.1e+26) or not (Vef <= 3.9e-47):
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (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 ((Vef <= -5.1e+26) || !(Vef <= 3.9e-47))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + 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 ((Vef <= -5.1e+26) || ~((Vef <= 3.9e-47)))
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (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[Vef, -5.1e+26], N[Not[LessEqual[Vef, 3.9e-47]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $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 Vef < -5.0999999999999997e26 or 3.89999999999999978e-47 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in Vef around inf 84.2%

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

   6. Taylor expanded in EDonor around 0 79.6%

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

   if -5.0999999999999997e26 < Vef < 3.89999999999999978e-47

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 73.1%

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

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -5.1 \cdot 10^{+26} \lor \neg \left(Vef \leq 3.9 \cdot 10^{-47}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \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 4: 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 99.9%

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

3. Simplified 99.9%

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

Alternative 5: 43.0% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -5.6 \cdot 10^{+183}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -1000000000000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 5.4 \cdot 10^{+48}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;Vef \leq 4 \cdot 10^{+147}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -5.6e+183)
     t_1
     (if (<= Vef -1000000000000.0)
       t_0
       (if (<= Vef 5.4e+48)
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
         (if (<= Vef 4e+147) t_0 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((EDonor / KbT)));
	double t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -5.6e+183) {
		tmp = t_1;
	} else if (Vef <= -1000000000000.0) {
		tmp = t_0;
	} else if (Vef <= 5.4e+48) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (Vef <= 4e+147) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((edonor / kbt)))
    t_1 = nachar / (1.0d0 + exp((vef / kbt)))
    if (vef <= (-5.6d+183)) then
        tmp = t_1
    else if (vef <= (-1000000000000.0d0)) then
        tmp = t_0
    else if (vef <= 5.4d+48) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if (vef <= 4d+147) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (Vef <= -5.6e+183) {
		tmp = t_1;
	} else if (Vef <= -1000000000000.0) {
		tmp = t_0;
	} else if (Vef <= 5.4e+48) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if (Vef <= 4e+147) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((EDonor / KbT)))
	t_1 = NaChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if Vef <= -5.6e+183:
		tmp = t_1
	elif Vef <= -1000000000000.0:
		tmp = t_0
	elif Vef <= 5.4e+48:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif Vef <= 4e+147:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -5.6e+183)
		tmp = t_1;
	elseif (Vef <= -1000000000000.0)
		tmp = t_0;
	elseif (Vef <= 5.4e+48)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (Vef <= 4e+147)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((EDonor / KbT)));
	t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -5.6e+183)
		tmp = t_1;
	elseif (Vef <= -1000000000000.0)
		tmp = t_0;
	elseif (Vef <= 5.4e+48)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (Vef <= 4e+147)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -5.6e+183], t$95$1, If[LessEqual[Vef, -1000000000000.0], t$95$0, If[LessEqual[Vef, 5.4e+48], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 4e+147], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -5.60000000000000036e183 or 3.9999999999999999e147 < Vef

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 67.9%

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

   6. Taylor expanded in Vef around inf 66.2%

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

   if -5.60000000000000036e183 < Vef < -1e12 or 5.40000000000000007e48 < Vef < 3.9999999999999999e147

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around inf 68.6%

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

   6. Taylor expanded in EDonor around inf 49.6%

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

   if -1e12 < Vef < 5.40000000000000007e48

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 71.3%

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

   6. Taylor expanded in EAccept around inf 50.2%

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

Alternative 6: 69.4% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -0.0012) (not (<= NdChar 4.9e+95)))
   (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
   (/ NaChar (+ 1.0 (pow E (/ (+ EAccept (+ Ev (- Vef mu))) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -0.0012) || !(NdChar <= 4.9e+95)) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = NaChar / (1.0 + pow(((double) M_E), ((EAccept + (Ev + (Vef - mu))) / KbT)));
	}
	return tmp;
}

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 <= -0.0012) || !(NdChar <= 4.9e+95)) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = NaChar / (1.0 + Math.pow(Math.E, ((EAccept + (Ev + (Vef - mu))) / KbT)));
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -0.0012) || !(NdChar <= 4.9e+95))
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	else
		tmp = Float64(NaChar / Float64(1.0 + (exp(1) ^ Float64(Float64(EAccept + Float64(Ev + Float64(Vef - 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 <= -0.0012) || ~((NdChar <= 4.9e+95)))
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	else
		tmp = NaChar / (1.0 + (2.71828182845904523536 ^ ((EAccept + (Ev + (Vef - mu))) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -0.0012], N[Not[LessEqual[NdChar, 4.9e+95]], $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[Power[E, N[(N[(EAccept + N[(Ev + N[(Vef - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -0.00119999999999999989 or 4.8999999999999999e95 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around inf 73.3%

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

   if -0.00119999999999999989 < NdChar < 4.8999999999999999e95

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 72.6%

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

      1. *-un-lft-identity 72.6%

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

      2. exp-prod 72.6%

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

      3. +-commutative 72.6%

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

   7. Applied egg-rr 72.6%

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

      1. exp-1-e 72.6%

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

      2. associate--l+ 72.6%

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

      3. +-commutative 72.6%

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

      4. sub-neg 72.6%

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

      5. associate-+r+ 72.6%

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

      6. mul-1-neg 72.6%

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

      7. mul-1-neg 72.6%

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

      8. associate-+r+ 72.6%

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

      9. sub-neg 72.6%

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

      10. associate--l+ 72.6%

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

   9. Simplified 72.6%

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

4. Final simplification 72.9%

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

Alternative 7: 69.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -0.001 \lor \neg \left(NdChar \leq 4.5 \cdot 10^{+92}\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 -0.001) (not (<= NdChar 4.5e+92)))
   (/ 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 <= -0.001) || !(NdChar <= 4.5e+92)) {
		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 <= (-0.001d0)) .or. (.not. (ndchar <= 4.5d+92))) 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 <= -0.001) || !(NdChar <= 4.5e+92)) {
		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 <= -0.001) or not (NdChar <= 4.5e+92):
		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 <= -0.001) || !(NdChar <= 4.5e+92))
		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 <= -0.001) || ~((NdChar <= 4.5e+92)))
		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, -0.001], N[Not[LessEqual[NdChar, 4.5e+92]], $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 < -1e-3 or 4.4999999999999999e92 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around inf 73.3%

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

   if -1e-3 < NdChar < 4.4999999999999999e92

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 72.6%

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

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -0.001 \lor \neg \left(NdChar \leq 4.5 \cdot 10^{+92}\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 8: 61.5% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -6.2e+229)
   (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
   (if (<= NdChar 1.8e+185)
     (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
     (/ NdChar (+ 1.0 (exp (/ 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 <= -6.2e+229) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else if (NdChar <= 1.8e+185) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	} else {
		tmp = NdChar / (1.0 + exp((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 <= (-6.2d+229)) then
        tmp = ndchar / (1.0d0 + exp((vef / kbt)))
    else if (ndchar <= 1.8d+185) then
        tmp = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
    else
        tmp = ndchar / (1.0d0 + exp((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 <= -6.2e+229) {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	} else if (NdChar <= 1.8e+185) {
		tmp = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	} else {
		tmp = NdChar / (1.0 + Math.exp((mu / KbT)));
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NdChar <= -6.2e+229)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	elseif (NdChar <= 1.8e+185)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT))));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(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 <= -6.2e+229)
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	elseif (NdChar <= 1.8e+185)
		tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
	else
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NdChar < -6.20000000000000027e229

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

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

   6. Taylor expanded in Vef around inf 86.2%

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

   if -6.20000000000000027e229 < NdChar < 1.80000000000000014e185

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 69.6%

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

   if 1.80000000000000014e185 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around inf 72.0%

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

   6. Taylor expanded in mu around inf 54.3%

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

4. Final simplification 69.0%

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

Alternative 9: 42.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;Vef \leq -4.7 \cdot 10^{+183}:\\ \;\;\;\;\frac{NaChar}{t\_0}\\ \mathbf{elif}\;Vef \leq -1.06 \cdot 10^{+68}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;Vef \leq 27000000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \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 (<= Vef -4.7e+183)
     (/ NaChar t_0)
     (if (<= Vef -1.06e+68)
       (/ NdChar (+ 1.0 (exp (/ Ec (- KbT)))))
       (if (<= Vef 27000000.0)
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
         (/ 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 (Vef <= -4.7e+183) {
		tmp = NaChar / t_0;
	} else if (Vef <= -1.06e+68) {
		tmp = NdChar / (1.0 + exp((Ec / -KbT)));
	} else if (Vef <= 27000000.0) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} 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 (vef <= (-4.7d+183)) then
        tmp = nachar / t_0
    else if (vef <= (-1.06d+68)) then
        tmp = ndchar / (1.0d0 + exp((ec / -kbt)))
    else if (vef <= 27000000.0d0) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    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 (Vef <= -4.7e+183) {
		tmp = NaChar / t_0;
	} else if (Vef <= -1.06e+68) {
		tmp = NdChar / (1.0 + Math.exp((Ec / -KbT)));
	} else if (Vef <= 27000000.0) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} 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 Vef <= -4.7e+183:
		tmp = NaChar / t_0
	elif Vef <= -1.06e+68:
		tmp = NdChar / (1.0 + math.exp((Ec / -KbT)))
	elif Vef <= 27000000.0:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	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 (Vef <= -4.7e+183)
		tmp = Float64(NaChar / t_0);
	elseif (Vef <= -1.06e+68)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-KbT)))));
	elseif (Vef <= 27000000.0)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	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 (Vef <= -4.7e+183)
		tmp = NaChar / t_0;
	elseif (Vef <= -1.06e+68)
		tmp = NdChar / (1.0 + exp((Ec / -KbT)));
	elseif (Vef <= 27000000.0)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	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[LessEqual[Vef, -4.7e+183], N[(NaChar / t$95$0), $MachinePrecision], If[LessEqual[Vef, -1.06e+68], N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 27000000.0], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar / t$95$0), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -4.6999999999999999e183

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 63.5%

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

   6. Taylor expanded in Vef around inf 63.4%

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

   if -4.6999999999999999e183 < Vef < -1.06e68

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

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

   6. Taylor expanded in Ec around inf 53.0%

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

      1. neg-mul-1 53.0%

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

   8. Simplified 53.0%

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

   if -1.06e68 < Vef < 2.7e7

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 70.8%

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

   6. Taylor expanded in EAccept around inf 50.4%

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

   if 2.7e7 < 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 inf 72.0%

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

   6. Taylor expanded in Vef around inf 62.7%

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

4. Final simplification 55.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -4.7 \cdot 10^{+183}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq -1.06 \cdot 10^{+68}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;Vef \leq 27000000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 42.8% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;Vef \leq -4.8 \cdot 10^{+183}:\\ \;\;\;\;\frac{NaChar}{t\_0}\\ \mathbf{elif}\;Vef \leq -6000000000:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 27500000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \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 (<= Vef -4.8e+183)
     (/ NaChar t_0)
     (if (<= Vef -6000000000.0)
       (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
       (if (<= Vef 27500000.0)
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
         (/ 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 (Vef <= -4.8e+183) {
		tmp = NaChar / t_0;
	} else if (Vef <= -6000000000.0) {
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	} else if (Vef <= 27500000.0) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} 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 (vef <= (-4.8d+183)) then
        tmp = nachar / t_0
    else if (vef <= (-6000000000.0d0)) then
        tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
    else if (vef <= 27500000.0d0) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    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 (Vef <= -4.8e+183) {
		tmp = NaChar / t_0;
	} else if (Vef <= -6000000000.0) {
		tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	} else if (Vef <= 27500000.0) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} 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 Vef <= -4.8e+183:
		tmp = NaChar / t_0
	elif Vef <= -6000000000.0:
		tmp = NdChar / (1.0 + math.exp((EDonor / KbT)))
	elif Vef <= 27500000.0:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	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 (Vef <= -4.8e+183)
		tmp = Float64(NaChar / t_0);
	elseif (Vef <= -6000000000.0)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))));
	elseif (Vef <= 27500000.0)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	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 (Vef <= -4.8e+183)
		tmp = NaChar / t_0;
	elseif (Vef <= -6000000000.0)
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	elseif (Vef <= 27500000.0)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	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[LessEqual[Vef, -4.8e+183], N[(NaChar / t$95$0), $MachinePrecision], If[LessEqual[Vef, -6000000000.0], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 27500000.0], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar / t$95$0), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if Vef < -4.8000000000000003e183

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 63.5%

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

   6. Taylor expanded in Vef around inf 63.4%

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

   if -4.8000000000000003e183 < Vef < -6e9

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 69.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 48.5%

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

   if -6e9 < Vef < 2.75e7

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 72.6%

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

   6. Taylor expanded in EAccept around inf 51.5%

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

   if 2.75e7 < 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 inf 72.0%

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

   6. Taylor expanded in Vef around inf 62.7%

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

Alternative 11: 44.1% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -1.6 \cdot 10^{+89} \lor \neg \left(Vef \leq 3 \cdot 10^{+62}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -1.6e+89) (not (<= Vef 3e+62)))
   (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
   (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -1.6e+89], N[Not[LessEqual[Vef, 3e+62]], $MachinePrecision]], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if Vef < -1.59999999999999994e89 or 3e62 < 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 58.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 52.1%

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

   if -1.59999999999999994e89 < Vef < 3e62

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 68.2%

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

   6. Taylor expanded in EAccept around inf 47.7%

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

4. Final simplification 49.5%

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

Alternative 12: 54.4% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 1.7e+211)
   (/ NaChar (+ 1.0 (pow E (/ (- (+ Vef Ev) mu) KbT))))
   (/ NdChar (+ 1.0 (exp (/ 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 (EAccept <= 1.7e+211) {
		tmp = NaChar / (1.0 + pow(((double) M_E), (((Vef + Ev) - mu) / KbT)));
	} else {
		tmp = NdChar / (1.0 + exp((Ec / -KbT)));
	}
	return tmp;
}

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 1.69999999999999995e211

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 64.6%

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

      1. *-un-lft-identity 64.6%

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

      2. exp-prod 64.6%

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

      3. +-commutative 64.6%

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

   7. Applied egg-rr 64.6%

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

      1. exp-1-e 64.6%

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

      2. associate--l+ 64.6%

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

      3. +-commutative 64.6%

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

      4. sub-neg 64.6%

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

      5. associate-+r+ 64.6%

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

      6. mul-1-neg 64.6%

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

      7. mul-1-neg 64.6%

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

      8. associate-+r+ 64.6%

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

      9. sub-neg 64.6%

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

      10. associate--l+ 64.6%

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

   9. Simplified 64.6%

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

   10. Taylor expanded in EAccept around 0 60.4%

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

   if 1.69999999999999995e211 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 68.4%

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

   6. Taylor expanded in Ec around inf 45.6%

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

      1. neg-mul-1 45.6%

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

   8. Simplified 45.6%

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

4. Final simplification 58.9%

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

Alternative 13: 39.2% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EAccept < 2.7499999999999998e-80

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 66.0%

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

   6. Taylor expanded in Ev around inf 39.2%

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

   if 2.7499999999999998e-80 < EAccept

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in NdChar around 0 60.3%

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

   6. Taylor expanded in EAccept around inf 45.0%

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

Alternative 14: 38.9% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT 2e+189)
   (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
   (+
    (* NdChar (+ 0.5 (* (/ (- (+ EDonor (+ mu Vef)) Ec) KbT) -0.25)))
    (* NaChar 0.5))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < 2e189

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

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

   6. Taylor expanded in EAccept around inf 40.0%

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

   if 2e189 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. *-commutative 78.2%

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

   7. Simplified 78.2%

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

   8. Taylor expanded in KbT around inf 42.5%

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

   9. Taylor expanded in NdChar around 0 64.6%

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

4. Final simplification 42.6%

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

Alternative 15: 31.6% accurate, 7.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.8 \cdot 10^{+84}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;KbT \leq 8.5 \cdot 10^{+173}:\\ \;\;\;\;\frac{NaChar}{\frac{EAccept + \left(Ev + \left(Vef - mu\right)\right)}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot \left(0.5 + \frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT} \cdot -0.25\right) + NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -2.8e+84)
   (* 0.5 (+ NdChar NaChar))
   (if (<= KbT 8.5e+173)
     (/ NaChar (+ (/ (+ EAccept (+ Ev (- Vef mu))) KbT) 2.0))
     (+
      (* NdChar (+ 0.5 (* (/ (- (+ EDonor (+ mu Vef)) Ec) KbT) -0.25)))
      (* NaChar 0.5)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -2.8e+84) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (KbT <= 8.5e+173) {
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0);
	} else {
		tmp = (NdChar * (0.5 + ((((EDonor + (mu + Vef)) - Ec) / KbT) * -0.25))) + (NaChar * 0.5);
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -2.8e+84:
		tmp = 0.5 * (NdChar + NaChar)
	elif KbT <= 8.5e+173:
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0)
	else:
		tmp = (NdChar * (0.5 + ((((EDonor + (mu + Vef)) - Ec) / KbT) * -0.25))) + (NaChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -2.8e+84)
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	elseif (KbT <= 8.5e+173)
		tmp = Float64(NaChar / Float64(Float64(Float64(EAccept + Float64(Ev + Float64(Vef - mu))) / KbT) + 2.0));
	else
		tmp = Float64(Float64(NdChar * Float64(0.5 + Float64(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT) * -0.25))) + Float64(NaChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -2.8e+84)
		tmp = 0.5 * (NdChar + NaChar);
	elseif (KbT <= 8.5e+173)
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0);
	else
		tmp = (NdChar * (0.5 + ((((EDonor + (mu + Vef)) - Ec) / KbT) * -0.25))) + (NaChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.8e+84], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 8.5e+173], N[(NaChar / N[(N[(N[(EAccept + N[(Ev + N[(Vef - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * N[(0.5 + N[(N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision] * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.79999999999999982e84

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. distribute-lft-out 42.8%

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

   7. Simplified 42.8%

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

   if -2.79999999999999982e84 < KbT < 8.5000000000000003e173

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 67.4%

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

      1. *-un-lft-identity 67.4%

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

      2. exp-prod 67.4%

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

      3. +-commutative 67.4%

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

   7. Applied egg-rr 67.4%

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

      1. exp-1-e 67.4%

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

      2. associate--l+ 67.4%

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

      3. +-commutative 67.4%

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

      4. sub-neg 67.4%

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

      5. associate-+r+ 67.4%

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

      6. mul-1-neg 67.4%

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

      7. mul-1-neg 67.4%

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

      8. associate-+r+ 67.4%

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

      9. sub-neg 67.4%

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

      10. associate--l+ 67.4%

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

   9. Simplified 67.4%

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

   10. Taylor expanded in KbT around inf 25.2%

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

       1. associate--l+ 25.2%

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

       2. associate-+r- 25.2%

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

       3. sub-neg 25.2%

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

       4. mul-1-neg 25.2%

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

       5. log-E 25.2%

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

       6. associate-/l* 25.2%

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

       7. mul-1-neg 25.2%

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

       8. sub-neg 25.2%

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

       9. *-lft-identity 25.2%

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

   12. Simplified 25.2%

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

   if 8.5000000000000003e173 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. *-commutative 75.2%

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

   7. Simplified 75.2%

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

   8. Taylor expanded in KbT around inf 40.7%

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

   9. Taylor expanded in NdChar around 0 59.9%

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

4. Final simplification 32.3%

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

Alternative 16: 31.8% accurate, 9.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1 \cdot 10^{+83}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{+171}:\\ \;\;\;\;\frac{NaChar}{\frac{EAccept + \left(Ev + \left(Vef - mu\right)\right)}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;NaChar \cdot 0.5 + \left(-0.25 \cdot \left(NdChar \cdot \frac{Vef}{KbT}\right) + NdChar \cdot 0.5\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1e+83)
   (* 0.5 (+ NdChar NaChar))
   (if (<= KbT 1.9e+171)
     (/ NaChar (+ (/ (+ EAccept (+ Ev (- Vef mu))) KbT) 2.0))
     (+ (* NaChar 0.5) (+ (* -0.25 (* NdChar (/ Vef KbT))) (* NdChar 0.5))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1e+83) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (KbT <= 1.9e+171) {
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0);
	} else {
		tmp = (NaChar * 0.5) + ((-0.25 * (NdChar * (Vef / KbT))) + (NdChar * 0.5));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1e+83:
		tmp = 0.5 * (NdChar + NaChar)
	elif KbT <= 1.9e+171:
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0)
	else:
		tmp = (NaChar * 0.5) + ((-0.25 * (NdChar * (Vef / KbT))) + (NdChar * 0.5))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -1e+83)
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	elseif (KbT <= 1.9e+171)
		tmp = Float64(NaChar / Float64(Float64(Float64(EAccept + Float64(Ev + Float64(Vef - mu))) / KbT) + 2.0));
	else
		tmp = Float64(Float64(NaChar * 0.5) + Float64(Float64(-0.25 * Float64(NdChar * Float64(Vef / KbT))) + Float64(NdChar * 0.5)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -1e+83)
		tmp = 0.5 * (NdChar + NaChar);
	elseif (KbT <= 1.9e+171)
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0);
	else
		tmp = (NaChar * 0.5) + ((-0.25 * (NdChar * (Vef / KbT))) + (NdChar * 0.5));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1e+83], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.9e+171], N[(NaChar / N[(N[(N[(EAccept + N[(Ev + N[(Vef - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(N[(-0.25 * N[(NdChar * N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.00000000000000003e83

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. distribute-lft-out 42.8%

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

   7. Simplified 42.8%

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

   if -1.00000000000000003e83 < KbT < 1.9000000000000001e171

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 67.4%

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

      1. *-un-lft-identity 67.4%

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

      2. exp-prod 67.4%

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

      3. +-commutative 67.4%

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

   7. Applied egg-rr 67.4%

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

      1. exp-1-e 67.4%

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

      2. associate--l+ 67.4%

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

      3. +-commutative 67.4%

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

      4. sub-neg 67.4%

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

      5. associate-+r+ 67.4%

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

      6. mul-1-neg 67.4%

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

      7. mul-1-neg 67.4%

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

      8. associate-+r+ 67.4%

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

      9. sub-neg 67.4%

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

      10. associate--l+ 67.4%

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

   9. Simplified 67.4%

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

   10. Taylor expanded in KbT around inf 25.2%

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

       1. associate--l+ 25.2%

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

       2. associate-+r- 25.2%

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

       3. sub-neg 25.2%

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

       4. mul-1-neg 25.2%

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

       5. log-E 25.2%

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

       6. associate-/l* 25.2%

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

       7. mul-1-neg 25.2%

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

       8. sub-neg 25.2%

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

       9. *-lft-identity 25.2%

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

   12. Simplified 25.2%

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

   if 1.9000000000000001e171 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. *-commutative 75.2%

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

   7. Simplified 75.2%

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

   8. Taylor expanded in KbT around inf 40.7%

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

   9. Taylor expanded in Vef around inf 49.0%

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

       1. associate-/l* 58.2%

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

   11. Simplified 58.2%

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

4. Final simplification 32.1%

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

Alternative 17: 31.7% accurate, 9.1× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.4e+82)
   (* 0.5 (+ NdChar NaChar))
   (if (<= KbT 1.05e+172)
     (/ NaChar (+ (/ (+ EAccept (+ Ev (- Vef mu))) KbT) 2.0))
     (+
      (* NaChar 0.5)
      (+ (* NdChar 0.5) (* -0.25 (* EDonor (/ NdChar KbT))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1.4e+82) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (KbT <= 1.05e+172) {
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0);
	} else {
		tmp = (NaChar * 0.5) + ((NdChar * 0.5) + (-0.25 * (EDonor * (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) :: tmp
    if (kbt <= (-1.4d+82)) then
        tmp = 0.5d0 * (ndchar + nachar)
    else if (kbt <= 1.05d+172) then
        tmp = nachar / (((eaccept + (ev + (vef - mu))) / kbt) + 2.0d0)
    else
        tmp = (nachar * 0.5d0) + ((ndchar * 0.5d0) + ((-0.25d0) * (edonor * (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 tmp;
	if (KbT <= -1.4e+82) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (KbT <= 1.05e+172) {
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0);
	} else {
		tmp = (NaChar * 0.5) + ((NdChar * 0.5) + (-0.25 * (EDonor * (NdChar / KbT))));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.4e82

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. distribute-lft-out 42.8%

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

   7. Simplified 42.8%

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

   if -1.4e82 < KbT < 1.0500000000000001e172

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 67.4%

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

      1. *-un-lft-identity 67.4%

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

      2. exp-prod 67.4%

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

      3. +-commutative 67.4%

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

   7. Applied egg-rr 67.4%

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

      1. exp-1-e 67.4%

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

      2. associate--l+ 67.4%

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

      3. +-commutative 67.4%

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

      4. sub-neg 67.4%

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

      5. associate-+r+ 67.4%

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

      6. mul-1-neg 67.4%

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

      7. mul-1-neg 67.4%

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

      8. associate-+r+ 67.4%

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

      9. sub-neg 67.4%

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

      10. associate--l+ 67.4%

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

   9. Simplified 67.4%

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

   10. Taylor expanded in KbT around inf 25.2%

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

       1. associate--l+ 25.2%

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

       2. associate-+r- 25.2%

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

       3. sub-neg 25.2%

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

       4. mul-1-neg 25.2%

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

       5. log-E 25.2%

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

       6. associate-/l* 25.2%

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

       7. mul-1-neg 25.2%

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

       8. sub-neg 25.2%

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

       9. *-lft-identity 25.2%

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

   12. Simplified 25.2%

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

   if 1.0500000000000001e172 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. *-commutative 75.2%

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

   7. Simplified 75.2%

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

   8. Taylor expanded in KbT around inf 40.7%

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

   9. Taylor expanded in EDonor around inf 47.2%

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

       1. associate-/l* 57.0%

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

   11. Simplified 57.0%

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

4. Final simplification 31.9%

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

Alternative 18: 31.7% accurate, 9.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.6 \cdot 10^{+81}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;KbT \leq 2.45 \cdot 10^{+171}:\\ \;\;\;\;\frac{NaChar}{\frac{EAccept + \left(Ev + \left(Vef - mu\right)\right)}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;NaChar \cdot 0.5 + NdChar \cdot \left(0.5 + \frac{Ec \cdot 0.25}{KbT}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -2.6e+81)
   (* 0.5 (+ NdChar NaChar))
   (if (<= KbT 2.45e+171)
     (/ NaChar (+ (/ (+ EAccept (+ Ev (- Vef mu))) KbT) 2.0))
     (+ (* NaChar 0.5) (* NdChar (+ 0.5 (/ (* Ec 0.25) KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -2.6e+81) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (KbT <= 2.45e+171) {
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0);
	} else {
		tmp = (NaChar * 0.5) + (NdChar * (0.5 + ((Ec * 0.25) / KbT)));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -2.6e+81:
		tmp = 0.5 * (NdChar + NaChar)
	elif KbT <= 2.45e+171:
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0)
	else:
		tmp = (NaChar * 0.5) + (NdChar * (0.5 + ((Ec * 0.25) / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -2.6e+81)
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	elseif (KbT <= 2.45e+171)
		tmp = Float64(NaChar / Float64(Float64(Float64(EAccept + Float64(Ev + Float64(Vef - mu))) / KbT) + 2.0));
	else
		tmp = Float64(Float64(NaChar * 0.5) + Float64(NdChar * Float64(0.5 + Float64(Float64(Ec * 0.25) / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -2.6e+81)
		tmp = 0.5 * (NdChar + NaChar);
	elseif (KbT <= 2.45e+171)
		tmp = NaChar / (((EAccept + (Ev + (Vef - mu))) / KbT) + 2.0);
	else
		tmp = (NaChar * 0.5) + (NdChar * (0.5 + ((Ec * 0.25) / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.6e+81], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.45e+171], N[(NaChar / N[(N[(N[(EAccept + N[(Ev + N[(Vef - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar * N[(0.5 + N[(N[(Ec * 0.25), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.59999999999999992e81

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. distribute-lft-out 42.8%

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

   7. Simplified 42.8%

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

   if -2.59999999999999992e81 < KbT < 2.4499999999999999e171

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 67.4%

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

      1. *-un-lft-identity 67.4%

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

      2. exp-prod 67.4%

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

      3. +-commutative 67.4%

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

   7. Applied egg-rr 67.4%

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

      1. exp-1-e 67.4%

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

      2. associate--l+ 67.4%

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

      3. +-commutative 67.4%

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

      4. sub-neg 67.4%

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

      5. associate-+r+ 67.4%

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

      6. mul-1-neg 67.4%

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

      7. mul-1-neg 67.4%

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

      8. associate-+r+ 67.4%

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

      9. sub-neg 67.4%

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

      10. associate--l+ 67.4%

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

   9. Simplified 67.4%

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

   10. Taylor expanded in KbT around inf 25.2%

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

       1. associate--l+ 25.2%

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

       2. associate-+r- 25.2%

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

       3. sub-neg 25.2%

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

       4. mul-1-neg 25.2%

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

       5. log-E 25.2%

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

       6. associate-/l* 25.2%

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

       7. mul-1-neg 25.2%

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

       8. sub-neg 25.2%

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

       9. *-lft-identity 25.2%

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

   12. Simplified 25.2%

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

   if 2.4499999999999999e171 < KbT

   1. Initial program 99.8%

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

   3. Simplified 99.8%

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

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

      1. *-commutative 75.2%

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

   7. Simplified 75.2%

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

   8. Taylor expanded in KbT around inf 40.7%

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

   9. Taylor expanded in Ec around inf 48.2%

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

   10. Taylor expanded in NdChar around 0 56.9%

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

       1. associate-*r/ 56.9%

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

   12. Simplified 56.9%

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

4. Final simplification 31.9%

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

Alternative 19: 30.0% accurate, 13.4× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -2.2e+214) (not (<= Vef 1.2e+153)))
   (/ NaChar (+ (/ Vef KbT) 2.0))
   (* 0.5 (+ NdChar NaChar))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -2.20000000000000023e214 or 1.19999999999999996e153 < 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 67.3%

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

   6. Taylor expanded in Vef around inf 65.4%

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

   7. Taylor expanded in Vef around 0 37.2%

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

      1. +-commutative 37.2%

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

   9. Simplified 37.2%

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

   if -2.20000000000000023e214 < Vef < 1.19999999999999996e153

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 25.8%

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

      1. distribute-lft-out 25.8%

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

   7. Simplified 25.8%

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

4. Final simplification 28.1%

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

Alternative 20: 28.5% accurate, 13.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -3.3 \cdot 10^{-14} \lor \neg \left(KbT \leq 7.6 \cdot 10^{+156}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -3.3e-14) (not (<= KbT 7.6e+156)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (+ (/ Ev KbT) 2.0))))

C

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

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -3.3e-14) or not (KbT <= 7.6e+156):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar / ((Ev / KbT) + 2.0)
	return tmp

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -3.3e-14], N[Not[LessEqual[KbT, 7.6e+156]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -3.2999999999999998e-14 or 7.60000000000000048e156 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 41.6%

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

      1. distribute-lft-out 41.6%

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

   7. Simplified 41.6%

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

   if -3.2999999999999998e-14 < KbT < 7.60000000000000048e156

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 68.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 37.8%

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

   7. Taylor expanded in Ev around 0 18.5%

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

4. Final simplification 27.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -3.3 \cdot 10^{-14} \lor \neg \left(KbT \leq 7.6 \cdot 10^{+156}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \end{array} \]
5. Add Preprocessing

Alternative 21: 23.3% accurate, 17.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -5.8 \cdot 10^{-46} \lor \neg \left(NdChar \leq 2.9 \cdot 10^{+95}\right):\\ \;\;\;\;NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -5.8e-46) (not (<= NdChar 2.9e+95)))
   (* NdChar 0.5)
   (* NaChar 0.5)))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -5.8e-46) || !(NdChar <= 2.9e+95)) {
		tmp = NdChar * 0.5;
	} else {
		tmp = NaChar * 0.5;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((ndchar <= (-5.8d-46)) .or. (.not. (ndchar <= 2.9d+95))) then
        tmp = ndchar * 0.5d0
    else
        tmp = nachar * 0.5d0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -5.8e-46) || !(NdChar <= 2.9e+95)) {
		tmp = NdChar * 0.5;
	} else {
		tmp = NaChar * 0.5;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NdChar <= -5.8e-46) or not (NdChar <= 2.9e+95):
		tmp = NdChar * 0.5
	else:
		tmp = NaChar * 0.5
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -5.8e-46) || !(NdChar <= 2.9e+95))
		tmp = Float64(NdChar * 0.5);
	else
		tmp = Float64(NaChar * 0.5);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -5.8e-46) || ~((NdChar <= 2.9e+95)))
		tmp = NdChar * 0.5;
	else
		tmp = NaChar * 0.5;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -5.8e-46], N[Not[LessEqual[NdChar, 2.9e+95]], $MachinePrecision]], N[(NdChar * 0.5), $MachinePrecision], N[(NaChar * 0.5), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -5.80000000000000009e-46 or 2.90000000000000013e95 < NdChar

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 25.0%

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

      1. distribute-lft-out 25.0%

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

   7. Simplified 25.0%

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

   8. Taylor expanded in NaChar around 0 22.9%

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

      1. *-commutative 22.9%

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

   10. Simplified 22.9%

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

   if -5.80000000000000009e-46 < NdChar < 2.90000000000000013e95

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

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

      1. distribute-lft-out 21.2%

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

   7. Simplified 21.2%

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

   8. Taylor expanded in NaChar around inf 20.9%

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

4. Final simplification 21.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -5.8 \cdot 10^{-46} \lor \neg \left(NdChar \leq 2.9 \cdot 10^{+95}\right):\\ \;\;\;\;NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NaChar \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 22: 28.3% 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 99.9%

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

3. Simplified 99.9%

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

5. Taylor expanded in KbT around inf 22.8%

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

   1. distribute-lft-out 22.8%

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

7. Simplified 22.8%

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

8. Final simplification 22.8%

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

Alternative 23: 19.0% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

3. Simplified 99.9%

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

5. Taylor expanded in KbT around inf 22.8%

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

   1. distribute-lft-out 22.8%

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

7. Simplified 22.8%

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

8. Taylor expanded in NaChar around inf 16.5%

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

9. Final simplification 16.5%

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

Reproduce

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