Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 14.3s

Alternatives: 23

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = 7.125131302972887e+181
  2. Ec = 8.549425413399559e-202
  3. Vef = -1.2375079612902884e-193
  4. EDonor = -1.5658871979905438e+125
  5. mu = -3.8150580156612395e-279
  6. KbT = 1.1065729771806447e+58
  7. NaChar = 5.671145776154131e+180
  8. Ev = -1.4575662012797504e+205
  9. EAccept = 1.8106128397129204e-277

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Final simplification 100.0%

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

Alternative 2: 68.1% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}}\\ t_1 := \frac{NaChar}{\frac{\left(\left(\left(KbT + Vef\right) + Ev\right) + EAccept\right) - mu}{KbT} - -1} - t\_0\\ t_2 := e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}\\ t_3 := \frac{NaChar}{t\_2 - -1}\\ t_4 := t\_3 - t\_0\\ \mathbf{if}\;t\_4 \leq -5 \cdot 10^{+173}:\\ \;\;\;\;0.5 \cdot NdChar - \frac{NaChar}{-1 - t\_2}\\ \mathbf{elif}\;t\_4 \leq -5 \cdot 10^{-281}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_4 \leq 5 \cdot 10^{-143}:\\ \;\;\;\;t\_3\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))
        (t_1
         (-
          (/ NaChar (- (/ (- (+ (+ (+ KbT Vef) Ev) EAccept) mu) KbT) -1.0))
          t_0))
        (t_2 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)))
        (t_3 (/ NaChar (- t_2 -1.0)))
        (t_4 (- t_3 t_0)))
   (if (<= t_4 -5e+173)
     (- (* 0.5 NdChar) (/ NaChar (- -1.0 t_2)))
     (if (<= t_4 -5e-281) t_1 (if (<= t_4 5e-143) t_3 t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	double t_1 = (NaChar / ((((((KbT + Vef) + Ev) + EAccept) - mu) / KbT) - -1.0)) - t_0;
	double t_2 = exp((((EAccept + (Ev + Vef)) - mu) / KbT));
	double t_3 = NaChar / (t_2 - -1.0);
	double t_4 = t_3 - t_0;
	double tmp;
	if (t_4 <= -5e+173) {
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_2));
	} else if (t_4 <= -5e-281) {
		tmp = t_1;
	} else if (t_4 <= 5e-143) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_0 = ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt)))
    t_1 = (nachar / ((((((kbt + vef) + ev) + eaccept) - mu) / kbt) - (-1.0d0))) - t_0
    t_2 = exp((((eaccept + (ev + vef)) - mu) / kbt))
    t_3 = nachar / (t_2 - (-1.0d0))
    t_4 = t_3 - t_0
    if (t_4 <= (-5d+173)) then
        tmp = (0.5d0 * ndchar) - (nachar / ((-1.0d0) - t_2))
    else if (t_4 <= (-5d-281)) then
        tmp = t_1
    else if (t_4 <= 5d-143) then
        tmp = t_3
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	double t_1 = (NaChar / ((((((KbT + Vef) + Ev) + EAccept) - mu) / KbT) - -1.0)) - t_0;
	double t_2 = Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT));
	double t_3 = NaChar / (t_2 - -1.0);
	double t_4 = t_3 - t_0;
	double tmp;
	if (t_4 <= -5e+173) {
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_2));
	} else if (t_4 <= -5e-281) {
		tmp = t_1;
	} else if (t_4 <= 5e-143) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)))
	t_1 = (NaChar / ((((((KbT + Vef) + Ev) + EAccept) - mu) / KbT) - -1.0)) - t_0
	t_2 = math.exp((((EAccept + (Ev + Vef)) - mu) / KbT))
	t_3 = NaChar / (t_2 - -1.0)
	t_4 = t_3 - t_0
	tmp = 0
	if t_4 <= -5e+173:
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_2))
	elif t_4 <= -5e-281:
		tmp = t_1
	elif t_4 <= 5e-143:
		tmp = t_3
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(Float64(Float64(Float64(Float64(Float64(KbT + Vef) + Ev) + EAccept) - mu) / KbT) - -1.0)) - t_0)
	t_2 = exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))
	t_3 = Float64(NaChar / Float64(t_2 - -1.0))
	t_4 = Float64(t_3 - t_0)
	tmp = 0.0
	if (t_4 <= -5e+173)
		tmp = Float64(Float64(0.5 * NdChar) - Float64(NaChar / Float64(-1.0 - t_2)));
	elseif (t_4 <= -5e-281)
		tmp = t_1;
	elseif (t_4 <= 5e-143)
		tmp = t_3;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	t_1 = (NaChar / ((((((KbT + Vef) + Ev) + EAccept) - mu) / KbT) - -1.0)) - t_0;
	t_2 = exp((((EAccept + (Ev + Vef)) - mu) / KbT));
	t_3 = NaChar / (t_2 - -1.0);
	t_4 = t_3 - t_0;
	tmp = 0.0;
	if (t_4 <= -5e+173)
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_2));
	elseif (t_4 <= -5e-281)
		tmp = t_1;
	elseif (t_4 <= 5e-143)
		tmp = t_3;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

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))))) < -5.00000000000000034e173

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 85.9

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

   5. Applied rewrites 85.9%

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

   if -5.00000000000000034e173 < (+.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.9999999999999998e-281 or 5.0000000000000002e-143 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower--.f64 N/A

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

      2. associate-+r+ N/A

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

      3. lower-+.f64 N/A

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

      4. lower-+.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. +-commutative N/A

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

      7. lower-+.f64 N/A

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

      8. lower-/.f64 N/A

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

      9. lower-/.f64 N/A

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

      10. lower-/.f64 56.7

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

   5. Applied rewrites 56.7%

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

   6. Taylor expanded in KbT around 0

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

   8. Applied rewrites 64.5%

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

   if -4.9999999999999998e-281 < (+.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-143

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 91.6

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

   5. Applied rewrites 91.6%

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

4. Final simplification 74.7%

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

Alternative 3: 67.8% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))
        (t_1 (- (* 0.5 NaChar) t_0))
        (t_2 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)))
        (t_3 (/ NaChar (- t_2 -1.0)))
        (t_4 (- t_3 t_0)))
   (if (<= t_4 -2e+144)
     (- (* 0.5 NdChar) (/ NaChar (- -1.0 t_2)))
     (if (<= t_4 -4e-148) t_1 (if (<= t_4 1e-137) t_3 t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	double t_1 = (0.5 * NaChar) - t_0;
	double t_2 = exp((((EAccept + (Ev + Vef)) - mu) / KbT));
	double t_3 = NaChar / (t_2 - -1.0);
	double t_4 = t_3 - t_0;
	double tmp;
	if (t_4 <= -2e+144) {
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_2));
	} else if (t_4 <= -4e-148) {
		tmp = t_1;
	} else if (t_4 <= 1e-137) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_0 = ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt)))
    t_1 = (0.5d0 * nachar) - t_0
    t_2 = exp((((eaccept + (ev + vef)) - mu) / kbt))
    t_3 = nachar / (t_2 - (-1.0d0))
    t_4 = t_3 - t_0
    if (t_4 <= (-2d+144)) then
        tmp = (0.5d0 * ndchar) - (nachar / ((-1.0d0) - t_2))
    else if (t_4 <= (-4d-148)) then
        tmp = t_1
    else if (t_4 <= 1d-137) then
        tmp = t_3
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	double t_1 = (0.5 * NaChar) - t_0;
	double t_2 = Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT));
	double t_3 = NaChar / (t_2 - -1.0);
	double t_4 = t_3 - t_0;
	double tmp;
	if (t_4 <= -2e+144) {
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_2));
	} else if (t_4 <= -4e-148) {
		tmp = t_1;
	} else if (t_4 <= 1e-137) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)))
	t_1 = (0.5 * NaChar) - t_0
	t_2 = math.exp((((EAccept + (Ev + Vef)) - mu) / KbT))
	t_3 = NaChar / (t_2 - -1.0)
	t_4 = t_3 - t_0
	tmp = 0
	if t_4 <= -2e+144:
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_2))
	elif t_4 <= -4e-148:
		tmp = t_1
	elif t_4 <= 1e-137:
		tmp = t_3
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT))))
	t_1 = Float64(Float64(0.5 * NaChar) - t_0)
	t_2 = exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))
	t_3 = Float64(NaChar / Float64(t_2 - -1.0))
	t_4 = Float64(t_3 - t_0)
	tmp = 0.0
	if (t_4 <= -2e+144)
		tmp = Float64(Float64(0.5 * NdChar) - Float64(NaChar / Float64(-1.0 - t_2)));
	elseif (t_4 <= -4e-148)
		tmp = t_1;
	elseif (t_4 <= 1e-137)
		tmp = t_3;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	t_1 = (0.5 * NaChar) - t_0;
	t_2 = exp((((EAccept + (Ev + Vef)) - mu) / KbT));
	t_3 = NaChar / (t_2 - -1.0);
	t_4 = t_3 - t_0;
	tmp = 0.0;
	if (t_4 <= -2e+144)
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_2));
	elseif (t_4 <= -4e-148)
		tmp = t_1;
	elseif (t_4 <= 1e-137)
		tmp = t_3;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

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))))) < -2.00000000000000005e144

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 74.8

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

   5. Applied rewrites 74.8%

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

   if -2.00000000000000005e144 < (+.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))))) < -3.99999999999999974e-148 or 9.99999999999999978e-138 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 61.9

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

   5. Applied rewrites 61.9%

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

   if -3.99999999999999974e-148 < (+.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.99999999999999978e-138

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 84.3

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

   5. Applied rewrites 84.3%

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

4. Final simplification 71.4%

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

Alternative 4: 65.0% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)))
        (t_1 (- (* 0.5 NdChar) (/ NaChar (- -1.0 t_0))))
        (t_2 (/ NaChar (- t_0 -1.0)))
        (t_3
         (-
          t_2
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_3 -2e+144)
     t_1
     (if (<= t_3 -2e-257)
       (/
        (* NaChar NdChar)
        (fma (exp (/ (- (+ (+ mu Vef) EDonor) Ec) KbT)) NaChar NaChar))
       (if (<= t_3 1e-88) t_2 t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = exp((((EAccept + (Ev + Vef)) - mu) / KbT));
	double t_1 = (0.5 * NdChar) - (NaChar / (-1.0 - t_0));
	double t_2 = NaChar / (t_0 - -1.0);
	double t_3 = t_2 - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_3 <= -2e+144) {
		tmp = t_1;
	} else if (t_3 <= -2e-257) {
		tmp = (NaChar * NdChar) / fma(exp(((((mu + Vef) + EDonor) - Ec) / KbT)), NaChar, NaChar);
	} else if (t_3 <= 1e-88) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))
	t_1 = Float64(Float64(0.5 * NdChar) - Float64(NaChar / Float64(-1.0 - t_0)))
	t_2 = Float64(NaChar / Float64(t_0 - -1.0))
	t_3 = Float64(t_2 - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)))))
	tmp = 0.0
	if (t_3 <= -2e+144)
		tmp = t_1;
	elseif (t_3 <= -2e-257)
		tmp = Float64(Float64(NaChar * NdChar) / fma(exp(Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT)), NaChar, NaChar));
	elseif (t_3 <= 1e-88)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

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

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))))) < -2.00000000000000005e144 or 9.99999999999999934e-89 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 63.5

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

   5. Applied rewrites 63.5%

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

   if -2.00000000000000005e144 < (+.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))))) < -2e-257

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 90.1%

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

   6. Taylor expanded in NdChar around inf

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

   8. Applied rewrites 54.7%

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

   if -2e-257 < (+.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.99999999999999934e-89

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 86.1

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

   5. Applied rewrites 86.1%

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

4. Final simplification 68.9%

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

Alternative 5: 78.1% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))
        (t_1 (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0)))
        (t_2 (- t_1 t_0)))
   (if (<= t_2 -2e-228)
     (- (/ NaChar (- (exp (/ EAccept KbT)) -1.0)) t_0)
     (if (<= t_2 1e-137) t_1 (- (/ NaChar (- (exp (/ Ev KbT)) -1.0)) t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	double t_1 = NaChar / (exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	double t_2 = t_1 - t_0;
	double tmp;
	if (t_2 <= -2e-228) {
		tmp = (NaChar / (exp((EAccept / KbT)) - -1.0)) - t_0;
	} else if (t_2 <= 1e-137) {
		tmp = t_1;
	} else {
		tmp = (NaChar / (exp((Ev / KbT)) - -1.0)) - t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt)))
    t_1 = nachar / (exp((((eaccept + (ev + vef)) - mu) / kbt)) - (-1.0d0))
    t_2 = t_1 - t_0
    if (t_2 <= (-2d-228)) then
        tmp = (nachar / (exp((eaccept / kbt)) - (-1.0d0))) - t_0
    else if (t_2 <= 1d-137) then
        tmp = t_1
    else
        tmp = (nachar / (exp((ev / kbt)) - (-1.0d0))) - t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	double t_1 = NaChar / (Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	double t_2 = t_1 - t_0;
	double tmp;
	if (t_2 <= -2e-228) {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) - -1.0)) - t_0;
	} else if (t_2 <= 1e-137) {
		tmp = t_1;
	} else {
		tmp = (NaChar / (Math.exp((Ev / KbT)) - -1.0)) - t_0;
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(-1.0 - N[Exp[N[(N[(mu - N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(N[Exp[N[(N[(N[(EAccept + N[(Ev + Vef), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 - t$95$0), $MachinePrecision]}, If[LessEqual[t$95$2, -2e-228], N[(N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[t$95$2, 1e-137], t$95$1, N[(N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision] - t$95$0), $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))))) < -2.00000000000000007e-228

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in EAccept around inf

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

      1. lower-/.f64 75.7

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

   5. Applied rewrites 75.7%

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

   if -2.00000000000000007e-228 < (+.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.99999999999999978e-138

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 88.4

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

   5. Applied rewrites 88.4%

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

   if 9.99999999999999978e-138 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 81.0

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

   5. Applied rewrites 81.0%

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

4. Final simplification 81.3%

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

Alternative 6: 78.4% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))
        (t_1 (- (/ NaChar (- (exp (/ EAccept KbT)) -1.0)) t_0))
        (t_2 (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0)))
        (t_3 (- t_2 t_0)))
   (if (<= t_3 -2e-228) t_1 (if (<= t_3 1e-137) t_2 t_1))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	double t_1 = (NaChar / (exp((EAccept / KbT)) - -1.0)) - t_0;
	double t_2 = NaChar / (exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	double t_3 = t_2 - t_0;
	double tmp;
	if (t_3 <= -2e-228) {
		tmp = t_1;
	} else if (t_3 <= 1e-137) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt)))
    t_1 = (nachar / (exp((eaccept / kbt)) - (-1.0d0))) - t_0
    t_2 = nachar / (exp((((eaccept + (ev + vef)) - mu) / kbt)) - (-1.0d0))
    t_3 = t_2 - t_0
    if (t_3 <= (-2d-228)) then
        tmp = t_1
    else if (t_3 <= 1d-137) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	double t_1 = (NaChar / (Math.exp((EAccept / KbT)) - -1.0)) - t_0;
	double t_2 = NaChar / (Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	double t_3 = t_2 - t_0;
	double tmp;
	if (t_3 <= -2e-228) {
		tmp = t_1;
	} else if (t_3 <= 1e-137) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	t_1 = (NaChar / (exp((EAccept / KbT)) - -1.0)) - t_0;
	t_2 = NaChar / (exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	t_3 = t_2 - t_0;
	tmp = 0.0;
	if (t_3 <= -2e-228)
		tmp = t_1;
	elseif (t_3 <= 1e-137)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

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.00000000000000007e-228 or 9.99999999999999978e-138 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in EAccept around inf

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

      1. lower-/.f64 75.8

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

   5. Applied rewrites 75.8%

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

   if -2.00000000000000007e-228 < (+.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.99999999999999978e-138

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 88.4

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

   5. Applied rewrites 88.4%

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

4. Final simplification 79.8%

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

Alternative 7: 74.9% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (-
          (/ NdChar (- (exp (/ (- (+ mu EDonor) Ec) KbT)) -1.0))
          (/ NaChar (- -1.0 (exp (/ EAccept KbT))))))
        (t_1 (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0)))
        (t_2
         (-
          t_1
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_2 -2e-228) t_0 (if (<= t_2 1e-88) t_1 t_0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (exp((((mu + EDonor) - Ec) / KbT)) - -1.0)) - (NaChar / (-1.0 - exp((EAccept / KbT))));
	double t_1 = NaChar / (exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	double t_2 = t_1 - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_2 <= -2e-228) {
		tmp = t_0;
	} else if (t_2 <= 1e-88) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (ndchar / (exp((((mu + edonor) - ec) / kbt)) - (-1.0d0))) - (nachar / ((-1.0d0) - exp((eaccept / kbt))))
    t_1 = nachar / (exp((((eaccept + (ev + vef)) - mu) / kbt)) - (-1.0d0))
    t_2 = t_1 - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_2 <= (-2d-228)) then
        tmp = t_0
    else if (t_2 <= 1d-88) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (Math.exp((((mu + EDonor) - Ec) / KbT)) - -1.0)) - (NaChar / (-1.0 - Math.exp((EAccept / KbT))));
	double t_1 = NaChar / (Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	double t_2 = t_1 - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_2 <= -2e-228) {
		tmp = t_0;
	} else if (t_2 <= 1e-88) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(Float64(mu + EDonor) - Ec) / KbT)) - -1.0)) - Float64(NaChar / Float64(-1.0 - exp(Float64(EAccept / KbT)))))
	t_1 = Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)) - -1.0))
	t_2 = Float64(t_1 - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)))))
	tmp = 0.0
	if (t_2 <= -2e-228)
		tmp = t_0;
	elseif (t_2 <= 1e-88)
		tmp = t_1;
	else
		tmp = t_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) - Ec) / KbT)) - -1.0)) - (NaChar / (-1.0 - exp((EAccept / KbT))));
	t_1 = NaChar / (exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	t_2 = t_1 - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	tmp = 0.0;
	if (t_2 <= -2e-228)
		tmp = t_0;
	elseif (t_2 <= 1e-88)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

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

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.00000000000000007e-228 or 9.99999999999999934e-89 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in EAccept around inf

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

      1. lower-/.f64 76.3

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

   5. Applied rewrites 76.3%

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

   6. Taylor expanded in Vef around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 71.4

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

   8. Applied rewrites 71.4%

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

   if -2.00000000000000007e-228 < (+.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.99999999999999934e-89

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 85.2

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

   5. Applied rewrites 85.2%

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

4. Final simplification 76.2%

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

Alternative 8: 65.5% accurate, 0.4× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ EAccept (+ Ev Vef)))
        (t_1 (- (* 0.5 NdChar) (/ NaChar (- -1.0 (exp (/ t_0 KbT))))))
        (t_2 (/ NaChar (- (exp (/ (- t_0 mu) KbT)) -1.0)))
        (t_3
         (-
          t_2
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_3 -4e+63) t_1 (if (<= t_3 1e-88) t_2 t_1))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = EAccept + (Ev + Vef);
	double t_1 = (0.5 * NdChar) - (NaChar / (-1.0 - exp((t_0 / KbT))));
	double t_2 = NaChar / (exp(((t_0 - mu) / KbT)) - -1.0);
	double t_3 = t_2 - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_3 <= -4e+63) {
		tmp = t_1;
	} else if (t_3 <= 1e-88) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = eaccept + (ev + vef)
    t_1 = (0.5d0 * ndchar) - (nachar / ((-1.0d0) - exp((t_0 / kbt))))
    t_2 = nachar / (exp(((t_0 - mu) / kbt)) - (-1.0d0))
    t_3 = t_2 - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_3 <= (-4d+63)) then
        tmp = t_1
    else if (t_3 <= 1d-88) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = EAccept + (Ev + Vef);
	double t_1 = (0.5 * NdChar) - (NaChar / (-1.0 - Math.exp((t_0 / KbT))));
	double t_2 = NaChar / (Math.exp(((t_0 - mu) / KbT)) - -1.0);
	double t_3 = t_2 - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_3 <= -4e+63) {
		tmp = t_1;
	} else if (t_3 <= 1e-88) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

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))))) < -4.00000000000000023e63 or 9.99999999999999934e-89 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 60.8

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

   5. Applied rewrites 60.8%

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

   6. Taylor expanded in mu around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-+.f64 57.3

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

   8. Applied rewrites 57.3%

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

   if -4.00000000000000023e63 < (+.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.99999999999999934e-89

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 72.8

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

   5. Applied rewrites 72.8%

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

4. Final simplification 65.2%

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

Alternative 9: 34.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(NaChar + NdChar\right) \cdot 0.5\\ t_1 := \frac{NaChar}{e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}}\\ \mathbf{if}\;t\_1 \leq -4 \cdot 10^{-148}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 4 \cdot 10^{-145}:\\ \;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(\frac{\frac{NdChar \cdot NdChar}{NaChar} - NdChar}{NaChar}, -1, -1\right)}{-NaChar}} \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (+ NaChar NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -4e-148)
     t_0
     (if (<= t_1 4e-145)
       (*
        (/
         1.0
         (/
          (fma (/ (- (/ (* NdChar NdChar) NaChar) NdChar) NaChar) -1.0 -1.0)
          (- NaChar)))
        0.5)
       t_0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar + NdChar) * 0.5;
	double t_1 = (NaChar / (exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -4e-148) {
		tmp = t_0;
	} else if (t_1 <= 4e-145) {
		tmp = (1.0 / (fma(((((NdChar * NdChar) / NaChar) - NdChar) / NaChar), -1.0, -1.0) / -NaChar)) * 0.5;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar + NdChar) * 0.5)
	t_1 = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)) - -1.0)) - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)))))
	tmp = 0.0
	if (t_1 <= -4e-148)
		tmp = t_0;
	elseif (t_1 <= 4e-145)
		tmp = Float64(Float64(1.0 / Float64(fma(Float64(Float64(Float64(Float64(NdChar * NdChar) / NaChar) - NdChar) / NaChar), -1.0, -1.0) / Float64(-NaChar))) * 0.5);
	else
		tmp = t_0;
	end
	return tmp
