Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 19.6s

Alternatives: 15

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -1.9517647703471027e+261
  2. Ec = -1.2730446556741257e+153
  3. Vef = -1.2517284303266822e+265
  4. EDonor = 1.0951208216546274e+55
  5. mu = 6.095440280651459e+158
  6. KbT = 4.500918674594975e+229
  7. NaChar = 9.030866748657333e+260
  8. Ev = 4.1515548533109375e+186
  9. EAccept = 1.192444809914513e+72

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: 77.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}}\\ t_1 := t\_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -1.05 \cdot 10^{+94}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;mu \leq -1.12 \cdot 10^{+22}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.42 \cdot 10^{+134}:\\ \;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -1.05e+94)
     t_1
     (if (<= mu -1.12e+22)
       (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
       (if (<= mu 1.42e+134)
         (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -1.05e+94) {
		tmp = t_1;
	} else if (mu <= -1.12e+22) {
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= 1.42e+134) {
		tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))
    t_1 = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-1.05d+94)) then
        tmp = t_1
    else if (mu <= (-1.12d+22)) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= 1.42d+134) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -1.05e+94) {
		tmp = t_1;
	} else if (mu <= -1.12e+22) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= 1.42e+134) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))
	t_1 = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -1.05e+94:
		tmp = t_1
	elif mu <= -1.12e+22:
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 1.42e+134:
		tmp = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -1.05e+94)
		tmp = t_1;
	elseif (mu <= -1.12e+22)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 1.42e+134)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)));
	t_1 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -1.05e+94)
		tmp = t_1;
	elseif (mu <= -1.12e+22)
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 1.42e+134)
		tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.05e+94], t$95$1, If[LessEqual[mu, -1.12e+22], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.42e+134], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -1.04999999999999995e94 or 1.42000000000000002e134 < mu

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in mu around inf 90.8%

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

   if -1.04999999999999995e94 < mu < -1.12e22

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 100.0%

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

   if -1.12e22 < mu < 1.42000000000000002e134

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 84.0%

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

4. Final simplification 87.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1.05 \cdot 10^{+94}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -1.12 \cdot 10^{+22}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.42 \cdot 10^{+134}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 76.6% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))))
   (if (or (<= EDonor -1.5e+220) (not (<= EDonor 1.9e+81)))
     (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
     (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if EDonor < -1.50000000000000012e220 or 1.9e81 < EDonor

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EDonor around inf 90.5%

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

   if -1.50000000000000012e220 < EDonor < 1.9e81

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 80.7%

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

4. Final simplification 83.4%

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

Alternative 4: 71.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.8 \cdot 10^{-94} \lor \neg \left(NaChar \leq 1.55 \cdot 10^{+110}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{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 -1.8e-94) (not (<= NaChar 1.55e+110)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT))))
    (/ NdChar (+ 1.0 (exp (/ EDonor 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 <= -1.8e-94) || !(NaChar <= 1.55e+110)) {
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / 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 <= (-1.8d-94)) .or. (.not. (nachar <= 1.55d+110))) then
        tmp = (nachar / (1.0d0 + exp(((vef + (ev + (eaccept - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / 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 <= -1.8e-94) || !(NaChar <= 1.55e+110)) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / 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 <= -1.8e-94) or not (NaChar <= 1.55e+110):
		tmp = (NaChar / (1.0 + math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / 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 <= -1.8e-94) || !(NaChar <= 1.55e+110))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	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 <= -1.8e-94) || ~((NaChar <= 1.55e+110)))
		tmp = (NaChar / (1.0 + exp(((Vef + (Ev + (EAccept - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / 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, -1.8e-94], N[Not[LessEqual[NaChar, 1.55e+110]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 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 < -1.8e-94 or 1.55000000000000009e110 < 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 EDonor around inf 79.1%

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

   if -1.8e-94 < NaChar < 1.55000000000000009e110

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 78.5%

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

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

Alternative 5: 69.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -2.25 \cdot 10^{-94} \lor \neg \left(NaChar \leq 2 \cdot 10^{+110}\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.25e-94) (not (<= NaChar 2e+110)))
   (/ 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.25e-94) || !(NaChar <= 2e+110)) {
		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.25d-94)) .or. (.not. (nachar <= 2d+110))) 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.25e-94) || !(NaChar <= 2e+110)) {
		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.25e-94) or not (NaChar <= 2e+110):
		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.25e-94) || !(NaChar <= 2e+110))
		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.25e-94) || ~((NaChar <= 2e+110)))
		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.25e-94], N[Not[LessEqual[NaChar, 2e+110]], $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.2500000000000001e-94 or 2e110 < 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 76.6%

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

   if -2.2500000000000001e-94 < NaChar < 2e110

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 78.5%

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

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.25 \cdot 10^{-94} \lor \neg \left(NaChar \leq 2 \cdot 10^{+110}\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 6: 61.7% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NaChar <= -8e-181) || !(NaChar <= 1.6e-134))
		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(Vef / KbT))));
	end
	return tmp
