Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 21.2s

Alternatives: 14

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -6.758934001644053e+41
  2. Ec = -3.933238538563548e-211
  3. Vef = 4.5957171737107014e+163
  4. EDonor = -1.7160130094166495e+183
  5. mu = 1.8041619464457133e-279
  6. KbT = 8.380780543598958e+73
  7. NaChar = -6.817083025198011e+41
  8. Ev = -1.6504762322024825e+295
  9. EAccept = 7.652042915879465e-128

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar * (1.0 / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0))) + (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.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 = (ndchar * (1.0d0 / (exp(((edonor + (mu + (vef - ec))) / kbt)) + 1.0d0))) + (nachar / (exp(((vef + (ev + (eaccept - mu))) / kbt)) + 1.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 (NdChar * (1.0 / (Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0))) + (NaChar / (Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

   1. div-inv 100.0%

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

6. Applied egg-rr 100.0%

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

7. Final simplification 100.0%

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

Alternative 2: 78.1% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1\\ t_1 := \frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ t_2 := \frac{NdChar}{e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}} + 1} + t\_1\\ t_3 := \frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ \mathbf{if}\;t\_2 \leq -1 \cdot 10^{-179}:\\ \;\;\;\;NdChar \cdot \frac{1}{t\_0} + t\_3\\ \mathbf{elif}\;t\_2 \leq 10^{-267}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_2 \leq 4 \cdot 10^{+232}:\\ \;\;\;\;\frac{NdChar}{t\_0} + t\_3\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (exp (/ (+ EDonor (+ mu (- Vef Ec))) KbT)) 1.0))
        (t_1 (/ NaChar (+ (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)) 1.0)))
        (t_2
         (+ (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0)) t_1))
        (t_3 (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))))
   (if (<= t_2 -1e-179)
     (+ (* NdChar (/ 1.0 t_0)) t_3)
     (if (<= t_2 1e-267)
       t_1
       (if (<= t_2 4e+232)
         (+ (/ NdChar t_0) t_3)
         (+
          (/ NaChar (+ (exp (/ (+ Vef (+ Ev (- EAccept mu))) KbT)) 1.0))
          (/ 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 t_0 = exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0;
	double t_1 = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	double t_2 = (NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + t_1;
	double t_3 = NaChar / (exp((EAccept / KbT)) + 1.0);
	double tmp;
	if (t_2 <= -1e-179) {
		tmp = (NdChar * (1.0 / t_0)) + t_3;
	} else if (t_2 <= 1e-267) {
		tmp = t_1;
	} else if (t_2 <= 4e+232) {
		tmp = (NdChar / t_0) + t_3;
	} else {
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (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) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = exp(((edonor + (mu + (vef - ec))) / kbt)) + 1.0d0
    t_1 = nachar / (exp((((eaccept + (vef + ev)) - mu) / kbt)) + 1.0d0)
    t_2 = (ndchar / (exp(((mu + (edonor + (vef - ec))) / kbt)) + 1.0d0)) + t_1
    t_3 = nachar / (exp((eaccept / kbt)) + 1.0d0)
    if (t_2 <= (-1d-179)) then
        tmp = (ndchar * (1.0d0 / t_0)) + t_3
    else if (t_2 <= 1d-267) then
        tmp = t_1
    else if (t_2 <= 4d+232) then
        tmp = (ndchar / t_0) + t_3
    else
        tmp = (nachar / (exp(((vef + (ev + (eaccept - mu))) / kbt)) + 1.0d0)) + (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 t_0 = Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0;
	double t_1 = NaChar / (Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	double t_2 = (NdChar / (Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + t_1;
	double t_3 = NaChar / (Math.exp((EAccept / KbT)) + 1.0);
	double tmp;
	if (t_2 <= -1e-179) {
		tmp = (NdChar * (1.0 / t_0)) + t_3;
	} else if (t_2 <= 1e-267) {
		tmp = t_1;
	} else if (t_2 <= 4e+232) {
		tmp = (NdChar / t_0) + t_3;
	} else {
		tmp = (NaChar / (Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0
	t_1 = NaChar / (math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0)
	t_2 = (NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + t_1
	t_3 = NaChar / (math.exp((EAccept / KbT)) + 1.0)
	tmp = 0
	if t_2 <= -1e-179:
		tmp = (NdChar * (1.0 / t_0)) + t_3
	elif t_2 <= 1e-267:
		tmp = t_1
	elif t_2 <= 4e+232:
		tmp = (NdChar / t_0) + t_3
	else:
		tmp = (NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0)
	t_1 = Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)) + 1.0))
	t_2 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0)) + t_1)
	t_3 = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0))
	tmp = 0.0
	if (t_2 <= -1e-179)
		tmp = Float64(Float64(NdChar * Float64(1.0 / t_0)) + t_3);
	elseif (t_2 <= 1e-267)
		tmp = t_1;
	elseif (t_2 <= 4e+232)
		tmp = Float64(Float64(NdChar / t_0) + t_3);
	else
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0)) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0;
	t_1 = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	t_2 = (NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + t_1;
	t_3 = NaChar / (exp((EAccept / KbT)) + 1.0);
	tmp = 0.0;
	if (t_2 <= -1e-179)
		tmp = (NdChar * (1.0 / t_0)) + t_3;
	elseif (t_2 <= 1e-267)
		tmp = t_1;
	elseif (t_2 <= 4e+232)
		tmp = (NdChar / t_0) + t_3;
	else
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-179], N[(N[(NdChar * N[(1.0 / t$95$0), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision], If[LessEqual[t$95$2, 1e-267], t$95$1, If[LessEqual[t$95$2, 4e+232], N[(N[(NdChar / t$95$0), $MachinePrecision] + t$95$3), $MachinePrecision], N[(N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1e-179

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. div-inv 100.0%

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

   6. Applied egg-rr 100.0%

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

   7. Taylor expanded in EAccept around inf 79.4%

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

   if -1e-179 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 9.9999999999999998e-268

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 93.4%

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

   if 9.9999999999999998e-268 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 4.00000000000000023e232

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 67.5%

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

   if 4.00000000000000023e232 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 95.6%

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

4. Final simplification 80.9%

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

Alternative 3: 78.1% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{EDonor + \left(mu + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1}\\ t_1 := \frac{NaChar}{e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}} + 1}\\ t_2 := \frac{NdChar}{e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}} + 1} + t\_1\\ \mathbf{if}\;t\_2 \leq -1 \cdot 10^{-179}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_2 \leq 10^{-267}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_2 \leq 4 \cdot 10^{+232}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(Ev + \left(EAccept - mu\right)\right)}{KbT}} + 1} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (math.exp((EAccept / KbT)) + 1.0))
	t_1 = NaChar / (math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0)
	t_2 = (NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + t_1
	tmp = 0
	if t_2 <= -1e-179:
		tmp = t_0
	elif t_2 <= 1e-267:
		tmp = t_1
	elif t_2 <= 4e+232:
		tmp = t_0
	else:
		tmp = (NaChar / (math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(EDonor + Float64(mu + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)))
	t_1 = Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)) + 1.0))
	t_2 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0)) + t_1)
	tmp = 0.0
	if (t_2 <= -1e-179)
		tmp = t_0;
	elseif (t_2 <= 1e-267)
		tmp = t_1;
	elseif (t_2 <= 4e+232)
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(Ev + Float64(EAccept - mu))) / KbT)) + 1.0)) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp((EAccept / KbT)) + 1.0));
	t_1 = NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0);
	t_2 = (NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + t_1;
	tmp = 0.0;
	if (t_2 <= -1e-179)
		tmp = t_0;
	elseif (t_2 <= 1e-267)
		tmp = t_1;
	elseif (t_2 <= 4e+232)
		tmp = t_0;
	else
		tmp = (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(N[Exp[N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-179], t$95$0, If[LessEqual[t$95$2, 1e-267], t$95$1, If[LessEqual[t$95$2, 4e+232], t$95$0, N[(N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(Ev + N[(EAccept - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 3 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1e-179 or 9.9999999999999998e-268 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 4.00000000000000023e232

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in EAccept around inf 74.0%

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

   if -1e-179 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 9.9999999999999998e-268

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 93.4%

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

   if 4.00000000000000023e232 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 95.6%

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

4. Final simplification 80.9%

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

Alternative 4: 47.1% accurate, 0.4× speedup

Math

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

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -500 or 1.99999999999999992e-291 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

      1. clear-num 99.8%

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

      2. inv-pow 99.9%

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

   6. Applied egg-rr 99.9%

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

      1. unpow-1 99.8%

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

   8. Simplified 99.8%

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

   9. Taylor expanded in KbT around inf 64.4%

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

   10. Taylor expanded in EAccept around inf 49.6%

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

   if -500 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 1.99999999999999992e-291

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 78.7%

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

   6. Taylor expanded in Vef around inf 54.2%

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

4. Final simplification 51.5%

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

Alternative 5: 36.2% accurate, 0.5× speedup

Math

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

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0))
	tmp = 0
	if (t_0 <= -2e-206) or not (t_0 <= 1e-270):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)) + 1.0)))
	tmp = 0.0
	if ((t_0 <= -2e-206) || !(t_0 <= 1e-270))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(Vef / KbT) + Float64(mu / KbT)))) - Float64(Ec / KbT)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0));
	tmp = 0.0;
	if ((t_0 <= -2e-206) || ~((t_0 <= 1e-270)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NdChar / ((2.0 + ((EDonor / KbT) + ((Vef / KbT) + (mu / KbT)))) - (Ec / KbT));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$0, -2e-206], N[Not[LessEqual[t$95$0, 1e-270]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -2.00000000000000006e-206 or 1e-270 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 36.0%

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

      1. distribute-lft-out 36.0%

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

   7. Simplified 36.0%

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

   if -2.00000000000000006e-206 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 1e-270

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 88.6%

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

   6. Taylor expanded in KbT around inf 42.1%

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

4. Final simplification 37.5%

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

Alternative 6: 32.5% accurate, 0.5× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0))
          (/ NaChar (+ (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)) 1.0)))))
   (if (or (<= t_0 -5e-135) (not (<= t_0 1e-270)))
     (* 0.5 (+ NdChar NaChar))
     (/ NdChar (+ 2.0 (/ EDonor 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 / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0));
	double tmp;
	if ((t_0 <= -5e-135) || !(t_0 <= 1e-270)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NdChar / (2.0 + (EDonor / KbT));
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0))
	tmp = 0
	if (t_0 <= -5e-135) or not (t_0 <= 1e-270):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NdChar / (2.0 + (EDonor / KbT))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)) + 1.0)))
	tmp = 0.0
	if ((t_0 <= -5e-135) || !(t_0 <= 1e-270))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NdChar / Float64(2.0 + Float64(EDonor / KbT)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / (exp((((EAccept + (Vef + Ev)) - mu) / KbT)) + 1.0));
	tmp = 0.0;
	if ((t_0 <= -5e-135) || ~((t_0 <= 1e-270)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NdChar / (2.0 + (EDonor / KbT));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$0, -5e-135], N[Not[LessEqual[t$95$0, 1e-270]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(2.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -5.0000000000000002e-135 or 1e-270 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT)))))

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 37.7%

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

      1. distribute-lft-out 37.7%

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

   7. Simplified 37.7%

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

   if -5.0000000000000002e-135 < (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < 1e-270

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 81.9%

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

   6. Taylor expanded in EDonor around inf 37.2%

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

   7. Taylor expanded in EDonor around 0 24.5%

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

4. Final simplification 33.7%

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

Alternative 7: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NaChar / (exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / (exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.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 / (exp(((vef + (ev + (eaccept - mu))) / kbt)) + 1.0d0)) + (ndchar / (exp(((edonor + (mu + (vef - ec))) / kbt)) + 1.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 / (Math.exp(((Vef + (Ev + (EAccept - mu))) / KbT)) + 1.0)) + (NdChar / (Math.exp(((EDonor + (mu + (Vef - Ec))) / KbT)) + 1.0));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Final simplification 100.0%

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

Alternative 8: 66.0% accurate, 1.9× speedup

Math

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

FPCore

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -1.19999999999999999e-159 or 3.1e179 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 73.7%

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

   if -1.19999999999999999e-159 < NdChar < 3.1e179

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 77.1%

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

4. Final simplification 75.4%

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

Alternative 9: 63.1% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -5.5e+255)
   (+
    (/
     NdChar
     (- (+ 2.0 (+ (/ EDonor KbT) (+ (/ Vef KbT) (/ mu KbT)))) (/ Ec KbT)))
    (+ (* -0.25 (/ (* NaChar EAccept) KbT)) (* NaChar 0.5)))
   (if (<= KbT 1.65e+218)
     (/ NaChar (+ (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT)) 1.0))
     (* 0.5 (+ NdChar NaChar)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -5.4999999999999998e255

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 80.0%

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

   6. Taylor expanded in EAccept around inf 96.0%

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

   7. Taylor expanded in KbT around inf 90.9%

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

   if -5.4999999999999998e255 < KbT < 1.64999999999999999e218

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around 0 67.0%

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

   if 1.64999999999999999e218 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 79.1%

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

      1. distribute-lft-out 79.1%

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

   7. Simplified 79.1%

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

4. Final simplification 69.2%

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

Alternative 10: 40.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2 \cdot 10^{+40} \lor \neg \left(KbT \leq 5.5 \cdot 10^{+58}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -2e+40) (not (<= KbT 5.5e+58)))
   (* 0.5 (+ NdChar NaChar))
   (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -2e+40], N[Not[LessEqual[KbT, 5.5e+58]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if KbT < -2.00000000000000006e40 or 5.4999999999999999e58 < KbT

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 51.2%

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

      1. distribute-lft-out 51.2%

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

   7. Simplified 51.2%

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

   if -2.00000000000000006e40 < KbT < 5.4999999999999999e58

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 68.3%

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

   6. Taylor expanded in EDonor around inf 35.9%

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

4. Final simplification 42.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -2 \cdot 10^{+40} \lor \neg \left(KbT \leq 5.5 \cdot 10^{+58}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 42.1% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -5.8 \cdot 10^{+98}:\\ \;\;\;\;\frac{NdChar}{2} + \left(NaChar \cdot 0.5 + -0.25 \cdot \left(NaChar \cdot \frac{Vef}{KbT}\right)\right)\\ \mathbf{elif}\;KbT \leq 1.3 \cdot 10^{+59}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -5.8e+98)
   (+ (/ NdChar 2.0) (+ (* NaChar 0.5) (* -0.25 (* NaChar (/ Vef KbT)))))
   (if (<= KbT 1.3e+59)
     (/ NdChar (+ (exp (/ Vef KbT)) 1.0))
     (* 0.5 (+ NdChar NaChar)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -5.8e+98], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(N[(NaChar * 0.5), $MachinePrecision] + N[(-0.25 * N[(NaChar * N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.3e+59], N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -5.8000000000000002e98

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in KbT around inf 59.0%

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

   6. Taylor expanded in KbT around inf 45.7%

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

   7. Taylor expanded in Vef around inf 53.8%

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

      1. associate-/l* 56.7%

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

   9. Simplified 56.7%

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

   if -5.8000000000000002e98 < KbT < 1.3e59

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 66.8%

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

   6. Taylor expanded in Vef around inf 43.5%

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

   if 1.3e59 < KbT

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 52.3%

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

      1. distribute-lft-out 52.3%

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

   7. Simplified 52.3%

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

4. Final simplification 47.6%

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

Alternative 12: 21.2% accurate, 17.6× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NdChar < -8.8e-159 or 1.90000000000000012e156 < NdChar

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in NdChar around inf 72.8%

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

   6. Taylor expanded in KbT around inf 24.6%

      \[\leadsto \frac{NdChar}{\color{blue}{2}} \]

   if -8.8e-159 < NdChar < 1.90000000000000012e156

   1. Initial program 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in KbT around inf 26.6%

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

      1. distribute-lft-out 26.6%

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

   7. Simplified 26.6%

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

   8. Taylor expanded in NaChar around inf 25.4%

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

      1. *-commutative 25.4%

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

   10. Simplified 25.4%

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

4. Final simplification 25.0%

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

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

5. Taylor expanded in KbT around inf 27.7%

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

   1. distribute-lft-out 27.7%

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

7. Simplified 27.7%

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

8. Final simplification 27.7%

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

Alternative 14: 18.9% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in KbT around inf 27.7%

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

   1. distribute-lft-out 27.7%

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

7. Simplified 27.7%

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

8. Taylor expanded in NaChar around inf 18.4%

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

   1. *-commutative 18.4%

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

10. Simplified 18.4%

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

Reproduce

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