end

Wolfram

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

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))))) < -3.99999999999999974e-148 or 3.99999999999999966e-145 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 33.9

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

   5. Applied rewrites 33.9%

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

   if -3.99999999999999974e-148 < (+.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))))) < 3.99999999999999966e-145

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 7.6

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

   5. Applied rewrites 7.6%

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

   7. Applied rewrites 6.1%

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

   8. Taylor expanded in NaChar around -inf

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

   10. Applied rewrites 35.0%

       \[\leadsto 0.5 \cdot \frac{1}{\frac{\mathsf{fma}\left(\frac{\frac{NdChar \cdot NdChar}{NaChar} - NdChar}{NaChar}, -1, -1\right)}{\color{blue}{-NaChar}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 34.2%

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

Alternative 10: 35.6% accurate, 0.4× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (+ NaChar NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -2e-222)
     t_0
     (if (<= t_1 4e-278)
       (*
        (/
         1.0
         (/
          (fma (/ (- (/ (* NaChar NaChar) NdChar) NaChar) NdChar) -1.0 -1.0)
          (- NdChar)))
        0.5)
       t_0))))

C

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar + NdChar) * 0.5)
	t_1 = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)) - -1.0)) - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)))))
	tmp = 0.0
	if (t_1 <= -2e-222)
		tmp = t_0;
	elseif (t_1 <= 4e-278)
		tmp = Float64(Float64(1.0 / Float64(fma(Float64(Float64(Float64(Float64(NaChar * NaChar) / NdChar) - NaChar) / NdChar), -1.0, -1.0) / Float64(-NdChar))) * 0.5);
	else
		tmp = t_0;
	end
	return tmp
