Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 16.7s

Alternatives: 20

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -1.2274155872818666e-182
  2. Ec = 1.1401046442987616e+166
  3. Vef = -1.5002225052761877e-129
  4. EDonor = 4.27771808216154e+225
  5. mu = 3.53813316497868e-103
  6. KbT = -8.726696986446939e-190
  7. NaChar = 2.2895194327714149e-181
  8. Ev = 1.2216893321042738e+216
  9. EAccept = 1.0556090721634681e+220

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(\left(Ev + Vef\right) + EAccept\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 (/ (- (+ (+ Ev Vef) EAccept) 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(((((Ev + Vef) + EAccept) - 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(((((ev + vef) + eaccept) - 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(((((Ev + Vef) + EAccept) - 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(((((Ev + Vef) + EAccept) - 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(Float64(Ev + Vef) + EAccept) - 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(((((Ev + Vef) + EAccept) - 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[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}} \]
4. Add Preprocessing

Alternative 2: 77.5% 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(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1}\\ t_2 := t\_1 - t\_0\\ \mathbf{if}\;t\_2 \leq -5 \cdot 10^{-256}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1} - t\_0\\ \mathbf{elif}\;t\_2 \leq 10^{-174}:\\ \;\;\;\;t\_1\\ \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)))))
        (t_1 (/ NaChar (- (exp (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) -1.0)))
        (t_2 (- t_1 t_0)))
   (if (<= t_2 -5e-256)
     (- (/ NaChar (- (exp (/ Vef KbT)) -1.0)) t_0)
     (if (<= t_2 1e-174)
       t_1
       (- (/ 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 t_1 = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	double t_2 = t_1 - t_0;
	double tmp;
	if (t_2 <= -5e-256) {
		tmp = (NaChar / (exp((Vef / KbT)) - -1.0)) - t_0;
	} else if (t_2 <= 1e-174) {
		tmp = t_1;
	} 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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt)))
    t_1 = nachar / (exp(((((ev + vef) + eaccept) - mu) / kbt)) - (-1.0d0))
    t_2 = t_1 - t_0
    if (t_2 <= (-5d-256)) then
        tmp = (nachar / (exp((vef / kbt)) - (-1.0d0))) - t_0
    else if (t_2 <= 1d-174) then
        tmp = t_1
    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 t_1 = NaChar / (Math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	double t_2 = t_1 - t_0;
	double tmp;
	if (t_2 <= -5e-256) {
		tmp = (NaChar / (Math.exp((Vef / KbT)) - -1.0)) - t_0;
	} else if (t_2 <= 1e-174) {
		tmp = t_1;
	} 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)))
	t_1 = NaChar / (math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)
	t_2 = t_1 - t_0
	tmp = 0
	if t_2 <= -5e-256:
		tmp = (NaChar / (math.exp((Vef / KbT)) - -1.0)) - t_0
	elif t_2 <= 1e-174:
		tmp = t_1
	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))))
	t_1 = Float64(NaChar / Float64(exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - mu) / KbT)) - -1.0))
	t_2 = Float64(t_1 - t_0)
	tmp = 0.0
	if (t_2 <= -5e-256)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Vef / KbT)) - -1.0)) - t_0);
	elseif (t_2 <= 1e-174)
		tmp = t_1;
	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)));
	t_1 = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	t_2 = t_1 - t_0;
	tmp = 0.0;
	if (t_2 <= -5e-256)
		tmp = (NaChar / (exp((Vef / KbT)) - -1.0)) - t_0;
	elseif (t_2 <= 1e-174)
		tmp = t_1;
	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]}, Block[{t$95$1 = N[(NaChar / N[(N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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, -5e-256], N[(N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[t$95$2, 1e-174], t$95$1, 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 (+.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))))) < -5e-256

   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 82.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{Vef}{KbT}}}} \]

   5. Applied rewrites 82.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{Vef}{KbT}}}} \]

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

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

      \[\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 90.4

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

   5. Applied rewrites 90.4%

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

   if 1e-174 < (+.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 77.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{EAccept}{KbT}}}} \]

   5. Applied rewrites 77.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{EAccept}{KbT}}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 83.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}} \leq -5 \cdot 10^{-256}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}}\\ \mathbf{elif}\;\frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}} \leq 10^{-174}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\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 3: 77.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{EAccept}{KbT}} - -1} - t\_0\\ t_2 := \frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1}\\ t_3 := t\_2 - t\_0\\ \mathbf{if}\;t\_3 \leq -1 \cdot 10^{-59}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_3 \leq 10^{-174}:\\ \;\;\;\;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 (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) -1.0)))
        (t_3 (- t_2 t_0)))
   (if (<= t_3 -1e-59) t_1 (if (<= t_3 1e-174) 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	double t_3 = t_2 - t_0;
	double tmp;
	if (t_3 <= -1e-59) {
		tmp = t_1;
	} else if (t_3 <= 1e-174) {
		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(((((ev + vef) + eaccept) - mu) / kbt)) - (-1.0d0))
    t_3 = t_2 - t_0
    if (t_3 <= (-1d-59)) then
        tmp = t_1
    else if (t_3 <= 1d-174) 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	double t_3 = t_2 - t_0;
	double tmp;
	if (t_3 <= -1e-59) {
		tmp = t_1;
	} else if (t_3 <= 1e-174) {
		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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)
	t_3 = t_2 - t_0
	tmp = 0
	if t_3 <= -1e-59:
		tmp = t_1
	elif t_3 <= 1e-174:
		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(Float64(Ev + Vef) + EAccept) - mu) / KbT)) - -1.0))
	t_3 = Float64(t_2 - t_0)
	tmp = 0.0
	if (t_3 <= -1e-59)
		tmp = t_1;
	elseif (t_3 <= 1e-174)
		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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	t_3 = t_2 - t_0;
	tmp = 0.0;
	if (t_3 <= -1e-59)
		tmp = t_1;
	elseif (t_3 <= 1e-174)
		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[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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, -1e-59], t$95$1, If[LessEqual[t$95$3, 1e-174], 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))))) < -1e-59 or 1e-174 < (+.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 78.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{EAccept}{KbT}}}} \]

   5. Applied rewrites 78.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{EAccept}{KbT}}}} \]

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

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

      \[\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 84.9

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

   5. Applied rewrites 84.9%

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

4. Final simplification 80.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}} \leq -1 \cdot 10^{-59}:\\ \;\;\;\;\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(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}} \leq 10^{-174}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\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 4: 68.4% accurate, 0.4× 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 := \frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1}\\ t_3 := t\_2 - t\_0\\ \mathbf{if}\;t\_3 \leq -1 \cdot 10^{-59}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_3 \leq 2 \cdot 10^{-37}:\\ \;\;\;\;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 (- (* 0.5 NaChar) t_0))
        (t_2 (/ NaChar (- (exp (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) -1.0)))
        (t_3 (- t_2 t_0)))
   (if (<= t_3 -1e-59) t_1 (if (<= t_3 2e-37) 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 = (0.5 * NaChar) - t_0;
	double t_2 = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	double t_3 = t_2 - t_0;
	double tmp;
	if (t_3 <= -1e-59) {
		tmp = t_1;
	} else if (t_3 <= 2e-37) {
		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 = (0.5d0 * nachar) - t_0
    t_2 = nachar / (exp(((((ev + vef) + eaccept) - mu) / kbt)) - (-1.0d0))
    t_3 = t_2 - t_0
    if (t_3 <= (-1d-59)) then
        tmp = t_1
    else if (t_3 <= 2d-37) 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 = (0.5 * NaChar) - t_0;
	double t_2 = NaChar / (Math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	double t_3 = t_2 - t_0;
	double tmp;
	if (t_3 <= -1e-59) {
		tmp = t_1;
	} else if (t_3 <= 2e-37) {
		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 = (0.5 * NaChar) - t_0
	t_2 = NaChar / (math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)
	t_3 = t_2 - t_0
	tmp = 0
	if t_3 <= -1e-59:
		tmp = t_1
	elif t_3 <= 2e-37:
		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(0.5 * NaChar) - t_0)
	t_2 = Float64(NaChar / Float64(exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - mu) / KbT)) - -1.0))
	t_3 = Float64(t_2 - t_0)
	tmp = 0.0
	if (t_3 <= -1e-59)
		tmp = t_1;
	elseif (t_3 <= 2e-37)
		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 = (0.5 * NaChar) - t_0;
	t_2 = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	t_3 = t_2 - t_0;
	tmp = 0.0;
	if (t_3 <= -1e-59)
		tmp = t_1;
	elseif (t_3 <= 2e-37)
		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[(0.5 * NaChar), $MachinePrecision] - t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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, -1e-59], t$95$1, If[LessEqual[t$95$3, 2e-37], 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))))) < -1e-59 or 2.00000000000000013e-37 < (+.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 80.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{EAccept}{KbT}}}} \]

   5. Applied rewrites 80.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{EAccept}{KbT}}}} \]

   6. 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} \]
   7. Step-by-step derivation

      1. lower-*.f64 70.5

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

   8. Applied rewrites 70.5%

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

   if -1e-59 < (+.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.00000000000000013e-37

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 81.2

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

   5. Applied rewrites 81.2%

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

4. Final simplification 75.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}} \leq -1 \cdot 10^{-59}:\\ \;\;\;\;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(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}} \leq 2 \cdot 10^{-37}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\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 5: 57.7% accurate, 0.4× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Derivation