end

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -8e-181], N[Not[LessEqual[NaChar, 1.6e-134]], $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[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -8.00000000000000038e-181 or 1.6000000000000001e-134 < 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 67.7%

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

   if -8.00000000000000038e-181 < NaChar < 1.6000000000000001e-134

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 74.1%

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

   6. Taylor expanded in NdChar around inf 68.2%

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

4. Final simplification 67.8%

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

Alternative 7: 44.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;NaChar \leq -2.4 \cdot 10^{+243}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq -4 \cdot 10^{-58}:\\ \;\;\;\;\frac{NaChar}{t\_0}\\ \mathbf{elif}\;NaChar \leq 10^{+112}:\\ \;\;\;\;\frac{NdChar}{t\_0}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \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 (<= NaChar -2.4e+243)
     (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
     (if (<= NaChar -4e-58)
       (/ NaChar t_0)
       (if (<= NaChar 1e+112)
         (/ NdChar t_0)
         (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + exp((Vef / KbT));
	double tmp;
	if (NaChar <= -2.4e+243) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (NaChar <= -4e-58) {
		tmp = NaChar / t_0;
	} else if (NaChar <= 1e+112) {
		tmp = NdChar / t_0;
	} else {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = 1.0d0 + exp((vef / kbt))
    if (nachar <= (-2.4d+243)) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (nachar <= (-4d-58)) then
        tmp = nachar / t_0
    else if (nachar <= 1d+112) then
        tmp = ndchar / t_0
    else
        tmp = nachar / (1.0d0 + exp((ev / kbt)))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = 1.0 + Math.exp((Vef / KbT));
	double tmp;
	if (NaChar <= -2.4e+243) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (NaChar <= -4e-58) {
		tmp = NaChar / t_0;
	} else if (NaChar <= 1e+112) {
		tmp = NdChar / t_0;
	} else {
		tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	tmp = 0
	if NaChar <= -2.4e+243:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif NaChar <= -4e-58:
		tmp = NaChar / t_0
	elif NaChar <= 1e+112:
		tmp = NdChar / t_0
	else:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + exp(Float64(Vef / KbT)))
	tmp = 0.0
	if (NaChar <= -2.4e+243)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (NaChar <= -4e-58)
		tmp = Float64(NaChar / t_0);
	elseif (NaChar <= 1e+112)
		tmp = Float64(NdChar / t_0);
	else
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	tmp = 0.0;
	if (NaChar <= -2.4e+243)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (NaChar <= -4e-58)
		tmp = NaChar / t_0;
	elseif (NaChar <= 1e+112)
		tmp = NdChar / t_0;
	else
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	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[NaChar, -2.4e+243], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -4e-58], N[(NaChar / t$95$0), $MachinePrecision], If[LessEqual[NaChar, 1e+112], N[(NdChar / t$95$0), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if NaChar < -2.4e243

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

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

   6. Taylor expanded in EAccept around inf 55.9%

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

   if -2.4e243 < NaChar < -4.0000000000000001e-58

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 77.8%

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

   6. Taylor expanded in Vef around inf 52.9%

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

   if -4.0000000000000001e-58 < NaChar < 9.9999999999999993e111

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 69.6%

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

   6. Taylor expanded in NdChar around inf 56.9%

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

   if 9.9999999999999993e111 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 77.1%

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

   6. Taylor expanded in Ev around inf 54.3%

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

Alternative 8: 40.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.02 \cdot 10^{+211}:\\ \;\;\;\;\frac{NdChar}{2} + \left(-0.25 \cdot \left(Ev \cdot \frac{NaChar}{KbT}\right) + NaChar \cdot 0.5\right)\\ \mathbf{elif}\;KbT \leq -1.75 \cdot 10^{-295}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.8 \cdot 10^{+74}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.02e+211)
   (+ (/ NdChar 2.0) (+ (* -0.25 (* Ev (/ NaChar KbT))) (* NaChar 0.5)))
   (if (<= KbT -1.75e-295)
     (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
     (if (<= KbT 2.8e+74)
       (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
       (* 0.5 (+ NdChar NaChar))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -1.02e+211) {
		tmp = (NdChar / 2.0) + ((-0.25 * (Ev * (NaChar / KbT))) + (NaChar * 0.5));
	} else if (KbT <= -1.75e-295) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if (KbT <= 2.8e+74) {
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	} else {
		tmp = 0.5 * (NdChar + NaChar);
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1.02e+211:
		tmp = (NdChar / 2.0) + ((-0.25 * (Ev * (NaChar / KbT))) + (NaChar * 0.5))
	elif KbT <= -1.75e-295:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif KbT <= 2.8e+74:
		tmp = NaChar / (1.0 + math.exp((Ev / KbT)))
	else:
		tmp = 0.5 * (NdChar + NaChar)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -1.02e+211)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(Float64(-0.25 * Float64(Ev * Float64(NaChar / KbT))) + Float64(NaChar * 0.5)));
	elseif (KbT <= -1.75e-295)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif (KbT <= 2.8e+74)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))));
	else
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -1.02e+211)
		tmp = (NdChar / 2.0) + ((-0.25 * (Ev * (NaChar / KbT))) + (NaChar * 0.5));
	elseif (KbT <= -1.75e-295)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif (KbT <= 2.8e+74)
		tmp = NaChar / (1.0 + exp((Ev / KbT)));
	else
		tmp = 0.5 * (NdChar + NaChar);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.02e+211], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(N[(-0.25 * N[(Ev * N[(NaChar / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -1.75e-295], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.8e+74], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -1.02e211

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 77.6%

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

   6. Taylor expanded in KbT around inf 46.0%

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

   7. Taylor expanded in Ev around inf 54.5%

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

      1. associate-/l* 64.2%

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

   9. Simplified 64.2%

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

   if -1.02e211 < KbT < -1.74999999999999994e-295

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 60.6%

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

   6. Taylor expanded in EAccept around inf 37.2%

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

   if -1.74999999999999994e-295 < KbT < 2.80000000000000002e74

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 60.3%

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

   6. Taylor expanded in Ev around inf 30.9%

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

   if 2.80000000000000002e74 < 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.7%

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

      1. distribute-lft-out 59.7%

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

   7. Simplified 59.7%

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

4. Final simplification 42.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -1.02 \cdot 10^{+211}:\\ \;\;\;\;\frac{NdChar}{2} + \left(-0.25 \cdot \left(Ev \cdot \frac{NaChar}{KbT}\right) + NaChar \cdot 0.5\right)\\ \mathbf{elif}\;KbT \leq -1.75 \cdot 10^{-295}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.8 \cdot 10^{+74}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 43.9% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -3.7 \cdot 10^{-58}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 2.55 \cdot 10^{+112}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -3.7000000000000003e-58

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 76.3%

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

   6. Taylor expanded in EAccept around inf 47.8%

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

   if -3.7000000000000003e-58 < NaChar < 2.55000000000000006e112

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in Vef around inf 69.6%

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

   6. Taylor expanded in NdChar around inf 56.9%

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

   if 2.55000000000000006e112 < NaChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 77.1%

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

   6. Taylor expanded in Ev around inf 54.3%

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

Alternative 10: 43.0% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -2.05 \cdot 10^{-48}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 2.05 \cdot 10^{-66}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -2.05e-48], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.05e-66], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.05000000000000007e-48

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 77.3%

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

   6. Taylor expanded in EAccept around inf 49.4%

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

   if -2.05000000000000007e-48 < NaChar < 2.04999999999999999e-66

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 78.6%

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

   6. Taylor expanded in EDonor around inf 52.8%

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

   if 2.04999999999999999e-66 < 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 67.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.5%

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

Alternative 11: 36.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq -4.2 \cdot 10^{-176}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;EAccept \leq 1.3 \cdot 10^{+100}:\\ \;\;\;\;\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 -4.2e-176)
   (* 0.5 (+ NdChar NaChar))
   (if (<= EAccept 1.3e+100)
     (/ 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 <= -4.2e-176) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (EAccept <= 1.3e+100) {
		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 <= (-4.2d-176)) then
        tmp = 0.5d0 * (ndchar + nachar)
    else if (eaccept <= 1.3d+100) 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 <= -4.2e-176) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (EAccept <= 1.3e+100) {
		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 <= -4.2e-176:
		tmp = 0.5 * (NdChar + NaChar)
	elif EAccept <= 1.3e+100:
		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 <= -4.2e-176)
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	elseif (EAccept <= 1.3e+100)
		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 <= -4.2e-176)
		tmp = 0.5 * (NdChar + NaChar);
	elseif (EAccept <= 1.3e+100)
		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, -4.2e-176], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.3e+100], 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 < -4.19999999999999984e-176

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 38.5%

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

      1. distribute-lft-out 38.5%

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

   7. Simplified 38.5%

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

   if -4.19999999999999984e-176 < EAccept < 1.3000000000000001e100

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

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

   if 1.3000000000000001e100 < 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 58.3%

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

   6. Taylor expanded in EAccept around inf 50.9%

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

4. Final simplification 43.4%

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

Alternative 12: 40.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.7 \cdot 10^{+210}:\\ \;\;\;\;\frac{NdChar}{2} + \left(-0.25 \cdot \left(Ev \cdot \frac{NaChar}{KbT}\right) + NaChar \cdot 0.5\right)\\ \mathbf{elif}\;KbT \leq 2.2 \cdot 10^{+56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -2.7e+210)
   (+ (/ NdChar 2.0) (+ (* -0.25 (* Ev (/ NaChar KbT))) (* NaChar 0.5)))
   (if (<= KbT 2.2e+56)
     (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
     (* 0.5 (+ NdChar NaChar)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.7e+210], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(N[(-0.25 * N[(Ev * N[(NaChar / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.2e+56], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -2.6999999999999999e210

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 77.6%

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

   6. Taylor expanded in KbT around inf 46.0%

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

   7. Taylor expanded in Ev around inf 54.5%

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

      1. associate-/l* 64.2%

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

   9. Simplified 64.2%

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

   if -2.6999999999999999e210 < KbT < 2.20000000000000016e56

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 59.9%

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

   6. Taylor expanded in EAccept around inf 35.4%

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

   if 2.20000000000000016e56 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 57.5%

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

      1. distribute-lft-out 57.5%

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

   7. Simplified 57.5%

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

4. Final simplification 43.3%

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

Alternative 13: 22.9% accurate, 17.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -3.7 \cdot 10^{-94} \lor \neg \left(NaChar \leq 2 \cdot 10^{+110}\right):\\ \;\;\;\;NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -3.7e-94) (not (<= NaChar 2e+110)))
   (* NaChar 0.5)
   (* NdChar 0.5)))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -3.7e-94) || !(NaChar <= 2e+110)) {
		tmp = NaChar * 0.5;
	} else {
		tmp = NdChar * 0.5;
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -3.7e-94) or not (NaChar <= 2e+110):
		tmp = NaChar * 0.5
	else:
		tmp = NdChar * 0.5
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NaChar <= -3.7e-94) || !(NaChar <= 2e+110))
		tmp = Float64(NaChar * 0.5);
	else
		tmp = Float64(NdChar * 0.5);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -3.7e-94) || ~((NaChar <= 2e+110)))
		tmp = NaChar * 0.5;
	else
		tmp = NdChar * 0.5;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -3.7e-94], N[Not[LessEqual[NaChar, 2e+110]], $MachinePrecision]], N[(NaChar * 0.5), $MachinePrecision], N[(NdChar * 0.5), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -3.6999999999999998e-94 or 2e110 < 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 KbT around inf 31.8%

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

      1. distribute-lft-out 31.8%

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

   7. Simplified 31.8%

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

   8. Taylor expanded in NaChar around inf 29.4%

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

      1. *-commutative 29.4%

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

   10. Simplified 29.4%

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

   if -3.6999999999999998e-94 < NaChar < 2e110

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 30.3%

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

      1. distribute-lft-out 30.3%

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

   7. Simplified 30.3%

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

   8. Taylor expanded in NaChar around 0 29.9%

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

4. Final simplification 29.6%

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

Alternative 14: 27.8% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 31.1%

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

   1. distribute-lft-out 31.1%

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

7. Simplified 31.1%

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

8. Final simplification 31.1%

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

Alternative 15: 18.6% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 31.1%

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

   1. distribute-lft-out 31.1%

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

7. Simplified 31.1%

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

8. Taylor expanded in NaChar around 0 19.9%

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

9. Final simplification 19.9%

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

Reproduce

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