end

Wolfram

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

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.0000000000000001e-222 or 3.99999999999999975e-278 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 32.2

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

   5. Applied rewrites 32.2%

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

   if -2.0000000000000001e-222 < (+.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))))) < 3.99999999999999975e-278

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 2.7

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

   5. Applied rewrites 2.7%

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

   7. Applied rewrites 7.0%

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

   8. Taylor expanded in NdChar around -inf

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

   10. Applied rewrites 37.1%

       \[\leadsto 0.5 \cdot \frac{1}{\frac{\mathsf{fma}\left(\frac{\frac{NaChar \cdot NaChar}{NdChar} - NaChar}{NdChar}, -1, -1\right)}{\color{blue}{-NdChar}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 33.4%

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

Alternative 11: 33.2% accurate, 0.5× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (+ NaChar NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -2e-228)
     t_0
     (if (<= t_1 5e-273)
       (* (/ 1.0 (/ (- NaChar NdChar) (* NaChar NaChar))) 0.5)
       t_0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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.00000000000000007e-228 or 4.99999999999999965e-273 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 31.9

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

   5. Applied rewrites 31.9%

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

   if -2.00000000000000007e-228 < (+.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.99999999999999965e-273

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 2.7

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

   5. Applied rewrites 2.7%

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

   7. Applied rewrites 7.2%

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

   8. Taylor expanded in NdChar around 0

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

   10. Applied rewrites 29.9%

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

4. Final simplification 31.4%

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

Alternative 12: 33.1% accurate, 0.5× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (+ NaChar NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -2e-228)
     t_0
     (if (<= t_1 5e-273)
       (/ (* (* NaChar NaChar) 0.5) (- NaChar NdChar))
       t_0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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.00000000000000007e-228 or 4.99999999999999965e-273 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 31.9

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

   5. Applied rewrites 31.9%

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

   if -2.00000000000000007e-228 < (+.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.99999999999999965e-273

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 2.7

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

   5. Applied rewrites 2.7%

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

   7. Applied rewrites 7.2%

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

   8. Taylor expanded in NdChar around 0

      \[\leadsto \frac{{NaChar}^{2} \cdot \frac{1}{2}}{NaChar - NdChar} \]
   9. Step-by-step derivation

   10. Applied rewrites 28.8%

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

4. Final simplification 31.1%

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

Alternative 13: 33.5% accurate, 0.5× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (+ NaChar NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -2e-222)
     t_0
     (if (<= t_1 4e-278)
       (/ (* -0.5 (* NdChar NdChar)) (- NaChar NdChar))
       t_0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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.0000000000000001e-222 or 3.99999999999999975e-278 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 32.2

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

   5. Applied rewrites 32.2%

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

   if -2.0000000000000001e-222 < (+.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))))) < 3.99999999999999975e-278

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 2.7

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

   5. Applied rewrites 2.7%

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

   7. Applied rewrites 7.0%

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

   8. Taylor expanded in NdChar around inf

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

   10. Applied rewrites 26.3%

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

4. Final simplification 30.7%

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

Alternative 14: 30.5% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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.0000000000000001e-222 or 3.99999999999999975e-278 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 32.2

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

   5. Applied rewrites 32.2%

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

   if -2.0000000000000001e-222 < (+.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))))) < 3.99999999999999975e-278

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around -inf

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

      1. associate-+r+ N/A

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

      2. metadata-eval N/A

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

      3. distribute-lft-neg-in N/A

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

      4. metadata-eval N/A

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

      5. distribute-lft-neg-in N/A

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

      6. distribute-neg-in N/A

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

      7. distribute-lft-out N/A

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

      8. distribute-lft-neg-in N/A

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

      9. metadata-eval N/A

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

   5. Applied rewrites 1.5%

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

   6. Taylor expanded in Ec around inf

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

   8. Applied rewrites 18.3%

      \[\leadsto \frac{Ec \cdot NdChar}{KbT} \cdot \color{blue}{0.25} \]
