Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 28.2s

Alternatives: 23

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
  (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev 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(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - 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(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - 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(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT))));
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

4. Final simplification 100.0%

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

Alternative 2: 73.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;Ev \leq -1.04 \cdot 10^{+111}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -2.3 \cdot 10^{-150} \lor \neg \left(Ev \leq -5.6 \cdot 10^{-260}\right) \land Ev \leq 8.5 \cdot 10^{-199}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= Ev -1.04e+111)
     (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (if (or (<= Ev -2.3e-150) (and (not (<= Ev -5.6e-260)) (<= Ev 8.5e-199)))
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -1.04e+111) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if ((Ev <= -2.3e-150) || (!(Ev <= -5.6e-260) && (Ev <= 8.5e-199))) {
		tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
	} else {
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    if (ev <= (-1.04d+111)) then
        tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
    else if ((ev <= (-2.3d-150)) .or. (.not. (ev <= (-5.6d-260))) .and. (ev <= 8.5d-199)) then
        tmp = t_0 + (nachar / (1.0d0 + exp((-mu / kbt))))
    else
        tmp = t_0 + (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 t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -1.04e+111) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if ((Ev <= -2.3e-150) || (!(Ev <= -5.6e-260) && (Ev <= 8.5e-199))) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	} else {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if Ev <= -1.04e+111:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif (Ev <= -2.3e-150) or (not (Ev <= -5.6e-260) and (Ev <= 8.5e-199)):
		tmp = t_0 + (NaChar / (1.0 + math.exp((-mu / KbT))))
	else:
		tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (Ev <= -1.04e+111)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif ((Ev <= -2.3e-150) || (!(Ev <= -5.6e-260) && (Ev <= 8.5e-199)))
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (Ev <= -1.04e+111)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif ((Ev <= -2.3e-150) || (~((Ev <= -5.6e-260)) && (Ev <= 8.5e-199)))
		tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
	else
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -1.04e+111], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[Ev, -2.3e-150], And[N[Not[LessEqual[Ev, -5.6e-260]], $MachinePrecision], LessEqual[Ev, 8.5e-199]]], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if Ev < -1.04e111

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Ev around inf 84.3%

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

   if -1.04e111 < Ev < -2.30000000000000003e-150 or -5.5999999999999996e-260 < Ev < 8.4999999999999994e-199

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 83.9%

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

      1. associate-*r/ 40.5%

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

      2. mul-1-neg 40.5%

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

   6. Simplified 83.9%

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

   if -2.30000000000000003e-150 < Ev < -5.5999999999999996e-260 or 8.4999999999999994e-199 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 67.5%

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

4. Final simplification 75.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -1.04 \cdot 10^{+111}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;Ev \leq -2.3 \cdot 10^{-150} \lor \neg \left(Ev \leq -5.6 \cdot 10^{-260}\right) \land Ev \leq 8.5 \cdot 10^{-199}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \]

