Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 18.1s

Alternatives: 15

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = 1.7784261262306536e-25
  2. Ec = -9.69130715359626e-279
  3. Vef = 6.6959923779260935e+180
  4. EDonor = -2.5265704004528258e+38
  5. mu = -8.270017326677861e+58
  6. KbT = -1.1711620386513258e-209
  7. NaChar = -5.954066252088624e-26
  8. Ev = -3.725759901590531e-50
  9. EAccept = 2.346290610115038e+131

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

Alternative 2: 66.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 1.05 \cdot 10^{-241}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.52 \cdot 10^{-115} \lor \neg \left(EAccept \leq 2.9 \cdot 10^{+112}\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 (<= EAccept 1.05e-241)
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT))))
    (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
   (if (or (<= EAccept 1.52e-115) (not (<= EAccept 2.9e+112)))
     (/ 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 (EAccept <= 1.05e-241) {
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if ((EAccept <= 1.52e-115) || !(EAccept <= 2.9e+112)) {
		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 (eaccept <= 1.05d-241) then
        tmp = (ndchar / (1.0d0 + exp(((edonor + (mu + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
    else if ((eaccept <= 1.52d-115) .or. (.not. (eaccept <= 2.9d+112))) 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 (EAccept <= 1.05e-241) {
		tmp = (NdChar / (1.0 + Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if ((EAccept <= 1.52e-115) || !(EAccept <= 2.9e+112)) {
		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 EAccept <= 1.05e-241:
		tmp = (NdChar / (1.0 + math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif (EAccept <= 1.52e-115) or not (EAccept <= 2.9e+112):
		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 (EAccept <= 1.05e-241)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif ((EAccept <= 1.52e-115) || !(EAccept <= 2.9e+112))
		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 (EAccept <= 1.05e-241)
		tmp = (NdChar / (1.0 + exp(((EDonor + (mu + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif ((EAccept <= 1.52e-115) || ~((EAccept <= 2.9e+112)))
		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[LessEqual[EAccept, 1.05e-241], 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[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EAccept, 1.52e-115], N[Not[LessEqual[EAccept, 2.9e+112]], $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 3 regimes

2. if EAccept < 1.05e-241

   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 Ev around inf 69.1%

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

   if 1.05e-241 < EAccept < 1.5200000000000001e-115 or 2.9000000000000002e112 < 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.1%

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

   if 1.5200000000000001e-115 < EAccept < 2.9000000000000002e112

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 69.3%

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

4. Final simplification 68.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;EAccept \leq 1.05 \cdot 10^{-241}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.52 \cdot 10^{-115} \lor \neg \left(EAccept \leq 2.9 \cdot 10^{+112}\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 3: 43.4% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -3.8:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;Vef \leq -1.12 \cdot 10^{-138}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 4.5 \cdot 10^{-227}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;Vef \leq 4.4 \cdot 10^{+91}:\\ \;\;\;\;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 (/ Ec (- KbT))))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -3.8)
     t_1
     (if (<= Vef -1.12e-138)
       t_0
       (if (<= Vef 4.5e-227)
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
         (if (<= Vef 4.4e+91) 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((Ec / -KbT)));
	double t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -3.8) {
		tmp = t_1;
	} else if (Vef <= -1.12e-138) {
		tmp = t_0;
	} else if (Vef <= 4.5e-227) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (Vef <= 4.4e+91) {
		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((ec / -kbt)))
    t_1 = nachar / (1.0d0 + exp((vef / kbt)))
    if (vef <= (-3.8d0)) then
        tmp = t_1
    else if (vef <= (-1.12d-138)) then
        tmp = t_0
    else if (vef <= 4.5d-227) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if (vef <= 4.4d+91) 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((Ec / -KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (Vef <= -3.8) {
		tmp = t_1;
	} else if (Vef <= -1.12e-138) {
		tmp = t_0;
	} else if (Vef <= 4.5e-227) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if (Vef <= 4.4e+91) {
		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((Ec / -KbT)))
	t_1 = NaChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if Vef <= -3.8:
		tmp = t_1
	elif Vef <= -1.12e-138:
		tmp = t_0
	elif Vef <= 4.5e-227:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif Vef <= 4.4e+91:
		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(Ec / Float64(-KbT)))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -3.8)
		tmp = t_1;
	elseif (Vef <= -1.12e-138)
		tmp = t_0;
	elseif (Vef <= 4.5e-227)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (Vef <= 4.4e+91)
		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((Ec / -KbT)));
	t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -3.8)
		tmp = t_1;
	elseif (Vef <= -1.12e-138)
		tmp = t_0;
	elseif (Vef <= 4.5e-227)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (Vef <= 4.4e+91)
		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[(Ec / (-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, -3.8], t$95$1, If[LessEqual[Vef, -1.12e-138], t$95$0, If[LessEqual[Vef, 4.5e-227], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 4.4e+91], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -3.7999999999999998 or 4.39999999999999999e91 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

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

   if -3.7999999999999998 < Vef < -1.1199999999999999e-138 or 4.49999999999999993e-227 < Vef < 4.39999999999999999e91

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

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

   6. Taylor expanded in Ec around inf 50.0%

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

      1. associate-*r/ 50.0%

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

      2. mul-1-neg 50.0%

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

   8. Simplified 50.0%

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

   if -1.1199999999999999e-138 < Vef < 4.49999999999999993e-227

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 61.1%

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

   6. Taylor expanded in EAccept around inf 42.3%

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

4. Final simplification 52.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -3.8:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq -1.12 \cdot 10^{-138}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{elif}\;Vef \leq 4.5 \cdot 10^{-227}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;Vef \leq 4.4 \cdot 10^{+91}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 69.1% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -2.5499999999999999e-14 or 3.1999999999999999e-59 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 70.7%

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

   if -2.5499999999999999e-14 < NaChar < 3.1999999999999999e-59

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

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

4. Final simplification 70.3%

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

Alternative 5: 43.8% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -1.25:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq 6 \cdot 10^{-227}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;Vef \leq 3.05 \cdot 10^{+94}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -1.25)
     t_0
     (if (<= Vef 6e-227)
       (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 0.5))
       (if (<= Vef 3.05e+94) (/ NdChar (+ 1.0 (exp (/ Ec (- KbT))))) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -1.25) {
		tmp = t_0;
	} else if (Vef <= 6e-227) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
	} else if (Vef <= 3.05e+94) {
		tmp = NdChar / (1.0 + exp((Ec / -KbT)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if Vef <= -1.25:
		tmp = t_0
	elif Vef <= 6e-227:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar * 0.5)
	elif Vef <= 3.05e+94:
		tmp = NdChar / (1.0 + math.exp((Ec / -KbT)))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -1.25)
		tmp = t_0;
	elseif (Vef <= 6e-227)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar * 0.5));
	elseif (Vef <= 3.05e+94)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Ec / Float64(-KbT)))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -1.25)
		tmp = t_0;
	elseif (Vef <= 6e-227)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
	elseif (Vef <= 3.05e+94)
		tmp = NdChar / (1.0 + exp((Ec / -KbT)));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -1.25], t$95$0, If[LessEqual[Vef, 6e-227], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 3.05e+94], N[(NdChar / N[(1.0 + N[Exp[N[(Ec / (-KbT)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -1.25 or 3.05000000000000017e94 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

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

   if -1.25 < Vef < 5.9999999999999999e-227

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

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

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

   7. Simplified 53.3%

      \[\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 EDonor around inf 46.0%

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

   if 5.9999999999999999e-227 < Vef < 3.05000000000000017e94

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

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

   6. Taylor expanded in Ec around inf 50.0%

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

      1. associate-*r/ 50.0%

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

      2. mul-1-neg 50.0%

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

   8. Simplified 50.0%

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

4. Final simplification 52.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -1.25:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Vef \leq 6 \cdot 10^{-227}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;Vef \leq 3.05 \cdot 10^{+94}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Ec}{-KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 62.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(EAccept + \left(Vef + Ev\right)\right) - mu\\ \mathbf{if}\;KbT \leq -1.12 \cdot 10^{+227}:\\ \;\;\;\;-0.25 \cdot \frac{NaChar \cdot t\_0}{KbT} + \left(\left(NdChar \cdot 0.5 + NaChar \cdot 0.5\right) - -0.25 \cdot \left(Ec \cdot \frac{NdChar}{KbT}\right)\right)\\ \mathbf{elif}\;KbT \leq 8 \cdot 10^{+199}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{t\_0}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision]}, If[LessEqual[KbT, -1.12e+227], N[(N[(-0.25 * N[(N[(NaChar * t$95$0), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision] - N[(-0.25 * N[(Ec * N[(NdChar / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 8e+199], N[(NaChar / N[(1.0 + N[Exp[N[(t$95$0 / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -1.1200000000000001e227

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

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

   6. Taylor expanded in Ec around inf 86.7%

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

      1. mul-1-neg 86.7%

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

      2. associate-/l* 100.0%

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

      3. distribute-rgt-neg-in 100.0%

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

      4. mul-1-neg 100.0%

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

      5. associate-*r/ 100.0%

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

      6. neg-mul-1 100.0%

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

   8. Simplified 100.0%

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

   if -1.1200000000000001e227 < KbT < 8.00000000000000078e199

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 63.0%

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

   if 8.00000000000000078e199 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 78.3%

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

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

   7. Simplified 78.3%

      \[\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 EDonor around inf 70.0%

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

4. Final simplification 65.7%

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

Alternative 7: 43.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;Vef \leq -3.5:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;Vef \leq -1.52 \cdot 10^{-212}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq 6 \cdot 10^{+128}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= Vef -3.5)
     t_0
     (if (<= Vef -1.52e-212)
       (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
       (if (<= Vef 6e+128) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (Vef <= -3.5) {
		tmp = t_0;
	} else if (Vef <= -1.52e-212) {
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	} else if (Vef <= 6e+128) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if Vef <= -3.5:
		tmp = t_0
	elif Vef <= -1.52e-212:
		tmp = NdChar / (1.0 + math.exp((EDonor / KbT)))
	elif Vef <= 6e+128:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (Vef <= -3.5)
		tmp = t_0;
	elseif (Vef <= -1.52e-212)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))));
	elseif (Vef <= 6e+128)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (Vef <= -3.5)
		tmp = t_0;
	elseif (Vef <= -1.52e-212)
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	elseif (Vef <= 6e+128)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.5], t$95$0, If[LessEqual[Vef, -1.52e-212], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 6e+128], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -3.5 or 5.9999999999999997e128 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

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

   if -3.5 < Vef < -1.52e-212

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 62.3%

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

   6. Taylor expanded in EDonor around inf 45.7%

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

   if -1.52e-212 < Vef < 5.9999999999999997e128

   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 Ev around inf 77.2%

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

   6. Taylor expanded in NdChar around 0 40.5%

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

Alternative 8: 41.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{if}\;KbT \leq -4.9 \cdot 10^{+152}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq -3.1 \cdot 10^{-208}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 4.7 \cdot 10^{+114}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* 0.5 (+ NdChar NaChar))))
   (if (<= KbT -4.9e+152)
     t_0
     (if (<= KbT -3.1e-208)
       (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
       (if (<= KbT 4.7e+114) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 0.5 * (NdChar + NaChar);
	double tmp;
	if (KbT <= -4.9e+152) {
		tmp = t_0;
	} else if (KbT <= -3.1e-208) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (KbT <= 4.7e+114) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 0.5 * (NdChar + NaChar)
	tmp = 0
	if KbT <= -4.9e+152:
		tmp = t_0
	elif KbT <= -3.1e-208:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif KbT <= 4.7e+114:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(0.5 * Float64(NdChar + NaChar))
	tmp = 0.0
	if (KbT <= -4.9e+152)
		tmp = t_0;
	elseif (KbT <= -3.1e-208)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (KbT <= 4.7e+114)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 0.5 * (NdChar + NaChar);
	tmp = 0.0;
	if (KbT <= -4.9e+152)
		tmp = t_0;
	elseif (KbT <= -3.1e-208)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (KbT <= 4.7e+114)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -4.9e+152], t$95$0, If[LessEqual[KbT, -3.1e-208], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4.7e+114], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -4.9000000000000004e152 or 4.7000000000000001e114 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 60.6%

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

      1. distribute-lft-out 60.6%

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

   7. Simplified 60.6%

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

   if -4.9000000000000004e152 < KbT < -3.0999999999999998e-208

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

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

   6. Taylor expanded in EAccept around inf 31.8%

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

   if -3.0999999999999998e-208 < KbT < 4.7000000000000001e114

   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 Ev around inf 59.7%

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

   6. Taylor expanded in NdChar around 0 29.7%

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

4. Final simplification 37.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -4.9 \cdot 10^{+152}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;KbT \leq -3.1 \cdot 10^{-208}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 4.7 \cdot 10^{+114}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 40.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -7.5 \cdot 10^{+151} \lor \neg \left(KbT \leq 3.5 \cdot 10^{+99}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \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 (<= KbT -7.5e+151) (not (<= KbT 3.5e+99)))
   (* 0.5 (+ NdChar NaChar))
   (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -7.5e+151) || !(KbT <= 3.5e+99)) {
		tmp = 0.5 * (NdChar + NaChar);
	} 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 ((kbt <= (-7.5d+151)) .or. (.not. (kbt <= 3.5d+99))) then
        tmp = 0.5d0 * (ndchar + nachar)
    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 ((KbT <= -7.5e+151) || !(KbT <= 3.5e+99)) {
		tmp = 0.5 * (NdChar + NaChar);
	} 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 (KbT <= -7.5e+151) or not (KbT <= 3.5e+99):
		tmp = 0.5 * (NdChar + NaChar)
	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 ((KbT <= -7.5e+151) || !(KbT <= 3.5e+99))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	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 ((KbT <= -7.5e+151) || ~((KbT <= 3.5e+99)))
		tmp = 0.5 * (NdChar + NaChar);
	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[KbT, -7.5e+151], N[Not[LessEqual[KbT, 3.5e+99]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $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 KbT < -7.49999999999999977e151 or 3.4999999999999998e99 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 59.6%

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

      1. distribute-lft-out 59.6%

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

   7. Simplified 59.6%

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

   if -7.49999999999999977e151 < KbT < 3.4999999999999998e99

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

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

4. Final simplification 39.2%

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

Alternative 10: 38.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;EAccept \leq -6 \cdot 10^{-145}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 1.4 \cdot 10^{+112}:\\ \;\;\;\;\frac{NaChar}{t\_0}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{t\_0}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 1.0 (exp (/ Vef KbT)))))
   (if (<= EAccept -6e-145)
     (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
     (if (<= EAccept 1.4e+112) (/ NaChar t_0) (/ NdChar t_0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	tmp = 0.0;
	if (EAccept <= -6e-145)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	elseif (EAccept <= 1.4e+112)
		tmp = NaChar / t_0;
	else
		tmp = NdChar / t_0;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < -5.99999999999999985e-145

   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 Ev around inf 66.8%

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

   6. Taylor expanded in NdChar around 0 35.9%

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

   if -5.99999999999999985e-145 < EAccept < 1.4000000000000001e112

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

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

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

   if 1.4000000000000001e112 < 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.3%

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

   6. Taylor expanded in Vef around inf 36.1%

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

Alternative 11: 39.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq -1.15 \cdot 10^{-143}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;EAccept \leq 2.5 \cdot 10^{+135}:\\ \;\;\;\;\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 (<= EAccept -1.15e-143)
   (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
   (if (<= EAccept 2.5e+135)
     (/ 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 (EAccept <= -1.15e-143) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else if (EAccept <= 2.5e+135) {
		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 (eaccept <= (-1.15d-143)) then
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    else if (eaccept <= 2.5d+135) 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 (EAccept <= -1.15e-143) {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	} else if (EAccept <= 2.5e+135) {
		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 EAccept <= -1.15e-143:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	elif EAccept <= 2.5e+135:
		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 (EAccept <= -1.15e-143)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	elseif (EAccept <= 2.5e+135)
		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 (EAccept <= -1.15e-143)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	elseif (EAccept <= 2.5e+135)
		tmp = NaChar / (1.0 + exp((Vef / KbT)));
	else
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < -1.15000000000000006e-143

   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 Ev around inf 66.8%

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

   6. Taylor expanded in NdChar around 0 35.9%

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

   if -1.15000000000000006e-143 < EAccept < 2.50000000000000015e135

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 63.1%

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

   6. Taylor expanded in Vef around inf 45.0%

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

   if 2.50000000000000015e135 < EAccept

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 44.4%

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

   6. Taylor expanded in EAccept around inf 37.5%

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

Alternative 12: 29.9% accurate, 13.4× speedup

Math

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

FPCore

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

Python

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if KbT < -7.2e21 or 8.5000000000000003e-223 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 33.8%

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

      1. distribute-lft-out 33.8%

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

   7. Simplified 33.8%

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

   if -7.2e21 < KbT < 8.5000000000000003e-223

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 64.6%

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

   6. Taylor expanded in Vef around inf 38.2%

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

   7. Taylor expanded in Vef around 0 21.7%

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

4. Final simplification 29.1%

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

Alternative 13: 19.6% accurate, 28.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq 1.9 \cdot 10^{+57}:\\ \;\;\;\;NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= EAccept 1.9e+57) (* NaChar 0.5) (/ NdChar 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 (EAccept <= 1.9e+57) {
		tmp = NaChar * 0.5;
	} else {
		tmp = NdChar / 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 (eaccept <= 1.9d+57) then
        tmp = nachar * 0.5d0
    else
        tmp = ndchar / 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 (EAccept <= 1.9e+57) {
		tmp = NaChar * 0.5;
	} else {
		tmp = NdChar / 2.0;
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EAccept, 1.9e+57], N[(NaChar * 0.5), $MachinePrecision], N[(NdChar / 2.0), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if EAccept < 1.8999999999999999e57

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

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

      1. distribute-lft-out 25.1%

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

   7. Simplified 25.1%

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

   8. Taylor expanded in NaChar around inf 19.5%

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

      1. *-commutative 19.5%

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

   10. Simplified 19.5%

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

   if 1.8999999999999999e57 < 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 60.6%

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

   6. Taylor expanded in KbT around inf 21.9%

      \[\leadsto \frac{NdChar}{\color{blue}{2}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 14: 28.1% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 24.4%

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

   1. distribute-lft-out 24.4%

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

7. Simplified 24.4%

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

8. Final simplification 24.4%

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

Alternative 15: 18.6% 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 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 24.4%

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

   1. distribute-lft-out 24.4%

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

7. Simplified 24.4%

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

8. Taylor expanded in NaChar around inf 17.8%

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

   1. *-commutative 17.8%

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

10. Simplified 17.8%

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

Reproduce

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