3. Recombined 2 regimes into one program.

4. Final simplification 28.7%

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

Alternative 15: 60.3% accurate, 0.7× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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))))) < -1e92

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 66.3

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

   5. Applied rewrites 66.3%

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

   6. Taylor expanded in mu around inf

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

      1. mul-1-neg N/A

         \[\leadsto \frac{1}{2} \cdot NdChar + \frac{NaChar}{1 + e^{\frac{\color{blue}{\mathsf{neg}\left(mu\right)}}{KbT}}} \]

      2. lower-neg.f64 55.9

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

   8. Applied rewrites 55.9%

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

   if -1e92 < (+.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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 63.0

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

   5. Applied rewrites 63.0%

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

4. Final simplification 61.7%

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

Alternative 16: 93.1% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (-
          (/ NaChar (- (exp (/ Vef KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= Vef -6.6e+143)
     t_0
     (if (<= Vef 4e+66)
       (-
        (/ NaChar (- (exp (/ (- (+ EAccept Ev) mu) KbT)) -1.0))
        (/ NdChar (- -1.0 (exp (/ (- (+ mu EDonor) Ec) KbT)))))
       t_0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -6.6e143 or 3.99999999999999978e66 < Vef

   1. Initial program 100.0%

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

   3. Taylor expanded in Vef around inf

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

      1. lower-/.f64 88.4

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

   5. Applied rewrites 88.4%

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

   if -6.6e143 < Vef < 3.99999999999999978e66

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Vef around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 N/A

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

      11. lower-/.f64 N/A

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

      12. +-commutative N/A

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

      13. lower-+.f64 N/A

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

   5. Applied rewrites 97.4%

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

4. Final simplification 94.4%

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

Alternative 17: 73.5% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT))))))
   (if (<= EAccept -1.2e-164)
     (- (/ NaChar (- (exp (/ Ev KbT)) -1.0)) t_0)
     (if (<= EAccept 1.3e+84)
       (- (/ NaChar (- (exp (/ Vef KbT)) -1.0)) t_0)
       (- (/ NaChar (- (exp (/ EAccept KbT)) -1.0)) t_0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT)));
	tmp = 0.0;
	if (EAccept <= -1.2e-164)
		tmp = (NaChar / (exp((Ev / KbT)) - -1.0)) - t_0;
	elseif (EAccept <= 1.3e+84)
		tmp = (NaChar / (exp((Vef / KbT)) - -1.0)) - t_0;
	else
		tmp = (NaChar / (exp((EAccept / KbT)) - -1.0)) - t_0;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if EAccept < -1.19999999999999992e-164

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 67.2

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

   5. Applied rewrites 67.2%

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

   if -1.19999999999999992e-164 < EAccept < 1.3000000000000001e84

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in Vef around inf

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

      1. lower-/.f64 69.2

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

   5. Applied rewrites 69.2%

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

   if 1.3000000000000001e84 < EAccept

   1. Initial program 100.0%

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

   3. Taylor expanded in EAccept around inf

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

      1. lower-/.f64 87.9

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

   5. Applied rewrites 87.9%

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