1. Split input into 3 regimes

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

   1. Initial program 100.0%

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

   6. Taylor expanded in KbT around inf

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

      1. lower-*.f64 54.8

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

   8. Applied rewrites 54.8%

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

   if -1e-59 < (+.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.9999999999999998e184

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 74.3

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

   5. Applied rewrites 74.3%

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

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

   1. Initial program 99.9%

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

   3. Taylor expanded in NaChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 74.4

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

   5. Applied rewrites 74.4%

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

   6. Taylor expanded in Ec around inf

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

   8. Applied rewrites 64.7%

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

4. Final simplification 67.8%

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

Alternative 6: 37.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(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}}\\ \mathbf{if}\;t\_1 \leq -5 \cdot 10^{-65}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 10^{+185}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -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 (* (+ NaChar NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -5e-65)
     t_0
     (if (<= t_1 1e+185) (/ 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 = (NaChar + NdChar) * 0.5;
	double t_1 = (NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -5e-65) {
		tmp = t_0;
	} else if (t_1 <= 1e+185) {
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	} 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(((((ev + vef) + eaccept) - mu) / kbt)) - (-1.0d0))) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_1 <= (-5d-65)) then
        tmp = t_0
    else if (t_1 <= 1d+185) then
        tmp = nachar / (exp((eaccept / kbt)) - (-1.0d0))
    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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -5e-65) {
		tmp = t_0;
	} else if (t_1 <= 1e+185) {
		tmp = NaChar / (Math.exp((EAccept / KbT)) - -1.0);
	} 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))))
	tmp = 0
	if t_1 <= -5e-65:
		tmp = t_0
	elif t_1 <= 1e+185:
		tmp = NaChar / (math.exp((EAccept / KbT)) - -1.0)
	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(Float64(Ev + Vef) + EAccept) - 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 <= -5e-65)
		tmp = t_0;
	elseif (t_1 <= 1e+185)
		tmp = Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) - -1.0));
	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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	tmp = 0.0;
	if (t_1 <= -5e-65)
		tmp = t_0;
	elseif (t_1 <= 1e+185)
		tmp = NaChar / (exp((EAccept / KbT)) - -1.0);
	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[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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, -5e-65], t$95$0, If[LessEqual[t$95$1, 1e+185], N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $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))))) < -4.99999999999999983e-65 or 9.9999999999999998e184 < (+.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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 44.3

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

   5. Applied rewrites 44.3%

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

   if -4.99999999999999983e-65 < (+.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.9999999999999998e184

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 74.2

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

   5. Applied rewrites 74.2%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 40.9%

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

4. Final simplification 42.2%

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

Alternative 7: 36.1% 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(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}}\\ \mathbf{if}\;t\_1 \leq -1 \cdot 10^{-294}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 5 \cdot 10^{-238}:\\ \;\;\;\;\frac{NdChar}{\left(\left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right) + \left(2 + \frac{EDonor}{KbT}\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (+ NaChar NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -1e-294)
     t_0
     (if (<= t_1 5e-238)
       (/
        NdChar
        (- (+ (+ (/ mu KbT) (/ Vef KbT)) (+ 2.0 (/ EDonor KbT))) (/ 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 + NdChar) * 0.5;
	double t_1 = (NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -1e-294) {
		tmp = t_0;
	} else if (t_1 <= 5e-238) {
		tmp = NdChar / ((((mu / KbT) + (Vef / KbT)) + (2.0 + (EDonor / KbT))) - (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) :: t_1
    real(8) :: tmp
    t_0 = (nachar + ndchar) * 0.5d0
    t_1 = (nachar / (exp(((((ev + vef) + eaccept) - mu) / kbt)) - (-1.0d0))) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_1 <= (-1d-294)) then
        tmp = t_0
    else if (t_1 <= 5d-238) then
        tmp = ndchar / ((((mu / kbt) + (vef / kbt)) + (2.0d0 + (edonor / kbt))) - (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 + NdChar) * 0.5;
	double t_1 = (NaChar / (Math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -1e-294) {
		tmp = t_0;
	} else if (t_1 <= 5e-238) {
		tmp = NdChar / ((((mu / KbT) + (Vef / KbT)) + (2.0 + (EDonor / KbT))) - (Ec / 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))))
	tmp = 0
	if t_1 <= -1e-294:
		tmp = t_0
	elif t_1 <= 5e-238:
		tmp = NdChar / ((((mu / KbT) + (Vef / KbT)) + (2.0 + (EDonor / KbT))) - (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 + NdChar) * 0.5)
	t_1 = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - 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 <= -1e-294)
		tmp = t_0;
	elseif (t_1 <= 5e-238)
		tmp = Float64(NdChar / Float64(Float64(Float64(Float64(mu / KbT) + Float64(Vef / KbT)) + Float64(2.0 + Float64(EDonor / KbT))) - Float64(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 + NdChar) * 0.5;
	t_1 = (NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	tmp = 0.0;
	if (t_1 <= -1e-294)
		tmp = t_0;
	elseif (t_1 <= 5e-238)
		tmp = NdChar / ((((mu / KbT) + (Vef / KbT)) + (2.0 + (EDonor / KbT))) - (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 + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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, -1e-294], t$95$0, If[LessEqual[t$95$1, 5e-238], N[(NdChar / N[(N[(N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision] + N[(2.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $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))))) < -1.00000000000000002e-294 or 5e-238 < (+.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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 37.0

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

   5. Applied rewrites 37.0%

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

   if -1.00000000000000002e-294 < (+.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))))) < 5e-238

   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 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 88.9

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

   5. Applied rewrites 88.9%

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

   6. Taylor expanded in KbT around inf

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

   8. Applied rewrites 37.6%

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

4. Final simplification 37.2%

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

Alternative 8: 35.3% 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(\left(Ev + Vef\right) + EAccept\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^{-74}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 5 \cdot 10^{-178}:\\ \;\;\;\;\frac{NaChar}{\left(\left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right) + \left(2 + \frac{EAccept}{KbT}\right)\right) - \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 NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -2e-74)
     t_0
     (if (<= t_1 5e-178)
       (/
        NaChar
        (- (+ (+ (/ Ev KbT) (/ Vef KbT)) (+ 2.0 (/ EAccept KbT))) (/ 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 + NdChar) * 0.5;
	double t_1 = (NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-74) {
		tmp = t_0;
	} else if (t_1 <= 5e-178) {
		tmp = NaChar / ((((Ev / KbT) + (Vef / KbT)) + (2.0 + (EAccept / KbT))) - (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) :: t_1
    real(8) :: tmp
    t_0 = (nachar + ndchar) * 0.5d0
    t_1 = (nachar / (exp(((((ev + vef) + eaccept) - mu) / kbt)) - (-1.0d0))) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_1 <= (-2d-74)) then
        tmp = t_0
    else if (t_1 <= 5d-178) then
        tmp = nachar / ((((ev / kbt) + (vef / kbt)) + (2.0d0 + (eaccept / kbt))) - (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 + NdChar) * 0.5;
	double t_1 = (NaChar / (Math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-74) {
		tmp = t_0;
	} else if (t_1 <= 5e-178) {
		tmp = NaChar / ((((Ev / KbT) + (Vef / KbT)) + (2.0 + (EAccept / KbT))) - (mu / 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))))
	tmp = 0
	if t_1 <= -2e-74:
		tmp = t_0
	elif t_1 <= 5e-178:
		tmp = NaChar / ((((Ev / KbT) + (Vef / KbT)) + (2.0 + (EAccept / KbT))) - (mu / 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(Float64(Ev + Vef) + EAccept) - 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-74)
		tmp = t_0;
	elseif (t_1 <= 5e-178)
		tmp = Float64(NaChar / Float64(Float64(Float64(Float64(Ev / KbT) + Float64(Vef / KbT)) + Float64(2.0 + Float64(EAccept / KbT))) - 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 + NdChar) * 0.5;
	t_1 = (NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	tmp = 0.0;
	if (t_1 <= -2e-74)
		tmp = t_0;
	elseif (t_1 <= 5e-178)
		tmp = NaChar / ((((Ev / KbT) + (Vef / KbT)) + (2.0 + (EAccept / KbT))) - (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[(N[(NaChar + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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-74], t$95$0, If[LessEqual[t$95$1, 5e-178], N[(NaChar / N[(N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision] + N[(2.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $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))))) < -1.99999999999999992e-74 or 4.99999999999999976e-178 < (+.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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 40.5

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

   5. Applied rewrites 40.5%

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

   if -1.99999999999999992e-74 < (+.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.99999999999999976e-178

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 84.1

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

   5. Applied rewrites 84.1%

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

   6. Taylor expanded in KbT around inf

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

   8. Applied rewrites 31.0%

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

4. Final simplification 37.0%

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

Alternative 9: 33.7% 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(\left(Ev + Vef\right) + EAccept\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^{-286}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 0:\\ \;\;\;\;\frac{\left(NdChar \cdot NdChar\right) \cdot 0.5}{\left(NdChar - NaChar\right) \cdot \left(NaChar + NdChar\right)} \cdot \left(NaChar + NdChar\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 NdChar) 0.5))
        (t_1
         (-
          (/ NaChar (- (exp (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -2e-286)
     t_0
     (if (<= t_1 0.0)
       (*
        (/ (* (* NdChar NdChar) 0.5) (* (- NdChar NaChar) (+ NaChar 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-286) {
		tmp = t_0;
	} else if (t_1 <= 0.0) {
		tmp = (((NdChar * NdChar) * 0.5) / ((NdChar - NaChar) * (NaChar + 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(((((ev + vef) + eaccept) - mu) / kbt)) - (-1.0d0))) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_1 <= (-2d-286)) then
        tmp = t_0
    else if (t_1 <= 0.0d0) then
        tmp = (((ndchar * ndchar) * 0.5d0) / ((ndchar - nachar) * (nachar + 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-286) {
		tmp = t_0;
	} else if (t_1 <= 0.0) {
		tmp = (((NdChar * NdChar) * 0.5) / ((NdChar - NaChar) * (NaChar + 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))))
	tmp = 0
	if t_1 <= -2e-286:
		tmp = t_0
	elif t_1 <= 0.0:
		tmp = (((NdChar * NdChar) * 0.5) / ((NdChar - NaChar) * (NaChar + 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(Float64(Ev + Vef) + EAccept) - 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-286)
		tmp = t_0;
	elseif (t_1 <= 0.0)
		tmp = Float64(Float64(Float64(Float64(NdChar * NdChar) * 0.5) / Float64(Float64(NdChar - NaChar) * Float64(NaChar + 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	tmp = 0.0;
	if (t_1 <= -2e-286)
		tmp = t_0;
	elseif (t_1 <= 0.0)
		tmp = (((NdChar * NdChar) * 0.5) / ((NdChar - NaChar) * (NaChar + 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[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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-286], t$95$0, If[LessEqual[t$95$1, 0.0], N[(N[(N[(N[(NdChar * NdChar), $MachinePrecision] * 0.5), $MachinePrecision] / N[(N[(NdChar - NaChar), $MachinePrecision] * N[(NaChar + NdChar), $MachinePrecision]), $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-286 or 0.0 < (+.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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 35.8

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

   5. Applied rewrites 35.8%

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

   if -2.0000000000000001e-286 < (+.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))))) < 0.0

   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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 2.6

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

   5. Applied rewrites 2.6%

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

   7. Applied rewrites 5.7%

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

   8. Taylor expanded in NaChar around 0

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

   10. Applied rewrites 31.1%

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

   12. Applied rewrites 34.1%

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

4. Final simplification 35.4%

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

Alternative 10: 32.9% 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(\left(Ev + Vef\right) + EAccept\right) - mu}{KbT}} - -1} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}}\\ \mathbf{if}\;t\_1 \leq -5 \cdot 10^{-239}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 5 \cdot 10^{-238}:\\ \;\;\;\;\frac{NdChar \cdot NdChar}{NdChar - 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 (/ (- (+ (+ Ev Vef) EAccept) mu) KbT)) -1.0))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -5e-239)
     t_0
     (if (<= t_1 5e-238)
       (* (/ (* NdChar NdChar) (- NdChar 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -5e-239) {
		tmp = t_0;
	} else if (t_1 <= 5e-238) {
		tmp = ((NdChar * NdChar) / (NdChar - 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(((((ev + vef) + eaccept) - mu) / kbt)) - (-1.0d0))) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_1 <= (-5d-239)) then
        tmp = t_0
    else if (t_1 <= 5d-238) then
        tmp = ((ndchar * ndchar) / (ndchar - 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -5e-239) {
		tmp = t_0;
	} else if (t_1 <= 5e-238) {
		tmp = ((NdChar * NdChar) / (NdChar - 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))))
	tmp = 0
	if t_1 <= -5e-239:
		tmp = t_0
	elif t_1 <= 5e-238:
		tmp = ((NdChar * NdChar) / (NdChar - 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(Float64(Ev + Vef) + EAccept) - 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 <= -5e-239)
		tmp = t_0;
	elseif (t_1 <= 5e-238)
		tmp = Float64(Float64(Float64(NdChar * NdChar) / Float64(NdChar - 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(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	tmp = 0.0;
	if (t_1 <= -5e-239)
		tmp = t_0;
	elseif (t_1 <= 5e-238)
		tmp = ((NdChar * NdChar) / (NdChar - 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[(N[(Ev + Vef), $MachinePrecision] + EAccept), $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, -5e-239], t$95$0, If[LessEqual[t$95$1, 5e-238], N[(N[(N[(NdChar * NdChar), $MachinePrecision] / N[(NdChar - 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))))) < -5e-239 or 5e-238 < (+.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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 37.9

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

   5. Applied rewrites 37.9%

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

   if -5e-239 < (+.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))))) < 5e-238

   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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 3.2

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

   5. Applied rewrites 3.2%

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

   7. Applied rewrites 5.5%

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

   8. Taylor expanded in NaChar around 0

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

   10. Applied rewrites 26.6%

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

   12. Applied rewrites 26.6%

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

4. Final simplification 34.7%

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

Alternative 11: 42.4% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ t_1 := \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ t_2 := 0.5 \cdot NdChar - \frac{NaChar}{-1 - e^{\frac{EAccept}{KbT}}}\\ \mathbf{if}\;KbT \leq -8.5 \cdot 10^{+85}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{-306}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;KbT \leq 1.35 \cdot 10^{-42}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 3.2 \cdot 10^{+75}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;KbT \leq 2.1 \cdot 10^{+189}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \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)))
        (t_1 (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
        (t_2 (- (* 0.5 NdChar) (/ NaChar (- -1.0 (exp (/ EAccept KbT)))))))
   (if (<= KbT -8.5e+85)
     t_2
     (if (<= KbT 1.9e-306)
       t_1
       (if (<= KbT 1.35e-42)
         t_0
         (if (<= KbT 3.2e+75) t_1 (if (<= KbT 2.1e+189) t_0 t_2)))))))

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);
	double t_1 = NdChar / (1.0 + exp((-Ec / KbT)));
	double t_2 = (0.5 * NdChar) - (NaChar / (-1.0 - exp((EAccept / KbT))));
	double tmp;
	if (KbT <= -8.5e+85) {
		tmp = t_2;
	} else if (KbT <= 1.9e-306) {
		tmp = t_1;
	} else if (KbT <= 1.35e-42) {
		tmp = t_0;
	} else if (KbT <= 3.2e+75) {
		tmp = t_1;
	} else if (KbT <= 2.1e+189) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	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 = nachar / (exp((vef / kbt)) - (-1.0d0))
    t_1 = ndchar / (1.0d0 + exp((-ec / kbt)))
    t_2 = (0.5d0 * ndchar) - (nachar / ((-1.0d0) - exp((eaccept / kbt))))
    if (kbt <= (-8.5d+85)) then
        tmp = t_2
    else if (kbt <= 1.9d-306) then
        tmp = t_1
    else if (kbt <= 1.35d-42) then
        tmp = t_0
    else if (kbt <= 3.2d+75) then
        tmp = t_1
    else if (kbt <= 2.1d+189) then
        tmp = t_0
    else
        tmp = t_2
    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);
	double t_1 = NdChar / (1.0 + Math.exp((-Ec / KbT)));
	double t_2 = (0.5 * NdChar) - (NaChar / (-1.0 - Math.exp((EAccept / KbT))));
	double tmp;
	if (KbT <= -8.5e+85) {
		tmp = t_2;
	} else if (KbT <= 1.9e-306) {
		tmp = t_1;
	} else if (KbT <= 1.35e-42) {
		tmp = t_0;
	} else if (KbT <= 3.2e+75) {
		tmp = t_1;
	} else if (KbT <= 2.1e+189) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (math.exp((Vef / KbT)) - -1.0)
	t_1 = NdChar / (1.0 + math.exp((-Ec / KbT)))
	t_2 = (0.5 * NdChar) - (NaChar / (-1.0 - math.exp((EAccept / KbT))))
	tmp = 0
	if KbT <= -8.5e+85:
		tmp = t_2
	elif KbT <= 1.9e-306:
		tmp = t_1
	elif KbT <= 1.35e-42:
		tmp = t_0
	elif KbT <= 3.2e+75:
		tmp = t_1
	elif KbT <= 2.1e+189:
		tmp = t_0
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(exp(Float64(Vef / KbT)) - -1.0))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))
	t_2 = Float64(Float64(0.5 * NdChar) - Float64(NaChar / Float64(-1.0 - exp(Float64(EAccept / KbT)))))
	tmp = 0.0
	if (KbT <= -8.5e+85)
		tmp = t_2;
	elseif (KbT <= 1.9e-306)
		tmp = t_1;
	elseif (KbT <= 1.35e-42)
		tmp = t_0;
	elseif (KbT <= 3.2e+75)
		tmp = t_1;
	elseif (KbT <= 2.1e+189)
		tmp = t_0;
	else
		tmp = t_2;
	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);
	t_1 = NdChar / (1.0 + exp((-Ec / KbT)));
	t_2 = (0.5 * NdChar) - (NaChar / (-1.0 - exp((EAccept / KbT))));
	tmp = 0.0;
	if (KbT <= -8.5e+85)
		tmp = t_2;
	elseif (KbT <= 1.9e-306)
		tmp = t_1;
	elseif (KbT <= 1.35e-42)
		tmp = t_0;
	elseif (KbT <= 3.2e+75)
		tmp = t_1;
	elseif (KbT <= 2.1e+189)
		tmp = t_0;
	else
		tmp = t_2;
	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[(Vef / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(0.5 * NdChar), $MachinePrecision] - N[(NaChar / N[(-1.0 - N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -8.5e+85], t$95$2, If[LessEqual[KbT, 1.9e-306], t$95$1, If[LessEqual[KbT, 1.35e-42], t$95$0, If[LessEqual[KbT, 3.2e+75], t$95$1, If[LessEqual[KbT, 2.1e+189], t$95$0, t$95$2]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -8.4999999999999994e85 or 2.09999999999999992e189 < 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 84.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 84.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}}}} \]

   6. Taylor expanded in KbT around inf

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

      1. lower-*.f64 72.5

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

   8. Applied rewrites 72.5%

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

   if -8.4999999999999994e85 < KbT < 1.9e-306 or 1.35e-42 < KbT < 3.19999999999999985e75

   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 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 73.3

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

   5. Applied rewrites 73.3%

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

   6. Taylor expanded in Ec around inf

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

   8. Applied rewrites 48.8%

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

   if 1.9e-306 < KbT < 1.35e-42 or 3.19999999999999985e75 < KbT < 2.09999999999999992e189

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 74.7

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

   5. Applied rewrites 74.7%

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

   6. Taylor expanded in Vef around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 59.8%

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

4. Final simplification 58.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -8.5 \cdot 10^{+85}:\\ \;\;\;\;0.5 \cdot NdChar - \frac{NaChar}{-1 - e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{-306}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.35 \cdot 10^{-42}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{elif}\;KbT \leq 3.2 \cdot 10^{+75}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.1 \cdot 10^{+189}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot NdChar - \frac{NaChar}{-1 - e^{\frac{EAccept}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 41.1% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ t_1 := \left(NaChar + NdChar\right) \cdot 0.5\\ t_2 := \frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{if}\;KbT \leq -7 \cdot 10^{+87}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{-306}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 1.35 \cdot 10^{-42}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;KbT \leq 3.2 \cdot 10^{+75}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq 2.7 \cdot 10^{+189}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \left(\frac{NaChar}{KbT} + \frac{NdChar}{KbT}\right) \cdot Vef, t\_1\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
        (t_1 (* (+ NaChar NdChar) 0.5))
        (t_2 (/ NaChar (- (exp (/ Vef KbT)) -1.0))))
   (if (<= KbT -7e+87)
     t_1
     (if (<= KbT 1.9e-306)
       t_0
       (if (<= KbT 1.35e-42)
         t_2
         (if (<= KbT 3.2e+75)
           t_0
           (if (<= KbT 2.7e+189)
             t_2
             (fma -0.25 (* (+ (/ NaChar KbT) (/ NdChar KbT)) Vef) t_1))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((-Ec / KbT)));
	double t_1 = (NaChar + NdChar) * 0.5;
	double t_2 = NaChar / (exp((Vef / KbT)) - -1.0);
	double tmp;
	if (KbT <= -7e+87) {
		tmp = t_1;
	} else if (KbT <= 1.9e-306) {
		tmp = t_0;
	} else if (KbT <= 1.35e-42) {
		tmp = t_2;
	} else if (KbT <= 3.2e+75) {
		tmp = t_0;
	} else if (KbT <= 2.7e+189) {
		tmp = t_2;
	} else {
		tmp = fma(-0.25, (((NaChar / KbT) + (NdChar / KbT)) * Vef), 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(-Ec) / KbT))))
	t_1 = Float64(Float64(NaChar + NdChar) * 0.5)
	t_2 = Float64(NaChar / Float64(exp(Float64(Vef / KbT)) - -1.0))
	tmp = 0.0
	if (KbT <= -7e+87)
		tmp = t_1;
	elseif (KbT <= 1.9e-306)
		tmp = t_0;
	elseif (KbT <= 1.35e-42)
		tmp = t_2;
	elseif (KbT <= 3.2e+75)
		tmp = t_0;
	elseif (KbT <= 2.7e+189)
		tmp = t_2;
	else
		tmp = fma(-0.25, Float64(Float64(Float64(NaChar / KbT) + Float64(NdChar / KbT)) * Vef), t_1);
	end
	return tmp
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -7e+87], t$95$1, If[LessEqual[KbT, 1.9e-306], t$95$0, If[LessEqual[KbT, 1.35e-42], t$95$2, If[LessEqual[KbT, 3.2e+75], t$95$0, If[LessEqual[KbT, 2.7e+189], t$95$2, N[(-0.25 * N[(N[(N[(NaChar / KbT), $MachinePrecision] + N[(NdChar / KbT), $MachinePrecision]), $MachinePrecision] * Vef), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if KbT < -6.99999999999999972e87

   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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 70.5

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

   5. Applied rewrites 70.5%

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

   if -6.99999999999999972e87 < KbT < 1.9e-306 or 1.35e-42 < KbT < 3.19999999999999985e75

   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 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 73.3

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

   5. Applied rewrites 73.3%

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

   6. Taylor expanded in Ec around inf

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

   8. Applied rewrites 48.8%

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

   if 1.9e-306 < KbT < 1.35e-42 or 3.19999999999999985e75 < KbT < 2.69999999999999994e189

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 74.7

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

   5. Applied rewrites 74.7%

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

   6. Taylor expanded in Vef around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 59.8%

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

   if 2.69999999999999994e189 < 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}{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. distribute-lft-out 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) \]

      3. lower-fma.f64 N/A

         \[\leadsto \color{blue}{\mathsf{fma}\left(\frac{-1}{4}, \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}, \frac{1}{2} \cdot NaChar + \frac{1}{2} \cdot NdChar\right)} \]

   5. Applied rewrites 69.2%

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

   6. Taylor expanded in Vef around inf

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

   8. Applied rewrites 69.2%

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

4. Final simplification 57.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;KbT \leq -7 \cdot 10^{+87}:\\ \;\;\;\;\left(NaChar + NdChar\right) \cdot 0.5\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{-306}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.35 \cdot 10^{-42}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{elif}\;KbT \leq 3.2 \cdot 10^{+75}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;KbT \leq 2.7 \cdot 10^{+189}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \left(\frac{NaChar}{KbT} + \frac{NdChar}{KbT}\right) \cdot Vef, \left(NaChar + NdChar\right) \cdot 0.5\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 38.4% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;Ev \leq -6.8 \cdot 10^{+226}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq -5.4 \cdot 10^{+178}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;Ev \leq -3.2 \cdot 10^{-114}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{-mu}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq -1.32 \cdot 10^{-245}:\\ \;\;\;\;\frac{NdChar}{1 + t\_0}\\ \mathbf{elif}\;Ev \leq 1.45 \cdot 10^{-178}:\\ \;\;\;\;\frac{NaChar}{t\_0 - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (exp (/ Vef KbT))))
   (if (<= Ev -6.8e+226)
     (/ NaChar (- (exp (/ Ev KbT)) -1.0))
     (if (<= Ev -5.4e+178)
       (/ NdChar (+ 1.0 (exp (/ mu KbT))))
       (if (<= Ev -3.2e-114)
         (/ NaChar (- (exp (/ (- mu) KbT)) -1.0))
         (if (<= Ev -1.32e-245)
           (/ NdChar (+ 1.0 t_0))
           (if (<= Ev 1.45e-178)
             (/ NaChar (- t_0 -1.0))
             (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = exp((Vef / KbT));
	double tmp;
	if (Ev <= -6.8e+226) {
		tmp = NaChar / (exp((Ev / KbT)) - -1.0);
	} else if (Ev <= -5.4e+178) {
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	} else if (Ev <= -3.2e-114) {
		tmp = NaChar / (exp((-mu / KbT)) - -1.0);
	} else if (Ev <= -1.32e-245) {
		tmp = NdChar / (1.0 + t_0);
	} else if (Ev <= 1.45e-178) {
		tmp = NaChar / (t_0 - -1.0);
	} else {
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = exp((vef / kbt))
    if (ev <= (-6.8d+226)) then
        tmp = nachar / (exp((ev / kbt)) - (-1.0d0))
    else if (ev <= (-5.4d+178)) then
        tmp = ndchar / (1.0d0 + exp((mu / kbt)))
    else if (ev <= (-3.2d-114)) then
        tmp = nachar / (exp((-mu / kbt)) - (-1.0d0))
    else if (ev <= (-1.32d-245)) then
        tmp = ndchar / (1.0d0 + t_0)
    else if (ev <= 1.45d-178) then
        tmp = nachar / (t_0 - (-1.0d0))
    else
        tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = Math.exp((Vef / KbT));
	double tmp;
	if (Ev <= -6.8e+226) {
		tmp = NaChar / (Math.exp((Ev / KbT)) - -1.0);
	} else if (Ev <= -5.4e+178) {
		tmp = NdChar / (1.0 + Math.exp((mu / KbT)));
	} else if (Ev <= -3.2e-114) {
		tmp = NaChar / (Math.exp((-mu / KbT)) - -1.0);
	} else if (Ev <= -1.32e-245) {
		tmp = NdChar / (1.0 + t_0);
	} else if (Ev <= 1.45e-178) {
		tmp = NaChar / (t_0 - -1.0);
	} else {
		tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = math.exp((Vef / KbT))
	tmp = 0
	if Ev <= -6.8e+226:
		tmp = NaChar / (math.exp((Ev / KbT)) - -1.0)
	elif Ev <= -5.4e+178:
		tmp = NdChar / (1.0 + math.exp((mu / KbT)))
	elif Ev <= -3.2e-114:
		tmp = NaChar / (math.exp((-mu / KbT)) - -1.0)
	elif Ev <= -1.32e-245:
		tmp = NdChar / (1.0 + t_0)
	elif Ev <= 1.45e-178:
		tmp = NaChar / (t_0 - -1.0)
	else:
		tmp = NdChar / (1.0 + math.exp((EDonor / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp(Float64(Vef / KbT))
	tmp = 0.0
	if (Ev <= -6.8e+226)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) - -1.0));
	elseif (Ev <= -5.4e+178)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))));
	elseif (Ev <= -3.2e-114)
		tmp = Float64(NaChar / Float64(exp(Float64(Float64(-mu) / KbT)) - -1.0));
	elseif (Ev <= -1.32e-245)
		tmp = Float64(NdChar / Float64(1.0 + t_0));
	elseif (Ev <= 1.45e-178)
		tmp = Float64(NaChar / Float64(t_0 - -1.0));
	else
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp((Vef / KbT));
	tmp = 0.0;
	if (Ev <= -6.8e+226)
		tmp = NaChar / (exp((Ev / KbT)) - -1.0);
	elseif (Ev <= -5.4e+178)
		tmp = NdChar / (1.0 + exp((mu / KbT)));
	elseif (Ev <= -3.2e-114)
		tmp = NaChar / (exp((-mu / KbT)) - -1.0);
	elseif (Ev <= -1.32e-245)
		tmp = NdChar / (1.0 + t_0);
	elseif (Ev <= 1.45e-178)
		tmp = NaChar / (t_0 - -1.0);
	else
		tmp = NdChar / (1.0 + exp((EDonor / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[Ev, -6.8e+226], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -5.4e+178], N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -3.2e-114], N[(NaChar / N[(N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -1.32e-245], N[(NdChar / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 1.45e-178], N[(NaChar / N[(t$95$0 - -1.0), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 6 regimes

2. if Ev < -6.79999999999999958e226

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 61.0

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

   5. Applied rewrites 61.0%

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

   6. Taylor expanded in Ev around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Ev}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 61.0%

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

   if -6.79999999999999958e226 < Ev < -5.40000000000000036e178

   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 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 72.1

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

   5. Applied rewrites 72.1%

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

   6. Taylor expanded in mu around inf

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

   8. Applied rewrites 47.3%

      \[\leadsto \frac{NdChar}{e^{\frac{mu}{KbT}} + 1} \]

   if -5.40000000000000036e178 < Ev < -3.2000000000000002e-114

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 67.0

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

   5. Applied rewrites 67.0%

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

   6. Taylor expanded in mu around inf

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

   8. Applied rewrites 45.1%

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

   if -3.2000000000000002e-114 < Ev < -1.32e-245

   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 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 57.6

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

   5. Applied rewrites 57.6%

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

   6. Taylor expanded in Vef around inf

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

   8. Applied rewrites 42.3%

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

   if -1.32e-245 < Ev < 1.4499999999999999e-178

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 56.1

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

   5. Applied rewrites 56.1%

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

   6. Taylor expanded in Vef around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 41.6%

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

   if 1.4499999999999999e-178 < Ev

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 68.5

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

   5. Applied rewrites 68.5%

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

   6. Taylor expanded in EDonor around inf

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

   8. Applied rewrites 43.9%

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

4. Final simplification 44.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -6.8 \cdot 10^{+226}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq -5.4 \cdot 10^{+178}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;Ev \leq -3.2 \cdot 10^{-114}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{-mu}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq -1.32 \cdot 10^{-245}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;Ev \leq 1.45 \cdot 10^{-178}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 68.3% accurate, 1.9× speedup

Math

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((((mu + Vef) + EDonor) - Ec) / KbT)))
	tmp = 0
	if NdChar <= -1.6e-42:
		tmp = t_0
	elif NdChar <= 8.8e-198:
		tmp = NaChar / (math.exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0)
	else:
		tmp = 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(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT))))
	tmp = 0.0
	if (NdChar <= -1.6e-42)
		tmp = t_0;
	elseif (NdChar <= 8.8e-198)
		tmp = Float64(NaChar / Float64(exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) - mu) / KbT)) - -1.0));
	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 / (1.0 + exp(((((mu + Vef) + EDonor) - Ec) / KbT)));
	tmp = 0.0;
	if (NdChar <= -1.6e-42)
		tmp = t_0;
	elseif (NdChar <= 8.8e-198)
		tmp = NaChar / (exp(((((Ev + Vef) + EAccept) - mu) / KbT)) - -1.0);
	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[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(N[(mu + Vef), $MachinePrecision] + EDonor), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.6e-42], t$95$0, If[LessEqual[NdChar, 8.8e-198], N[(NaChar / N[(N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -1.60000000000000012e-42 or 8.8000000000000001e-198 < 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 NaChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 72.2

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

   5. Applied rewrites 72.2%

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

   if -1.60000000000000012e-42 < NdChar < 8.8000000000000001e-198

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 79.7

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

   5. Applied rewrites 79.7%

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

4. Final simplification 74.4%

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

Alternative 15: 40.0% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -3.3 \cdot 10^{+88}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq 1.45 \cdot 10^{-178}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -3.3e+88)
   (/ NaChar (- (exp (/ Ev KbT)) -1.0))
   (if (<= Ev 1.45e-178)
     (/ NaChar (- (exp (/ Vef KbT)) -1.0))
     (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -3.3e+88], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 1.45e-178], N[(NaChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if Ev < -3.3000000000000003e88

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 59.8

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

   5. Applied rewrites 59.8%

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

   6. Taylor expanded in Ev around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Ev}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 54.2%

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

   if -3.3000000000000003e88 < Ev < 1.4499999999999999e-178

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 63.3

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

   5. Applied rewrites 63.3%

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

   6. Taylor expanded in Vef around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 45.5%

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

   if 1.4499999999999999e-178 < Ev

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 68.5

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

   5. Applied rewrites 68.5%

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

   6. Taylor expanded in EDonor around inf

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

   8. Applied rewrites 43.9%

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

4. Final simplification 46.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -3.3 \cdot 10^{+88}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq 1.45 \cdot 10^{-178}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 39.2% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -2 \cdot 10^{+93}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq 6 \cdot 10^{-208}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Ev -2e+93)
   (/ NaChar (- (exp (/ Ev KbT)) -1.0))
   (if (<= Ev 6e-208)
     (/ NaChar (- (exp (/ Vef KbT)) -1.0))
     (/ NaChar (- (exp (/ EAccept KbT)) -1.0)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -2.00000000000000009e93

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 58.5

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

   5. Applied rewrites 58.5%

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

   6. Taylor expanded in Ev around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Ev}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 52.3%

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

   if -2.00000000000000009e93 < Ev < 5.99999999999999972e-208

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

      \[\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 64.1

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

   5. Applied rewrites 64.1%

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

   6. Taylor expanded in Vef around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Vef}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 46.3%

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

   if 5.99999999999999972e-208 < Ev

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

      \[\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 58.2

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

   5. Applied rewrites 58.2%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 40.1%

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

4. Final simplification 45.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -2 \cdot 10^{+93}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{elif}\;Ev \leq 6 \cdot 10^{-208}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 37.9% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ev \leq -1.25 \cdot 10^{+88}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -1.24999999999999999e88

   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}{\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 59.8

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

   5. Applied rewrites 59.8%

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

   6. Taylor expanded in Ev around inf

      \[\leadsto \frac{NaChar}{e^{\frac{Ev}{KbT}} + 1} \]
   7. Step-by-step derivation

   8. Applied rewrites 54.2%

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

   if -1.24999999999999999e88 < Ev

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

      \[\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. lower-+.f64 N/A

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

      8. +-commutative N/A

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

      9. lower-+.f64 61.1

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

   5. Applied rewrites 61.1%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 37.3%

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

4. Final simplification 40.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;Ev \leq -1.25 \cdot 10^{+88}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} - -1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} - -1}\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 23.3% accurate, 15.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -3.8 \cdot 10^{-52}:\\ \;\;\;\;0.5 \cdot NdChar\\ \mathbf{elif}\;NdChar \leq 130000000:\\ \;\;\;\;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 -3.8e-52)
   (* 0.5 NdChar)
   (if (<= NdChar 130000000.0) (* 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 <= -3.8e-52) {
		tmp = 0.5 * NdChar;
	} else if (NdChar <= 130000000.0) {
		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 <= (-3.8d-52)) then
        tmp = 0.5d0 * ndchar
    else if (ndchar <= 130000000.0d0) 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 <= -3.8e-52) {
		tmp = 0.5 * NdChar;
	} else if (NdChar <= 130000000.0) {
		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 <= -3.8e-52:
		tmp = 0.5 * NdChar
	elif NdChar <= 130000000.0:
		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 <= -3.8e-52)
		tmp = Float64(0.5 * NdChar);
	elseif (NdChar <= 130000000.0)
		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 <= -3.8e-52)
		tmp = 0.5 * NdChar;
	elseif (NdChar <= 130000000.0)
		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, -3.8e-52], N[(0.5 * NdChar), $MachinePrecision], If[LessEqual[NdChar, 130000000.0], N[(0.5 * NaChar), $MachinePrecision], N[(0.5 * NdChar), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if NdChar < -3.8000000000000003e-52 or 1.3e8 < 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 NaChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 73.4

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

   5. Applied rewrites 73.4%

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

   6. Taylor expanded in KbT around inf

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

   8. Applied rewrites 24.6%

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

   if -3.8000000000000003e-52 < NdChar < 1.3e8

   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. +-commutative N/A

         \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

      2. distribute-lft-out N/A

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

      3. lower-*.f64 N/A

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

      4. lower-+.f64 29.3

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

   5. Applied rewrites 29.3%

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

   6. Taylor expanded in NaChar around inf

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

   8. Applied rewrites 27.7%

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

Alternative 19: 27.8% 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. +-commutative N/A

      \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

   2. distribute-lft-out N/A

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

   3. lower-*.f64 N/A

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

   4. lower-+.f64 28.2

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

5. Applied rewrites 28.2%

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

6. Final simplification 28.2%

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

Alternative 20: 18.4% 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. +-commutative N/A

      \[\leadsto \color{blue}{\frac{1}{2} \cdot NdChar + \frac{1}{2} \cdot NaChar} \]

   2. distribute-lft-out N/A

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

   3. lower-*.f64 N/A

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

   4. lower-+.f64 28.2

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

5. Applied rewrites 28.2%

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

6. Taylor expanded in NaChar around inf

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

8. Applied rewrites 19.1%

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

Reproduce

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