Alternative 3: 74.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{if}\;Vef \leq -3.55 \cdot 10^{+71}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq -8.5 \cdot 10^{-194}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;Vef \leq -5.2 \cdot 10^{-306}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.65 \cdot 10^{+128}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))))
   (if (<= Vef -3.55e+71)
     t_1
     (if (<= Vef -8.5e-194)
       t_0
       (if (<= Vef -5.2e-306)
         (+
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
         (if (<= Vef 1.65e+128) t_0 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	double t_1 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	double tmp;
	if (Vef <= -3.55e+71) {
		tmp = t_1;
	} else if (Vef <= -8.5e-194) {
		tmp = t_0;
	} else if (Vef <= -5.2e-306) {
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (Vef <= 1.65e+128) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    t_1 = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    if (vef <= (-3.55d+71)) then
        tmp = t_1
    else if (vef <= (-8.5d-194)) then
        tmp = t_0
    else if (vef <= (-5.2d-306)) then
        tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    else if (vef <= 1.65d+128) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double t_1 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	double tmp;
	if (Vef <= -3.55e+71) {
		tmp = t_1;
	} else if (Vef <= -8.5e-194) {
		tmp = t_0;
	} else if (Vef <= -5.2e-306) {
		tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else if (Vef <= 1.65e+128) {
		tmp = t_0;
	} 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 + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	t_1 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	tmp = 0
	if Vef <= -3.55e+71:
		tmp = t_1
	elif Vef <= -8.5e-194:
		tmp = t_0
	elif Vef <= -5.2e-306:
		tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif Vef <= 1.65e+128:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))))
	tmp = 0.0
	if (Vef <= -3.55e+71)
		tmp = t_1;
	elseif (Vef <= -8.5e-194)
		tmp = t_0;
	elseif (Vef <= -5.2e-306)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (Vef <= 1.65e+128)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	t_1 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	tmp = 0.0;
	if (Vef <= -3.55e+71)
		tmp = t_1;
	elseif (Vef <= -8.5e-194)
		tmp = t_0;
	elseif (Vef <= -5.2e-306)
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (Vef <= 1.65e+128)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.55e+71], t$95$1, If[LessEqual[Vef, -8.5e-194], t$95$0, If[LessEqual[Vef, -5.2e-306], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.65e+128], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if Vef < -3.54999999999999993e71 or 1.65e128 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 89.9%

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

   5. Taylor expanded in EDonor around 0 88.6%

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

   if -3.54999999999999993e71 < Vef < -8.5000000000000005e-194 or -5.2000000000000001e-306 < Vef < 1.65e128

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 76.6%

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

   if -8.5000000000000005e-194 < Vef < -5.2000000000000001e-306

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 84.7%

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

      1. associate-*r/ 44.8%

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

      2. mul-1-neg 44.8%

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

   6. Simplified 84.7%

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

   7. Taylor expanded in mu around inf 75.1%

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

4. Final simplification 79.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Vef \leq -3.55 \cdot 10^{+71}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;Vef \leq -8.5 \cdot 10^{-194}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;Vef \leq -5.2 \cdot 10^{-306}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;Vef \leq 1.65 \cdot 10^{+128}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 4: 77.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -1.9 \cdot 10^{-10}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -7 \cdot 10^{-249}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 4.8 \cdot 10^{+134}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{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 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -1.9e-10)
     t_1
     (if (<= mu -7e-249)
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
       (if (<= mu 4.8e+134)
         (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev 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 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -1.9e-10) {
		tmp = t_1;
	} else if (mu <= -7e-249) {
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	} else if (mu <= 4.8e+134) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / 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 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-1.9d-10)) then
        tmp = t_1
    else if (mu <= (-7d-249)) then
        tmp = t_0 + (nachar / (1.0d0 + exp((vef / kbt))))
    else if (mu <= 4.8d+134) then
        tmp = t_0 + (nachar / (1.0d0 + exp((ev / 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 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -1.9e-10) {
		tmp = t_1;
	} else if (mu <= -7e-249) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
	} else if (mu <= 4.8e+134) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -1.9e-10:
		tmp = t_1
	elif mu <= -7e-249:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT))))
	elif mu <= 4.8e+134:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -1.9e-10)
		tmp = t_1;
	elseif (mu <= -7e-249)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	elseif (mu <= 4.8e+134)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / 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 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -1.9e-10)
		tmp = t_1;
	elseif (mu <= -7e-249)
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	elseif (mu <= 4.8e+134)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / 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[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.9e-10], t$95$1, If[LessEqual[mu, -7e-249], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 4.8e+134], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if mu < -1.8999999999999999e-10 or 4.80000000000000011e134 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 84.8%

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

   if -1.8999999999999999e-10 < mu < -7.00000000000000025e-249

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 88.7%

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

   if -7.00000000000000025e-249 < mu < 4.80000000000000011e134

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Ev around inf 76.1%

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

4. Final simplification 82.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1.9 \cdot 10^{-10}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;mu \leq -7 \cdot 10^{-249}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;mu \leq 4.8 \cdot 10^{+134}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \]