4. Final simplification 72.6%

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

Alternative 18: 75.8% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (-
          (/ NdChar (- (exp (/ (- (+ mu Vef) Ec) KbT)) -1.0))
          (/ NaChar (- -1.0 (exp (/ Vef KbT)))))))
   (if (<= Vef -3.9e+92)
     t_0
     (if (<= Vef 0.42)
       (-
        (/ NdChar (- (exp (/ (- (+ mu EDonor) Ec) KbT)) -1.0))
        (/ NaChar (- -1.0 (exp (/ EAccept KbT)))))
       t_0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Vef < -3.90000000000000011e92 or 0.419999999999999984 < Vef

   1. Initial program 100.0%

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

   3. Taylor expanded in Vef around inf

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

      1. lower-/.f64 85.9

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

   5. Applied rewrites 85.9%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 83.1

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

   8. Applied rewrites 83.1%

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

   if -3.90000000000000011e92 < Vef < 0.419999999999999984

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in EAccept around inf

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

      1. lower-/.f64 74.3

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

   5. Applied rewrites 74.3%

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

   6. Taylor expanded in Vef around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 73.1

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

   8. Applied rewrites 73.1%

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

4. Final simplification 77.2%

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

Alternative 19: 65.8% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}} - -1}\\ \mathbf{if}\;NaChar \leq -5.4 \cdot 10^{+23}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;NaChar \leq 1.85 \cdot 10^{+65}:\\ \;\;\;\;\frac{NaChar \cdot NdChar}{\mathsf{fma}\left(e^{\frac{\left(\left(mu + Vef\right) + EDonor\right) - Ec}{KbT}}, NaChar, NaChar\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (- (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)) -1.0))))
   (if (<= NaChar -5.4e+23)
     t_0
     (if (<= NaChar 1.85e+65)
       (/
        (* NaChar NdChar)
        (fma (exp (/ (- (+ (+ mu Vef) EDonor) Ec) KbT)) NaChar NaChar))
       t_0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (exp((((EAccept + (Ev + Vef)) - mu) / KbT)) - -1.0);
	double tmp;
	if (NaChar <= -5.4e+23) {
		tmp = t_0;
	} else if (NaChar <= 1.85e+65) {
		tmp = (NaChar * NdChar) / fma(exp(((((mu + Vef) + EDonor) - Ec) / KbT)), NaChar, NaChar);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)) - -1.0))
	tmp = 0.0
	if (NaChar <= -5.4e+23)
		tmp = t_0;
	elseif (NaChar <= 1.85e+65)
		tmp = Float64(Float64(NaChar * NdChar) / fma(exp(Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT)), NaChar, NaChar));
	else
		tmp = t_0;
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if NaChar < -5.3999999999999997e23 or 1.84999999999999997e65 < NaChar

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 71.0

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

   5. Applied rewrites 71.0%

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

   if -5.3999999999999997e23 < NaChar < 1.84999999999999997e65

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 87.8%

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

   6. Taylor expanded in NdChar around inf

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

   8. Applied rewrites 64.6%

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

4. Final simplification 67.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;NaChar \leq -5.4 \cdot 10^{+23}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}} - -1}\\ \mathbf{elif}\;NaChar \leq 1.85 \cdot 10^{+65}:\\ \;\;\;\;\frac{NaChar \cdot NdChar}{\mathsf{fma}\left(e^{\frac{\left(\left(mu + Vef\right) + EDonor\right) - Ec}{KbT}}, NaChar, NaChar\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}} - -1}\\ \end{array} \]
5. Add Preprocessing

Alternative 20: 63.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(NaChar + NdChar\right) \cdot 0.5\\ t_1 := \frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}\\ \mathbf{if}\;KbT \leq -1.05 \cdot 10^{+220}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \frac{NaChar}{KbT} \cdot EAccept, t\_0\right)\\ \mathbf{elif}\;KbT \leq 1.5 \cdot 10^{+212}:\\ \;\;\;\;\frac{NaChar}{e^{t\_1} - -1}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \mathsf{fma}\left(NaChar, t\_1, \frac{\left(\left(mu + Vef\right) + EDonor\right) - Ec}{KbT} \cdot NdChar\right), t\_0\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (+ NaChar NdChar) 0.5))
        (t_1 (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)))
   (if (<= KbT -1.05e+220)
     (fma -0.25 (* (/ NaChar KbT) EAccept) t_0)
     (if (<= KbT 1.5e+212)
       (/ NaChar (- (exp t_1) -1.0))
       (fma
        -0.25
        (fma NaChar t_1 (* (/ (- (+ (+ mu Vef) EDonor) Ec) KbT) NdChar))
        t_0)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar + NdChar) * 0.5;
	double t_1 = ((EAccept + (Ev + Vef)) - mu) / KbT;
	double tmp;
	if (KbT <= -1.05e+220) {
		tmp = fma(-0.25, ((NaChar / KbT) * EAccept), t_0);
	} else if (KbT <= 1.5e+212) {
		tmp = NaChar / (exp(t_1) - -1.0);
	} else {
		tmp = fma(-0.25, fma(NaChar, t_1, (((((mu + Vef) + EDonor) - Ec) / KbT) * NdChar)), t_0);
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar + NdChar) * 0.5)
	t_1 = Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)
	tmp = 0.0
	if (KbT <= -1.05e+220)
		tmp = fma(-0.25, Float64(Float64(NaChar / KbT) * EAccept), t_0);
	elseif (KbT <= 1.5e+212)
		tmp = Float64(NaChar / Float64(exp(t_1) - -1.0));
	else
		tmp = fma(-0.25, fma(NaChar, t_1, Float64(Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT) * NdChar)), t_0);
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.05000000000000003e220

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around -inf

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

      1. associate-+r+ N/A

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

      2. metadata-eval N/A

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

      3. distribute-lft-neg-in N/A

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

      4. metadata-eval N/A

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

      5. distribute-lft-neg-in N/A

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

      6. distribute-neg-in N/A

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

      7. distribute-lft-out N/A

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

      8. distribute-lft-neg-in N/A

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

      9. metadata-eval N/A

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

   5. Applied rewrites 62.8%

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

   6. Taylor expanded in EAccept around inf

      \[\leadsto \mathsf{fma}\left(\frac{-1}{4}, \frac{EAccept \cdot NaChar}{\color{blue}{KbT}}, \frac{1}{2} \cdot \left(NaChar + NdChar\right)\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 65.4%

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

   if -1.05000000000000003e220 < KbT < 1.5e212

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 61.5

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

   5. Applied rewrites 61.5%

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

   if 1.5e212 < KbT

   1. Initial program 99.8%

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

   3. Taylor expanded in KbT around -inf

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

      1. associate-+r+ N/A

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

      2. metadata-eval N/A

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

      3. distribute-lft-neg-in N/A

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

      4. metadata-eval N/A

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

      5. distribute-lft-neg-in N/A

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

      6. distribute-neg-in N/A

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

      7. distribute-lft-out N/A

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

      8. distribute-lft-neg-in N/A

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

      9. metadata-eval N/A

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

   5. Applied rewrites 79.8%

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

4. Final simplification 62.9%

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

Alternative 21: 22.2% accurate, 15.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -2.36 \cdot 10^{-94}:\\ \;\;\;\;0.5 \cdot NdChar\\ \mathbf{elif}\;NdChar \leq 1.25 \cdot 10^{-108}:\\ \;\;\;\;0.5 \cdot NaChar\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot NdChar\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -2.36e-94)
   (* 0.5 NdChar)
   (if (<= NdChar 1.25e-108) (* 0.5 NaChar) (* 0.5 NdChar))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NdChar <= -2.36e-94) {
		tmp = 0.5 * NdChar;
	} else if (NdChar <= 1.25e-108) {
		tmp = 0.5 * NaChar;
	} else {
		tmp = 0.5 * NdChar;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (ndchar <= (-2.36d-94)) then
        tmp = 0.5d0 * ndchar
    else if (ndchar <= 1.25d-108) then
        tmp = 0.5d0 * nachar
    else
        tmp = 0.5d0 * ndchar
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NdChar <= -2.36e-94) {
		tmp = 0.5 * NdChar;
	} else if (NdChar <= 1.25e-108) {
		tmp = 0.5 * NaChar;
	} else {
		tmp = 0.5 * NdChar;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NdChar <= -2.36e-94:
		tmp = 0.5 * NdChar
	elif NdChar <= 1.25e-108:
		tmp = 0.5 * NaChar
	else:
		tmp = 0.5 * NdChar
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NdChar <= -2.36e-94)
		tmp = Float64(0.5 * NdChar);
	elseif (NdChar <= 1.25e-108)
		tmp = Float64(0.5 * NaChar);
	else
		tmp = Float64(0.5 * NdChar);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NdChar <= -2.36e-94)
		tmp = 0.5 * NdChar;
	elseif (NdChar <= 1.25e-108)
		tmp = 0.5 * NaChar;
	else
		tmp = 0.5 * NdChar;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -2.36e-94], N[(0.5 * NdChar), $MachinePrecision], If[LessEqual[NdChar, 1.25e-108], N[(0.5 * NaChar), $MachinePrecision], N[(0.5 * NdChar), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -2.3599999999999999e-94 or 1.25e-108 < 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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 24.3

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

   5. Applied rewrites 24.3%

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

   7. Applied rewrites 15.9%

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

   9. Applied rewrites 15.9%

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

   10. Taylor expanded in NdChar around inf

       \[\leadsto \frac{1}{2} \cdot \color{blue}{NdChar} \]
   11. Step-by-step derivation

   12. Applied rewrites 22.0%

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

   if -2.3599999999999999e-94 < NdChar < 1.25e-108

   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}}} \]
   2. Add Preprocessing

   3. Taylor expanded in KbT around inf

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

      1. distribute-lft-out N/A

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

      2. lower-*.f64 N/A

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

      3. lower-+.f64 26.2

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

   5. Applied rewrites 26.2%

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

   6. Taylor expanded in NdChar around 0

      \[\leadsto \frac{1}{2} \cdot \color{blue}{NaChar} \]
   7. Step-by-step derivation

   8. Applied rewrites 28.1%

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

Alternative 22: 27.6% accurate, 30.7× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar + NdChar), $MachinePrecision] * 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}}} \]
2. Add Preprocessing

3. Taylor expanded in KbT around inf

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

   1. distribute-lft-out N/A

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

   2. lower-*.f64 N/A

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

   3. lower-+.f64 24.8

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

5. Applied rewrites 24.8%

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

6. Final simplification 24.8%

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

Alternative 23: 17.9% accurate, 46.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (* 0.5 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 * 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 * 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 * NaChar;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(0.5 * NaChar), $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}}} \]
2. Add Preprocessing

3. Taylor expanded in KbT around inf

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

   1. distribute-lft-out N/A

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

   2. lower-*.f64 N/A

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

   3. lower-+.f64 24.8

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

5. Applied rewrites 24.8%

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

6. Taylor expanded in NdChar around 0

   \[\leadsto \frac{1}{2} \cdot \color{blue}{NaChar} \]
7. Step-by-step derivation

8. Applied rewrites 15.9%

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

Reproduce

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