Alternative 5: 76.4% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -8.8e+73) (not (<= Vef 1.06e+166)))
   (+
    (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
    (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((Vef <= -8.8e+73) || !(Vef <= 1.06e+166)) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((Vef <= -8.8e+73) || ~((Vef <= 1.06e+166)))
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -8.8e73 or 1.06e166 < Vef

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in Vef around inf 92.2%

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

   5. Taylor expanded in EDonor around 0 90.7%

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

   if -8.8e73 < Vef < 1.06e166

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 74.7%

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

4. Final simplification 78.6%

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

Alternative 6: 77.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;mu \leq -95 \lor \neg \left(mu \leq 9 \cdot 10^{+132}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \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 (or (<= mu -95.0) (not (<= mu 9e+132)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) 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 ((mu <= -95.0) || !(mu <= 9e+132)) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (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 ((mu <= (-95.0d0)) .or. (.not. (mu <= 9d+132))) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    else
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (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 ((mu <= -95.0) || !(mu <= 9e+132)) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (mu <= -95.0) or not (mu <= 9e+132):
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	else:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (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 ((mu <= -95.0) || !(mu <= 9e+132))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + 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 ((mu <= -95.0) || ~((mu <= 9e+132)))
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	else
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if mu < -95 or 8.99999999999999944e132 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 85.1%

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

   if -95 < mu < 8.99999999999999944e132

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Ev around inf 75.8%

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

4. Final simplification 79.7%

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

Alternative 7: 60.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{if}\;NdChar \leq -4.1 \cdot 10^{+62}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.15 \cdot 10^{-167}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -4.2 \cdot 10^{-203}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 1.8 \cdot 10^{-56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2 + \frac{EDonor + \left(Vef + \left(mu - Ec\right)\right)}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
   (if (<= NdChar -4.1e+62)
     (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
     (if (<= NdChar -2.15e-167)
       (+
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
        (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
       (if (<= NdChar -4.2e-203)
         (+ t_0 (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
         (if (<= NdChar 1.8e-56)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
            (/ NdChar (+ 2.0 (/ (+ EDonor (+ Vef (- mu Ec))) KbT))))
           (+
            (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
            (/ NaChar (+ (/ EAccept KbT) 2.0)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((-mu / KbT)));
	double tmp;
	if (NdChar <= -4.1e+62) {
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (NdChar <= -2.15e-167) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (NdChar <= -4.2e-203) {
		tmp = t_0 + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (NdChar <= 1.8e-56) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)));
	} else {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((-mu / kbt)))
    if (ndchar <= (-4.1d+62)) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    else if (ndchar <= (-2.15d-167)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (ndchar <= (-4.2d-203)) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (ndchar <= 1.8d-56) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (2.0d0 + ((edonor + (vef + (mu - ec))) / kbt)))
    else
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((-mu / KbT)));
	double tmp;
	if (NdChar <= -4.1e+62) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else if (NdChar <= -2.15e-167) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (NdChar <= -4.2e-203) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (NdChar <= 1.8e-56) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)));
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((-mu / KbT)))
	tmp = 0
	if NdChar <= -4.1e+62:
		tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif NdChar <= -2.15e-167:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif NdChar <= -4.2e-203:
		tmp = t_0 + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif NdChar <= 1.8e-56:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)))
	else:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))
	tmp = 0.0
	if (NdChar <= -4.1e+62)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (NdChar <= -2.15e-167)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (NdChar <= -4.2e-203)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (NdChar <= 1.8e-56)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(Float64(EDonor + Float64(Vef + Float64(mu - Ec))) / KbT))));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((-mu / KbT)));
	tmp = 0.0;
	if (NdChar <= -4.1e+62)
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (NdChar <= -2.15e-167)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (NdChar <= -4.2e-203)
		tmp = t_0 + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (NdChar <= 1.8e-56)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)));
	else
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -4.1e+62], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2.15e-167], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -4.2e-203], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.8e-56], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(N[(EDonor + N[(Vef + N[(mu - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 5 regimes

2. if NdChar < -4.09999999999999984e62

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 83.1%

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

      1. associate-*r/ 24.0%

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

      2. mul-1-neg 24.0%

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

   6. Simplified 83.1%

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

   7. Taylor expanded in mu around inf 63.4%

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

   if -4.09999999999999984e62 < NdChar < -2.1499999999999999e-167

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EDonor around inf 83.7%

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

   5. Taylor expanded in EAccept around inf 69.7%

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

   if -2.1499999999999999e-167 < NdChar < -4.20000000000000004e-203

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 89.8%

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

      1. associate-*r/ 39.1%

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

      2. mul-1-neg 39.1%

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

   6. Simplified 89.8%

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

   7. Taylor expanded in Ec around inf 79.7%

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

      1. associate-*r/ 79.7%

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

      2. mul-1-neg 79.7%

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

   9. Simplified 79.7%

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

   if -4.20000000000000004e-203 < NdChar < 1.79999999999999989e-56

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Step-by-step derivation

      1. add-cube-cbrt 100.0%

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

      2. pow3 100.0%

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

   5. Applied egg-rr 100.0%

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

   6. Taylor expanded in KbT around inf 74.6%

      \[\leadsto \frac{NdChar}{\color{blue}{2 + \left(0.3333333333333333 \cdot \frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT} + 0.6666666666666666 \cdot \frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   7. Step-by-step derivation

      1. distribute-rgt-out 74.6%

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

      2. metadata-eval 74.6%

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

      3. *-rgt-identity 74.6%

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

      4. associate--l+ 74.6%

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

      5. sub-neg 74.6%

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

      6. associate-+r+ 74.6%

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

      7. mul-1-neg 74.6%

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

      8. mul-1-neg 74.6%

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

      9. sub-neg 74.6%

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

   8. Simplified 74.6%

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

   if 1.79999999999999989e-56 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 73.8%

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

   5. Taylor expanded in EAccept around 0 61.9%

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

4. Final simplification 68.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -4.1 \cdot 10^{+62}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.15 \cdot 10^{-167}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -4.2 \cdot 10^{-203}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 1.8 \cdot 10^{-56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2 + \frac{EDonor + \left(Vef + \left(mu - Ec\right)\right)}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \end{array} \]

Alternative 8: 70.2% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= mu -1.15e+146) (not (<= mu 2.6e+187)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
    (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
    (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((mu <= -1.15e+146) || !(mu <= 2.6e+187)) {
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((mu <= -1.15e+146) || ~((mu <= 2.6e+187)))
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if mu < -1.15e146 or 2.5999999999999999e187 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 95.3%

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

      1. associate-*r/ 40.7%

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

      2. mul-1-neg 40.7%

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

   6. Simplified 95.3%

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

   7. Taylor expanded in mu around inf 85.3%

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

   if -1.15e146 < mu < 2.5999999999999999e187

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Vef around inf 74.3%

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

   5. Taylor expanded in EDonor around 0 67.8%

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

4. Final simplification 72.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;mu \leq -1.15 \cdot 10^{+146} \lor \neg \left(mu \leq 2.6 \cdot 10^{+187}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \end{array} \]

Alternative 9: 62.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \mathbf{if}\;NdChar \leq -7 \cdot 10^{+61}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -2.2 \cdot 10^{-174}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.75 \cdot 10^{-220}:\\ \;\;\;\;t_0 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 1.05 \cdot 10^{-56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2 + \frac{EDonor + \left(Vef + \left(mu - Ec\right)\right)}{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 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1 (+ t_0 (/ NaChar (+ (/ EAccept KbT) 2.0)))))
   (if (<= NdChar -7e+61)
     t_1
     (if (<= NdChar -2.2e-174)
       (+
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
        (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
       (if (<= NdChar -2.75e-220)
         (+ t_0 (/ NaChar (- 2.0 (/ mu KbT))))
         (if (<= NdChar 1.05e-56)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
            (/ NdChar (+ 2.0 (/ (+ EDonor (+ Vef (- mu Ec))) 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 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
	double tmp;
	if (NdChar <= -7e+61) {
		tmp = t_1;
	} else if (NdChar <= -2.2e-174) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (NdChar <= -2.75e-220) {
		tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
	} else if (NdChar <= 1.05e-56) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / 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 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = t_0 + (nachar / ((eaccept / kbt) + 2.0d0))
    if (ndchar <= (-7d+61)) then
        tmp = t_1
    else if (ndchar <= (-2.2d-174)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (ndchar <= (-2.75d-220)) then
        tmp = t_0 + (nachar / (2.0d0 - (mu / kbt)))
    else if (ndchar <= 1.05d-56) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (2.0d0 + ((edonor + (vef + (mu - ec))) / 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 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
	double tmp;
	if (NdChar <= -7e+61) {
		tmp = t_1;
	} else if (NdChar <= -2.2e-174) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (NdChar <= -2.75e-220) {
		tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
	} else if (NdChar <= 1.05e-56) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = t_0 + (NaChar / ((EAccept / KbT) + 2.0))
	tmp = 0
	if NdChar <= -7e+61:
		tmp = t_1
	elif NdChar <= -2.2e-174:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif NdChar <= -2.75e-220:
		tmp = t_0 + (NaChar / (2.0 - (mu / KbT)))
	elif NdChar <= 1.05e-56:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(t_0 + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0)))
	tmp = 0.0
	if (NdChar <= -7e+61)
		tmp = t_1;
	elseif (NdChar <= -2.2e-174)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (NdChar <= -2.75e-220)
		tmp = Float64(t_0 + Float64(NaChar / Float64(2.0 - Float64(mu / KbT))));
	elseif (NdChar <= 1.05e-56)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(Float64(EDonor + Float64(Vef + Float64(mu - Ec))) / 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 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
	tmp = 0.0;
	if (NdChar <= -7e+61)
		tmp = t_1;
	elseif (NdChar <= -2.2e-174)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (NdChar <= -2.75e-220)
		tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
	elseif (NdChar <= 1.05e-56)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / 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[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -7e+61], t$95$1, If[LessEqual[NdChar, -2.2e-174], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2.75e-220], N[(t$95$0 + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.05e-56], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(N[(EDonor + N[(Vef + N[(mu - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 4 regimes

2. if NdChar < -7.00000000000000036e61 or 1.05000000000000003e-56 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 76.1%

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

   5. Taylor expanded in EAccept around 0 60.4%

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

   if -7.00000000000000036e61 < NdChar < -2.20000000000000022e-174

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 84.1%

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

   5. Taylor expanded in EAccept around inf 68.7%

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

   if -2.20000000000000022e-174 < NdChar < -2.7499999999999999e-220

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 75.0%

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

      1. associate-*r/ 30.8%

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

      2. mul-1-neg 30.8%

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

   6. Simplified 75.0%

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

   7. Taylor expanded in mu around 0 75.0%

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

      1. mul-1-neg 30.8%

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

      2. unsub-neg 30.8%

         \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{\color{blue}{2 - \frac{mu}{KbT}}} \]

   9. Simplified 75.0%

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

   if -2.7499999999999999e-220 < NdChar < 1.05000000000000003e-56

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Step-by-step derivation

      1. add-cube-cbrt 100.0%

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

      2. pow3 100.0%

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

   5. Applied egg-rr 100.0%

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

   6. Taylor expanded in KbT around inf 74.6%

      \[\leadsto \frac{NdChar}{\color{blue}{2 + \left(0.3333333333333333 \cdot \frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT} + 0.6666666666666666 \cdot \frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   7. Step-by-step derivation

      1. distribute-rgt-out 74.6%

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

      2. metadata-eval 74.6%

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

      3. *-rgt-identity 74.6%

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

      4. associate--l+ 74.6%

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

      5. sub-neg 74.6%

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

      6. associate-+r+ 74.6%

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

      7. mul-1-neg 74.6%

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

      8. mul-1-neg 74.6%

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

      9. sub-neg 74.6%

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

   8. Simplified 74.6%

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

4. Final simplification 66.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -7 \cdot 10^{+61}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \mathbf{elif}\;NdChar \leq -2.2 \cdot 10^{-174}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.75 \cdot 10^{-220}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 1.05 \cdot 10^{-56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2 + \frac{EDonor + \left(Vef + \left(mu - Ec\right)\right)}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \end{array} \]

Alternative 10: 60.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;NdChar \leq -6 \cdot 10^{+61}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -1.4 \cdot 10^{-174}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -4.2 \cdot 10^{-203}:\\ \;\;\;\;t_0 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 1.85 \cdot 10^{-56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2 + \frac{EDonor + \left(Vef + \left(mu - Ec\right)\right)}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= NdChar -6e+61)
     (+
      (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
      (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
     (if (<= NdChar -1.4e-174)
       (+
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
        (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
       (if (<= NdChar -4.2e-203)
         (+ t_0 (/ NaChar (- 2.0 (/ mu KbT))))
         (if (<= NdChar 1.85e-56)
           (+
            (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
            (/ NdChar (+ 2.0 (/ (+ EDonor (+ Vef (- mu Ec))) KbT))))
           (+ t_0 (/ NaChar (+ (/ EAccept KbT) 2.0)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (NdChar <= -6e+61) {
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (NdChar <= -1.4e-174) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (NdChar <= -4.2e-203) {
		tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
	} else if (NdChar <= 1.85e-56) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)));
	} else {
		tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if NdChar <= -6e+61:
		tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif NdChar <= -1.4e-174:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif NdChar <= -4.2e-203:
		tmp = t_0 + (NaChar / (2.0 - (mu / KbT)))
	elif NdChar <= 1.85e-56:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)))
	else:
		tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (NdChar <= -6e+61)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (NdChar <= -1.4e-174)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (NdChar <= -4.2e-203)
		tmp = Float64(t_0 + Float64(NaChar / Float64(2.0 - Float64(mu / KbT))));
	elseif (NdChar <= 1.85e-56)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(Float64(EDonor + Float64(Vef + Float64(mu - Ec))) / KbT))));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (NdChar <= -6e+61)
		tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (NdChar <= -1.4e-174)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (NdChar <= -4.2e-203)
		tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
	elseif (NdChar <= 1.85e-56)
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)));
	else
		tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -6e+61], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -1.4e-174], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -4.2e-203], N[(t$95$0 + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.85e-56], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(N[(EDonor + N[(Vef + N[(mu - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 5 regimes

2. if NdChar < -6e61

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 83.1%

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

      1. associate-*r/ 24.0%

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

      2. mul-1-neg 24.0%

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

   6. Simplified 83.1%

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

   7. Taylor expanded in mu around inf 63.4%

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

   if -6e61 < NdChar < -1.39999999999999999e-174

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 84.1%

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

   5. Taylor expanded in EAccept around inf 68.7%

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

   if -1.39999999999999999e-174 < NdChar < -4.20000000000000004e-203

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in mu around inf 88.4%

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

      1. associate-*r/ 30.4%

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

      2. mul-1-neg 30.4%

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

   6. Simplified 88.4%

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

   7. Taylor expanded in mu around 0 88.4%

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

      1. mul-1-neg 30.4%

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

      2. unsub-neg 30.4%

         \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{\color{blue}{2 - \frac{mu}{KbT}}} \]

   9. Simplified 88.4%

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

   if -4.20000000000000004e-203 < NdChar < 1.8500000000000001e-56

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Step-by-step derivation

      1. add-cube-cbrt 100.0%

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

      2. pow3 100.0%

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

   5. Applied egg-rr 100.0%

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

   6. Taylor expanded in KbT around inf 74.6%

      \[\leadsto \frac{NdChar}{\color{blue}{2 + \left(0.3333333333333333 \cdot \frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT} + 0.6666666666666666 \cdot \frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   7. Step-by-step derivation

      1. distribute-rgt-out 74.6%

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

      2. metadata-eval 74.6%

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

      3. *-rgt-identity 74.6%

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

      4. associate--l+ 74.6%

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

      5. sub-neg 74.6%

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

      6. associate-+r+ 74.6%

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

      7. mul-1-neg 74.6%

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

      8. mul-1-neg 74.6%

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

      9. sub-neg 74.6%

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

   8. Simplified 74.6%

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

   if 1.8500000000000001e-56 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 73.8%

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

   5. Taylor expanded in EAccept around 0 61.9%

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

4. Final simplification 68.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NdChar \leq -6 \cdot 10^{+61}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -1.4 \cdot 10^{-174}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -4.2 \cdot 10^{-203}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 1.85 \cdot 10^{-56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2 + \frac{EDonor + \left(Vef + \left(mu - Ec\right)\right)}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \end{array} \]

Alternative 11: 65.9% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -1.4e-65) (not (<= NdChar 1.25e-56)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
    (/ NaChar (+ (/ EAccept KbT) 2.0)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar (+ 2.0 (/ (+ EDonor (+ Vef (- mu 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 ((NdChar <= -1.4e-65) || !(NdChar <= 1.25e-56)) {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - 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 ((ndchar <= (-1.4d-65)) .or. (.not. (ndchar <= 1.25d-56))) then
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (2.0d0 + ((edonor + (vef + (mu - 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 ((NdChar <= -1.4e-65) || !(NdChar <= 1.25e-56)) {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (2.0 + ((EDonor + (Vef + (mu - Ec))) / KbT)));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -1.4e-65 or 1.24999999999999999e-56 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 76.0%

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

   5. Taylor expanded in EAccept around 0 59.7%

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

   if -1.4e-65 < NdChar < 1.24999999999999999e-56

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]
   4. Step-by-step derivation

      1. add-cube-cbrt 100.0%

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

      2. pow3 100.0%

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

   5. Applied egg-rr 100.0%

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

   6. Taylor expanded in KbT around inf 72.0%

      \[\leadsto \frac{NdChar}{\color{blue}{2 + \left(0.3333333333333333 \cdot \frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT} + 0.6666666666666666 \cdot \frac{\left(EDonor + \left(Vef + mu\right)\right) - Ec}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \]
   7. Step-by-step derivation

      1. distribute-rgt-out 72.0%

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

      2. metadata-eval 72.0%

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

      3. *-rgt-identity 72.0%

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

      4. associate--l+ 72.0%

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

      5. sub-neg 72.0%

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

      6. associate-+r+ 72.0%

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

      7. mul-1-neg 72.0%

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

      8. mul-1-neg 72.0%

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

      9. sub-neg 72.0%

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

   8. Simplified 72.0%

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

4. Final simplification 64.9%

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

Alternative 12: 60.5% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -3.8) (not (<= NaChar 3.05e-24)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar 2.0))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
    (/ NaChar (+ (/ EAccept KbT) 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -3.7999999999999998 or 3.05000000000000018e-24 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 53.6%

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

   if -3.7999999999999998 < NaChar < 3.05000000000000018e-24

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 70.7%

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

   5. Taylor expanded in EAccept around 0 67.6%

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

4. Final simplification 60.4%

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

Alternative 13: 60.0% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -0.0060000000000000001 or 1.25000000000000001e-42 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 53.1%

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

   if -0.0060000000000000001 < NaChar < 1.25000000000000001e-42

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in Ev around inf 80.0%

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

   5. Taylor expanded in Ev around 0 68.1%

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

      1. +-commutative 68.1%

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

   7. Simplified 68.1%

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

4. Final simplification 60.1%

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

Alternative 14: 63.0% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -2.6e-68) (not (<= NdChar 1e-61)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
    (/ NaChar (+ (/ EAccept KbT) 2.0)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar (+ (/ EDonor KbT) 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -2.5999999999999998e-68 or 1e-61 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in EAccept around inf 75.7%

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

   5. Taylor expanded in EAccept around 0 59.6%

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

   if -2.5999999999999998e-68 < NdChar < 1e-61

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 70.7%

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

   5. Taylor expanded in EDonor around 0 66.4%

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

4. Final simplification 62.4%

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

Alternative 15: 50.2% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.2e-188) (not (<= NaChar 2.55e-25)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar 2.0))
   (+
    (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
    (/ NaChar (+ (/ EAccept KbT) 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.2e-188 or 2.5500000000000001e-25 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 49.1%

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

   if -1.2e-188 < NaChar < 2.5500000000000001e-25

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 74.6%

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

   5. Taylor expanded in EAccept around 0 74.5%

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

   6. Taylor expanded in EDonor around inf 57.2%

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

4. Final simplification 51.7%

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

Alternative 16: 56.7% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -0.031) (not (<= NaChar 2.3e+38)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar 2.0))
   (+
    (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
    (/ NaChar 2.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -0.031 or 2.3000000000000001e38 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 54.6%

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

   if -0.031 < NaChar < 2.3000000000000001e38

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in mu around inf 83.8%

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

      1. associate-*r/ 36.0%

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

      2. mul-1-neg 36.0%

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

   6. Simplified 83.8%

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

   7. Taylor expanded in mu around 0 60.3%

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

4. Final simplification 57.7%

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

Alternative 17: 42.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.5 \cdot 10^{-22} \lor \neg \left(NaChar \leq 2.5 \cdot 10^{-25}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.5e-22) (not (<= NaChar 2.5e-25)))
   (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar (+ (/ mu KbT) 2.0)))
   (+
    (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
    (/ NaChar (+ (/ EAccept KbT) 2.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.5e-22], N[Not[LessEqual[NaChar, 2.5e-25]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if NaChar < -1.5e-22 or 2.49999999999999981e-25 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 65.0%

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

   5. Taylor expanded in mu around inf 44.3%

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

   6. Taylor expanded in mu around 0 40.1%

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

      1. +-commutative 40.1%

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

   8. Simplified 40.1%

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

   if -1.5e-22 < NaChar < 2.49999999999999981e-25

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 70.1%

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

   5. Taylor expanded in EAccept around 0 67.6%

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

   6. Taylor expanded in EDonor around inf 48.8%

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

4. Final simplification 44.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -1.5 \cdot 10^{-22} \lor \neg \left(NaChar \leq 2.5 \cdot 10^{-25}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{\frac{mu}{KbT} + 2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\ \end{array} \]

Alternative 18: 41.3% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -1.1e48

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 50.4%

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

   5. Taylor expanded in Vef around inf 39.0%

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

   if -1.1e48 < NaChar < 7.0000000000000004e-25

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EAccept around inf 71.5%

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

   5. Taylor expanded in EAccept around 0 65.0%

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

   6. Taylor expanded in EDonor around inf 47.2%

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

   if 7.0000000000000004e-25 < 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 55.2%

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

   5. Taylor expanded in EAccept around inf 36.1%

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

4. Final simplification 42.5%

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

Alternative 19: 39.0% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -2.35e+48)
   (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (/ NdChar 2.0))
   (if (<= NaChar 4.4e+49)
     (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 0.5))
     (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NaChar <= -2.35e+48) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	} else if (NaChar <= 4.4e+49) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NaChar <= -2.35e+48)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	elseif (NaChar <= 4.4e+49)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if NaChar < -2.35000000000000006e48

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 50.4%

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

   5. Taylor expanded in Vef around inf 39.0%

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

   if -2.35000000000000006e48 < NaChar < 4.4000000000000001e49

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in EDonor around inf 66.1%

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

   5. Taylor expanded in KbT around inf 43.7%

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

   if 4.4000000000000001e49 < NaChar

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 56.7%

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

   5. Taylor expanded in EAccept around inf 37.5%

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

4. Final simplification 41.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -2.35 \cdot 10^{+48}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;NaChar \leq 4.4 \cdot 10^{+49}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 20: 36.9% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -5500000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -5.5e6

   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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

   4. Taylor expanded in KbT around inf 43.1%

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

   5. Taylor expanded in Ev around inf 36.7%

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

   if -5.5e6 < Ev

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in KbT around inf 47.2%

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

   5. Taylor expanded in EAccept around inf 36.1%

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

4. Final simplification 36.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -5500000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \]

Alternative 21: 35.5% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

4. Taylor expanded in KbT around inf 46.3%

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

5. Taylor expanded in EAccept around inf 35.6%

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

6. Final simplification 35.6%

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

Alternative 22: 27.6% 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

4. Taylor expanded in KbT around inf 46.3%

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

5. Taylor expanded in mu around inf 36.8%

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

   1. associate-*r/ 36.8%

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

   2. mul-1-neg 36.8%

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

7. Simplified 36.8%

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

8. Taylor expanded in mu around 0 27.0%

   \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{\color{blue}{2 + -1 \cdot \frac{mu}{KbT}}} \]
9. Step-by-step derivation

   1. mul-1-neg 27.0%

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

   2. unsub-neg 27.0%

      \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{\color{blue}{2 - \frac{mu}{KbT}}} \]

10. Simplified 27.0%

    \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{\color{blue}{2 - \frac{mu}{KbT}}} \]

11. Taylor expanded in mu around 0 28.5%

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

    1. distribute-lft-out 28.5%

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

13. Simplified 28.5%

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

14. Final simplification 28.5%

    \[\leadsto 0.5 \cdot \left(NdChar + NaChar\right) \]

Alternative 23: 18.5% 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{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}} \]

4. Taylor expanded in KbT around inf 46.3%

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

5. Taylor expanded in mu around inf 36.8%

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

   1. associate-*r/ 36.8%

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

   2. mul-1-neg 36.8%

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

7. Simplified 36.8%

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

8. Taylor expanded in mu around 0 27.0%

   \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{\color{blue}{2 + -1 \cdot \frac{mu}{KbT}}} \]
9. Step-by-step derivation

   1. mul-1-neg 27.0%

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

   2. unsub-neg 27.0%

      \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{\color{blue}{2 - \frac{mu}{KbT}}} \]

10. Simplified 27.0%

    \[\leadsto \frac{NdChar}{2} + \frac{NaChar}{\color{blue}{2 - \frac{mu}{KbT}}} \]

11. Taylor expanded in NdChar around inf 18.8%

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

12. Final simplification 18.8%

    \[\leadsto NdChar \cdot 0.5 \]

Reproduce

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