Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 9.9s

Alternatives: 24

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = 0.8234246956975825
  2. Ec = 8103490570583459000.0
  3. Vef = 2.0045908432963616e-152
  4. EDonor = -2.5775995547737135e+109
  5. mu = -3.14042581315389e-5
  6. KbT = 4.679379359652243e-129
  7. NaChar = -0.32186044654788165
  8. Ev = -1.1125926404537815e+307
  9. EAccept = 9.69350151455827e+45

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}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}} - \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 (+ 1.0 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT))))
  (/ 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 / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (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 / (1.0d0 + exp((((eaccept + (ev + vef)) - mu) / kbt)))) - (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 / (1.0 + Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NaChar / (1.0 + math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (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(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)))) - 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 / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (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[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Ev + Vef), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $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}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}} \]
4. Add Preprocessing

Alternative 2: 74.2% accurate, 0.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

   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.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 78.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 EDonor around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 72.0

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

   8. Applied rewrites 72.0%

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

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

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 90.2

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

   5. Applied rewrites 90.2%

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

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

   1. Initial program 100.0%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 77.6

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

   5. Applied rewrites 77.6%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. lower-+.f64 71.6

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

   8. Applied rewrites 71.6%

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

4. Final simplification 76.5%

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

Alternative 3: 74.0% accurate, 0.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

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

   1. Initial program 100.0%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 80.6

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

   5. Applied rewrites 80.6%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. lower-+.f64 74.4

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

   8. Applied rewrites 74.4%

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

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

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 87.0

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

   5. Applied rewrites 87.0%

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

4. Final simplification 77.9%

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

Alternative 4: 36.4% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(NaChar + NdChar\right) \cdot 0.5\\ t_1 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}}\\ \mathbf{if}\;t\_1 \leq -2 \cdot 10^{-181}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 5 \cdot 10^{-285}:\\ \;\;\;\;\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 (+ 1.0 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT))))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -2e-181)
     t_0
     (if (<= t_1 5e-285)
       (/
        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 / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-181) {
		tmp = t_0;
	} else if (t_1 <= 5e-285) {
		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 / (1.0d0 + exp((((eaccept + (ev + vef)) - mu) / kbt)))) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_1 <= (-2d-181)) then
        tmp = t_0
    else if (t_1 <= 5d-285) 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 / (1.0 + Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-181) {
		tmp = t_0;
	} else if (t_1 <= 5e-285) {
		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 / (1.0 + math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))))
	tmp = 0
	if t_1 <= -2e-181:
		tmp = t_0
	elif t_1 <= 5e-285:
		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(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)))) - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)))))
	tmp = 0.0
	if (t_1 <= -2e-181)
		tmp = t_0;
	elseif (t_1 <= 5e-285)
		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 / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	tmp = 0.0;
	if (t_1 <= -2e-181)
		tmp = t_0;
	elseif (t_1 <= 5e-285)
		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[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Ev + Vef), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $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-181], t$95$0, If[LessEqual[t$95$1, 5e-285], 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))))) < -2.00000000000000009e-181 or 5.00000000000000018e-285 < (+.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 33.4

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

   5. Applied rewrites 33.4%

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

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

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 90.7

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

   5. Applied rewrites 90.7%

      \[\leadsto \color{blue}{\frac{NaChar}{e^{\frac{\left(\left(Ev + Vef\right) + EAccept\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 41.3%

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

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

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -1.99999999999999989e-201 or 2.00000000000000003e-221 < (+.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 33.9

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

   5. Applied rewrites 33.9%

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

   if -1.99999999999999989e-201 < (+.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.00000000000000003e-221

   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.5

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

   5. Applied rewrites 3.5%

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

   7. Applied rewrites 5.9%

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

   8. Taylor expanded in NaChar around -inf

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

   10. Applied rewrites 36.7%

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

4. Final simplification 34.6%

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

Alternative 6: 35.5% accurate, 0.4× speedup

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -2e-231 or 1.99999999999999997e-170 < (+.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 34.0

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

   5. Applied rewrites 34.0%

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

   if -2e-231 < (+.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.99999999999999997e-170

   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 4.0

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

   5. Applied rewrites 4.0%

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

   7. Applied rewrites 5.8%

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

   8. Taylor expanded in NdChar around -inf

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

   10. Applied rewrites 29.1%

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

4. Final simplification 32.8%

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

Alternative 7: 33.5% accurate, 0.5× speedup

Math

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

FPCore

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

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar + NdChar) * 0.5;
	double t_1 = (NaChar / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-231) {
		tmp = t_0;
	} else if (t_1 <= 4e-244) {
		tmp = (1.0 / ((NdChar - NaChar) / (NdChar * NdChar))) * 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 / (1.0d0 + exp((((eaccept + (ev + vef)) - mu) / kbt)))) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_1 <= (-2d-231)) then
        tmp = t_0
    else if (t_1 <= 4d-244) then
        tmp = (1.0d0 / ((ndchar - nachar) / (ndchar * ndchar))) * 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 / (1.0 + Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-231) {
		tmp = t_0;
	} else if (t_1 <= 4e-244) {
		tmp = (1.0 / ((NdChar - NaChar) / (NdChar * NdChar))) * 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 / (1.0 + math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))))
	tmp = 0
	if t_1 <= -2e-231:
		tmp = t_0
	elif t_1 <= 4e-244:
		tmp = (1.0 / ((NdChar - NaChar) / (NdChar * NdChar))) * 0.5
	else:
		tmp = t_0
	return tmp

Julia

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 (/.f64 NdChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (neg.f64 (-.f64 (-.f64 (-.f64 Ec Vef) EDonor) mu)) KbT)))) (/.f64 NaChar (+.f64 #s(literal 1 binary64) (exp.f64 (/.f64 (+.f64 (+.f64 (+.f64 Ev Vef) EAccept) (neg.f64 mu)) KbT))))) < -2e-231 or 3.9999999999999997e-244 < (+.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 32.9

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

   5. Applied rewrites 32.9%

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

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

   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.0

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

   5. Applied rewrites 3.0%

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

   7. Applied rewrites 6.2%

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

   8. Taylor expanded in NdChar around inf

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

   10. Applied rewrites 25.0%

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

4. Final simplification 31.2%

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

Alternative 8: 33.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(NaChar + NdChar\right) \cdot 0.5\\ t_1 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{KbT}}}\\ \mathbf{if}\;t\_1 \leq -2 \cdot 10^{-257}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;t\_1 \leq 10^{-287}:\\ \;\;\;\;\frac{-0.5 \cdot \left(NaChar \cdot NaChar\right)}{NdChar - NaChar}\\ \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 (+ 1.0 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT))))
          (/ NdChar (- -1.0 (exp (/ (- mu (- (- Ec Vef) EDonor)) KbT)))))))
   (if (<= t_1 -2e-257)
     t_0
     (if (<= t_1 1e-287)
       (/ (* -0.5 (* NaChar NaChar)) (- NdChar NaChar))
       t_0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar + NdChar) * 0.5;
	double t_1 = (NaChar / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-257) {
		tmp = t_0;
	} else if (t_1 <= 1e-287) {
		tmp = (-0.5 * (NaChar * NaChar)) / (NdChar - NaChar);
	} 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 / (1.0d0 + exp((((eaccept + (ev + vef)) - mu) / kbt)))) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - edonor)) / kbt))))
    if (t_1 <= (-2d-257)) then
        tmp = t_0
    else if (t_1 <= 1d-287) then
        tmp = ((-0.5d0) * (nachar * nachar)) / (ndchar - nachar)
    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 / (1.0 + Math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	double tmp;
	if (t_1 <= -2e-257) {
		tmp = t_0;
	} else if (t_1 <= 1e-287) {
		tmp = (-0.5 * (NaChar * NaChar)) / (NdChar - NaChar);
	} 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 / (1.0 + math.exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - EDonor)) / KbT))))
	tmp = 0
	if t_1 <= -2e-257:
		tmp = t_0
	elif t_1 <= 1e-287:
		tmp = (-0.5 * (NaChar * NaChar)) / (NdChar - NaChar)
	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(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT)))) - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - EDonor)) / KbT)))))
	tmp = 0.0
	if (t_1 <= -2e-257)
		tmp = t_0;
	elseif (t_1 <= 1e-287)
		tmp = Float64(Float64(-0.5 * Float64(NaChar * NaChar)) / Float64(NdChar - NaChar));
	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 / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)))) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	tmp = 0.0;
	if (t_1 <= -2e-257)
		tmp = t_0;
	elseif (t_1 <= 1e-287)
		tmp = (-0.5 * (NaChar * NaChar)) / (NdChar - NaChar);
	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[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Ev + Vef), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $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-257], t$95$0, If[LessEqual[t$95$1, 1e-287], N[(N[(-0.5 * N[(NaChar * NaChar), $MachinePrecision]), $MachinePrecision] / N[(NdChar - NaChar), $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))))) < -2e-257 or 1.00000000000000002e-287 < (+.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 32.1

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

   5. Applied rewrites 32.1%

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

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

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

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

   5. Applied rewrites 2.7%

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

   7. Applied rewrites 6.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 NdChar around 0

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

   10. Applied rewrites 27.4%

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

4. Final simplification 31.2%

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

Alternative 9: 33.5% accurate, 0.5× speedup

Math

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

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

   5. Applied rewrites 32.9%

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

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

   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.0

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

   5. Applied rewrites 3.0%

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

   7. Applied rewrites 6.2%

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

   9. Applied rewrites 6.2%

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

   10. Taylor expanded in NdChar around inf

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

   12. Applied rewrites 23.7%

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

4. Final simplification 30.9%

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

Alternative 10: 93.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;Vef \leq -4.3 \cdot 10^{+170}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{\left(mu + Vef\right) - Ec}{KbT}} - -1} - \frac{NaChar}{-1 - t\_0}\\ \mathbf{elif}\;Vef \leq 1.52 \cdot 10^{+147}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + Ev\right) - mu}{KbT}}} - \frac{NdChar}{-1 - e^{\frac{\left(mu + EDonor\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + t\_0} - \frac{NdChar}{-1 - e^{\frac{mu - \left(\left(Ec - Vef\right) - EDonor\right)}{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 (<= Vef -4.3e+170)
     (-
      (/ NdChar (- (exp (/ (- (+ mu Vef) Ec) KbT)) -1.0))
      (/ NaChar (- -1.0 t_0)))
     (if (<= Vef 1.52e+147)
       (-
        (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept Ev) mu) KbT))))
        (/ NdChar (- -1.0 (exp (/ (- (+ mu EDonor) Ec) KbT)))))
       (-
        (/ NaChar (+ 1.0 t_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) {
	double t_0 = exp((Vef / KbT));
	double tmp;
	if (Vef <= -4.3e+170) {
		tmp = (NdChar / (exp((((mu + Vef) - Ec) / KbT)) - -1.0)) - (NaChar / (-1.0 - t_0));
	} else if (Vef <= 1.52e+147) {
		tmp = (NaChar / (1.0 + exp((((EAccept + Ev) - mu) / KbT)))) - (NdChar / (-1.0 - exp((((mu + EDonor) - Ec) / KbT))));
	} else {
		tmp = (NaChar / (1.0 + t_0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - 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 (vef <= (-4.3d+170)) then
        tmp = (ndchar / (exp((((mu + vef) - ec) / kbt)) - (-1.0d0))) - (nachar / ((-1.0d0) - t_0))
    else if (vef <= 1.52d+147) then
        tmp = (nachar / (1.0d0 + exp((((eaccept + ev) - mu) / kbt)))) - (ndchar / ((-1.0d0) - exp((((mu + edonor) - ec) / kbt))))
    else
        tmp = (nachar / (1.0d0 + t_0)) - (ndchar / ((-1.0d0) - exp(((mu - ((ec - vef) - 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 (Vef <= -4.3e+170) {
		tmp = (NdChar / (Math.exp((((mu + Vef) - Ec) / KbT)) - -1.0)) - (NaChar / (-1.0 - t_0));
	} else if (Vef <= 1.52e+147) {
		tmp = (NaChar / (1.0 + Math.exp((((EAccept + Ev) - mu) / KbT)))) - (NdChar / (-1.0 - Math.exp((((mu + EDonor) - Ec) / KbT))));
	} else {
		tmp = (NaChar / (1.0 + t_0)) - (NdChar / (-1.0 - Math.exp(((mu - ((Ec - Vef) - 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 Vef <= -4.3e+170:
		tmp = (NdChar / (math.exp((((mu + Vef) - Ec) / KbT)) - -1.0)) - (NaChar / (-1.0 - t_0))
	elif Vef <= 1.52e+147:
		tmp = (NaChar / (1.0 + math.exp((((EAccept + Ev) - mu) / KbT)))) - (NdChar / (-1.0 - math.exp((((mu + EDonor) - Ec) / KbT))))
	else:
		tmp = (NaChar / (1.0 + t_0)) - (NdChar / (-1.0 - math.exp(((mu - ((Ec - Vef) - 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 (Vef <= -4.3e+170)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)) - -1.0)) - Float64(NaChar / Float64(-1.0 - t_0)));
	elseif (Vef <= 1.52e+147)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Ev) - mu) / KbT)))) - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(Float64(mu + EDonor) - Ec) / KbT)))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + t_0)) - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - 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 (Vef <= -4.3e+170)
		tmp = (NdChar / (exp((((mu + Vef) - Ec) / KbT)) - -1.0)) - (NaChar / (-1.0 - t_0));
	elseif (Vef <= 1.52e+147)
		tmp = (NaChar / (1.0 + exp((((EAccept + Ev) - mu) / KbT)))) - (NdChar / (-1.0 - exp((((mu + EDonor) - Ec) / KbT))));
	else
		tmp = (NaChar / (1.0 + t_0)) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - 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[Vef, -4.3e+170], N[(N[(NdChar / N[(N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision] - N[(NaChar / N[(-1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.52e+147], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(NdChar / N[(-1.0 - N[Exp[N[(N[(N[(mu + EDonor), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + t$95$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. Split input into 3 regimes

2. if Vef < -4.2999999999999999e170

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

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 82.7

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

   8. Applied rewrites 82.7%

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

   if -4.2999999999999999e170 < Vef < 1.51999999999999992e147

   1. Initial program 100.0%

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

   3. Taylor expanded in Vef around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-/.f64 N/A

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

      4. +-commutative N/A

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

      5. lower-+.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. +-commutative N/A

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

      10. lower-+.f64 N/A

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

      11. lower-/.f64 N/A

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

      12. +-commutative N/A

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

      13. lower-+.f64 N/A

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

   5. Applied rewrites 96.8%

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

   if 1.51999999999999992e147 < Vef

   1. Initial program 100.0%

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

   3. Taylor expanded in Vef around inf

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

      1. lower-/.f64 96.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 96.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}}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 95.2%

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

Alternative 11: 73.1% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if Ev < -3.04999999999999999e84

   1. Initial program 100.0%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 97.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{Ev}{KbT}}}} \]

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

   if -3.04999999999999999e84 < Ev < -3.10000000000000002e-195

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

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

   if -3.10000000000000002e-195 < 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 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 73.6

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

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

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

Alternative 12: 63.3% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (- (exp (/ (- Ec) KbT)) -1.0))))
   (if (<= KbT -9e+181)
     (- t_0 (/ NaChar (- -1.0 (exp (/ Vef KbT)))))
     (if (<= KbT -1.6e-7)
       (/
        (* NaChar NdChar)
        (fma (exp (/ (- (+ (+ mu Vef) EDonor) Ec) KbT)) NaChar NaChar))
       (if (<= KbT 1.8e+109)
         (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT))))
         (- t_0 (/ NaChar (- -1.0 (exp (/ Ev KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (exp((-Ec / KbT)) - -1.0);
	double tmp;
	if (KbT <= -9e+181) {
		tmp = t_0 - (NaChar / (-1.0 - exp((Vef / KbT))));
	} else if (KbT <= -1.6e-7) {
		tmp = (NaChar * NdChar) / fma(exp(((((mu + Vef) + EDonor) - Ec) / KbT)), NaChar, NaChar);
	} else if (KbT <= 1.8e+109) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)));
	} else {
		tmp = t_0 - (NaChar / (-1.0 - exp((Ev / KbT))));
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(exp(Float64(Float64(-Ec) / KbT)) - -1.0))
	tmp = 0.0
	if (KbT <= -9e+181)
		tmp = Float64(t_0 - Float64(NaChar / Float64(-1.0 - exp(Float64(Vef / KbT)))));
	elseif (KbT <= -1.6e-7)
		tmp = Float64(Float64(NaChar * NdChar) / fma(exp(Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT)), NaChar, NaChar));
	elseif (KbT <= 1.8e+109)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))));
	else
		tmp = Float64(t_0 - Float64(NaChar / Float64(-1.0 - exp(Float64(Ev / KbT)))));
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -9e181

   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 93.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 93.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}}}} \]

   6. Taylor expanded in Ec around inf

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

      1. mul-1-neg N/A

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

      2. lower-neg.f64 85.9

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

   8. Applied rewrites 85.9%

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

   if -9e181 < KbT < -1.6e-7

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 86.3%

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

   6. Taylor expanded in NdChar around inf

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

   8. Applied rewrites 74.4%

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

   if -1.6e-7 < KbT < 1.8e109

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 70.7

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

   5. Applied rewrites 70.7%

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

   if 1.8e109 < KbT

   1. Initial program 100.0%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 86.8

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

   5. Applied rewrites 86.8%

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

   6. Taylor expanded in Ec around inf

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

      1. mul-1-neg N/A

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

      2. lower-neg.f64 66.1

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

   8. Applied rewrites 66.1%

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

4. Final simplification 72.6%

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

Alternative 13: 63.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{-Ec}{KbT}} - -1} - \frac{NaChar}{-1 - e^{\frac{Ev}{KbT}}}\\ \mathbf{if}\;KbT \leq -1.15 \cdot 10^{+182}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;KbT \leq -1.6 \cdot 10^{-7}:\\ \;\;\;\;\frac{NaChar \cdot NdChar}{\mathsf{fma}\left(e^{\frac{\left(\left(mu + Vef\right) + EDonor\right) - Ec}{KbT}}, NaChar, NaChar\right)}\\ \mathbf{elif}\;KbT \leq 1.8 \cdot 10^{+109}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - 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
         (-
          (/ NdChar (- (exp (/ (- Ec) KbT)) -1.0))
          (/ NaChar (- -1.0 (exp (/ Ev KbT)))))))
   (if (<= KbT -1.15e+182)
     t_0
     (if (<= KbT -1.6e-7)
       (/
        (* NaChar NdChar)
        (fma (exp (/ (- (+ (+ mu Vef) EDonor) Ec) KbT)) NaChar NaChar))
       (if (<= KbT 1.8e+109)
         (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Ev Vef)) 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 = (NdChar / (exp((-Ec / KbT)) - -1.0)) - (NaChar / (-1.0 - exp((Ev / KbT))));
	double tmp;
	if (KbT <= -1.15e+182) {
		tmp = t_0;
	} else if (KbT <= -1.6e-7) {
		tmp = (NaChar * NdChar) / fma(exp(((((mu + Vef) + EDonor) - Ec) / KbT)), NaChar, NaChar);
	} else if (KbT <= 1.8e+109) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(exp(Float64(Float64(-Ec) / KbT)) - -1.0)) - Float64(NaChar / Float64(-1.0 - exp(Float64(Ev / KbT)))))
	tmp = 0.0
	if (KbT <= -1.15e+182)
		tmp = t_0;
	elseif (KbT <= -1.6e-7)
		tmp = Float64(Float64(NaChar * NdChar) / fma(exp(Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT)), NaChar, NaChar));
	elseif (KbT <= 1.8e+109)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))));
	else
		tmp = t_0;
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.15e182 or 1.8e109 < KbT

   1. Initial program 100.0%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 88.9

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

   5. Applied rewrites 88.9%

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

   6. Taylor expanded in Ec around inf

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

      1. mul-1-neg N/A

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

      2. lower-neg.f64 74.8

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

   8. Applied rewrites 74.8%

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

   if -1.15e182 < KbT < -1.6e-7

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 86.3%

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

   6. Taylor expanded in NdChar around inf

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

   8. Applied rewrites 74.4%

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

   if -1.6e-7 < KbT < 1.8e109

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 70.7

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

   5. Applied rewrites 70.7%

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

4. Final simplification 72.3%

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

Alternative 14: 73.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if Ev < -1.3499999999999999e57

   1. Initial program 100.0%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 96.0

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

   5. Applied rewrites 96.0%

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

   if -1.3499999999999999e57 < 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 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 72.4

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

   5. Applied rewrites 72.4%

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

4. Final simplification 76.8%

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

Alternative 15: 71.4% accurate, 1.0× speedup

Math

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

FPCore

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Ev <= -1.35e+57)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)) - -1.0)) - Float64(NaChar / Float64(-1.0 - exp(Float64(Ev / KbT)))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) - Float64(NdChar / Float64(-1.0 - exp(Float64(Float64(mu - Float64(Float64(Ec - Vef) - 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 <= -1.35e+57)
		tmp = (NdChar / (exp((((mu + Vef) - Ec) / KbT)) - -1.0)) - (NaChar / (-1.0 - exp((Ev / KbT))));
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) - (NdChar / (-1.0 - exp(((mu - ((Ec - Vef) - EDonor)) / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -1.35e+57], N[(N[(NdChar / N[(N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision] - N[(NaChar / N[(-1.0 - N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $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. Split input into 2 regimes

2. if Ev < -1.3499999999999999e57

   1. Initial program 100.0%

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

   3. Taylor expanded in Ev around inf

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

      1. lower-/.f64 96.0

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

   5. Applied rewrites 96.0%

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

   6. Taylor expanded in EDonor around 0

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

      1. lower--.f64 N/A

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

      2. lower-+.f64 90.3

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

   8. Applied rewrites 90.3%

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

   if -1.3499999999999999e57 < 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 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 72.4

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

   5. Applied rewrites 72.4%

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

4. Final simplification 75.8%

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

Alternative 16: 63.3% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT)))
        (t_1 (/ (- (+ (+ mu Vef) EDonor) Ec) KbT)))
   (if (<= KbT -1.36e+182)
     (- (* 0.5 NdChar) (/ NaChar (- -1.0 t_0)))
     (if (<= KbT -1.6e-7)
       (/ (* NaChar NdChar) (fma (exp t_1) NaChar NaChar))
       (if (<= KbT 4.5e+232)
         (/ NaChar (+ 1.0 t_0))
         (fma
          -0.25
          (fma NaChar (/ EAccept KbT) (* t_1 NdChar))
          (* (+ 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) {
	double t_0 = exp((((EAccept + (Ev + Vef)) - mu) / KbT));
	double t_1 = (((mu + Vef) + EDonor) - Ec) / KbT;
	double tmp;
	if (KbT <= -1.36e+182) {
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - t_0));
	} else if (KbT <= -1.6e-7) {
		tmp = (NaChar * NdChar) / fma(exp(t_1), NaChar, NaChar);
	} else if (KbT <= 4.5e+232) {
		tmp = NaChar / (1.0 + t_0);
	} else {
		tmp = fma(-0.25, fma(NaChar, (EAccept / KbT), (t_1 * NdChar)), ((NaChar + NdChar) * 0.5));
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))
	t_1 = Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT)
	tmp = 0.0
	if (KbT <= -1.36e+182)
		tmp = Float64(Float64(0.5 * NdChar) - Float64(NaChar / Float64(-1.0 - t_0)));
	elseif (KbT <= -1.6e-7)
		tmp = Float64(Float64(NaChar * NdChar) / fma(exp(t_1), NaChar, NaChar));
	elseif (KbT <= 4.5e+232)
		tmp = Float64(NaChar / Float64(1.0 + t_0));
	else
		tmp = fma(-0.25, fma(NaChar, Float64(EAccept / KbT), Float64(t_1 * NdChar)), Float64(Float64(NaChar + NdChar) * 0.5));
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -1.36000000000000012e182

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 79.9

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

   5. Applied rewrites 79.9%

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

   if -1.36000000000000012e182 < KbT < -1.6e-7

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 86.3%

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

   6. Taylor expanded in NdChar around inf

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

   8. Applied rewrites 74.4%

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

   if -1.6e-7 < KbT < 4.4999999999999998e232

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 69.5

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

   5. Applied rewrites 69.5%

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

   if 4.4999999999999998e232 < 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 73.0%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 73.0%

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

4. Final simplification 71.7%

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

Alternative 17: 63.2% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ (- (+ (+ mu Vef) EDonor) Ec) KbT))
        (t_1 (+ EAccept (+ Ev Vef))))
   (if (<= KbT -1.36e+182)
     (- (* 0.5 NdChar) (/ NaChar (- -1.0 (exp (/ t_1 KbT)))))
     (if (<= KbT -1.6e-7)
       (/ (* NaChar NdChar) (fma (exp t_0) NaChar NaChar))
       (if (<= KbT 4.5e+232)
         (/ NaChar (+ 1.0 (exp (/ (- t_1 mu) KbT))))
         (fma
          -0.25
          (fma NaChar (/ EAccept KbT) (* t_0 NdChar))
          (* (+ 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) {
	double t_0 = (((mu + Vef) + EDonor) - Ec) / KbT;
	double t_1 = EAccept + (Ev + Vef);
	double tmp;
	if (KbT <= -1.36e+182) {
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - exp((t_1 / KbT))));
	} else if (KbT <= -1.6e-7) {
		tmp = (NaChar * NdChar) / fma(exp(t_0), NaChar, NaChar);
	} else if (KbT <= 4.5e+232) {
		tmp = NaChar / (1.0 + exp(((t_1 - mu) / KbT)));
	} else {
		tmp = fma(-0.25, fma(NaChar, (EAccept / KbT), (t_0 * NdChar)), ((NaChar + NdChar) * 0.5));
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT)
	t_1 = Float64(EAccept + Float64(Ev + Vef))
	tmp = 0.0
	if (KbT <= -1.36e+182)
		tmp = Float64(Float64(0.5 * NdChar) - Float64(NaChar / Float64(-1.0 - exp(Float64(t_1 / KbT)))));
	elseif (KbT <= -1.6e-7)
		tmp = Float64(Float64(NaChar * NdChar) / fma(exp(t_0), NaChar, NaChar));
	elseif (KbT <= 4.5e+232)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(t_1 - mu) / KbT))));
	else
		tmp = fma(-0.25, fma(NaChar, Float64(EAccept / KbT), Float64(t_0 * NdChar)), Float64(Float64(NaChar + NdChar) * 0.5));
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 4 regimes

2. if KbT < -1.36000000000000012e182

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 79.9

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

   5. Applied rewrites 79.9%

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

   6. Taylor expanded in mu around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-+.f64 79.3

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

   8. Applied rewrites 79.3%

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

   if -1.36000000000000012e182 < KbT < -1.6e-7

   1. Initial program 100.0%

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

   3. Taylor expanded in NaChar around inf

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

   5. Applied rewrites 86.3%

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

   6. Taylor expanded in NdChar around inf

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

   8. Applied rewrites 74.4%

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

   if -1.6e-7 < KbT < 4.4999999999999998e232

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 69.5

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

   5. Applied rewrites 69.5%

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

   if 4.4999999999999998e232 < 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 73.0%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 73.0%

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

4. Final simplification 71.6%

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

Alternative 18: 64.7% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ EAccept (+ Ev Vef))))
   (if (<= KbT -1.45e+186)
     (- (* 0.5 NdChar) (/ NaChar (- -1.0 (exp (/ t_0 KbT)))))
     (if (<= KbT 4.5e+232)
       (/ NaChar (+ 1.0 (exp (/ (- t_0 mu) KbT))))
       (fma
        -0.25
        (fma
         NaChar
         (/ EAccept KbT)
         (* (/ (- (+ (+ mu Vef) EDonor) Ec) KbT) NdChar))
        (* (+ 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) {
	double t_0 = EAccept + (Ev + Vef);
	double tmp;
	if (KbT <= -1.45e+186) {
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - exp((t_0 / KbT))));
	} else if (KbT <= 4.5e+232) {
		tmp = NaChar / (1.0 + exp(((t_0 - mu) / KbT)));
	} else {
		tmp = fma(-0.25, fma(NaChar, (EAccept / KbT), (((((mu + Vef) + EDonor) - Ec) / KbT) * NdChar)), ((NaChar + NdChar) * 0.5));
	}
	return tmp;
}

Julia

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -1.45e186

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 81.7

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

   5. Applied rewrites 81.7%

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

   6. Taylor expanded in mu around 0

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

      1. +-commutative N/A

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

      2. lower-+.f64 N/A

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

      3. lower-+.f64 81.1

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

   8. Applied rewrites 81.1%

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

   if -1.45e186 < KbT < 4.4999999999999998e232

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 65.1

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

   5. Applied rewrites 65.1%

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

   if 4.4999999999999998e232 < 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 73.0%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 73.0%

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

4. Final simplification 67.5%

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

Alternative 19: 64.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -8 \cdot 10^{+187}:\\ \;\;\;\;0.5 \cdot NdChar - \frac{NaChar}{-1 - e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;KbT \leq 4.5 \cdot 10^{+232}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \mathsf{fma}\left(NaChar, \frac{EAccept}{KbT}, \frac{\left(\left(mu + Vef\right) + EDonor\right) - Ec}{KbT} \cdot NdChar\right), \left(NaChar + NdChar\right) \cdot 0.5\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -8e+187)
   (- (* 0.5 NdChar) (/ NaChar (- -1.0 (exp (/ (- mu) KbT)))))
   (if (<= KbT 4.5e+232)
     (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT))))
     (fma
      -0.25
      (fma
       NaChar
       (/ EAccept KbT)
       (* (/ (- (+ (+ mu Vef) EDonor) Ec) KbT) NdChar))
      (* (+ 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) {
	double tmp;
	if (KbT <= -8e+187) {
		tmp = (0.5 * NdChar) - (NaChar / (-1.0 - exp((-mu / KbT))));
	} else if (KbT <= 4.5e+232) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)));
	} else {
		tmp = fma(-0.25, fma(NaChar, (EAccept / KbT), (((((mu + Vef) + EDonor) - Ec) / KbT) * NdChar)), ((NaChar + NdChar) * 0.5));
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -8e+187)
		tmp = Float64(Float64(0.5 * NdChar) - Float64(NaChar / Float64(-1.0 - exp(Float64(Float64(-mu) / KbT)))));
	elseif (KbT <= 4.5e+232)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))));
	else
		tmp = fma(-0.25, fma(NaChar, Float64(EAccept / KbT), Float64(Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT) * NdChar)), Float64(Float64(NaChar + NdChar) * 0.5));
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if KbT < -7.99999999999999926e187

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 81.7

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

   5. Applied rewrites 81.7%

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

   6. Taylor expanded in mu around inf

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

      1. mul-1-neg N/A

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

      2. lower-neg.f64 75.1

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

   8. Applied rewrites 75.1%

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

   if -7.99999999999999926e187 < KbT < 4.4999999999999998e232

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 65.1

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

   5. Applied rewrites 65.1%

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

   if 4.4999999999999998e232 < 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 73.0%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 73.0%

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

4. Final simplification 66.8%

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

Alternative 20: 63.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -8 \cdot 10^{+187}:\\ \;\;\;\;\frac{NaChar}{\left(\left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right) + \left(2 + \frac{EAccept}{KbT}\right)\right) - \frac{mu}{KbT}} + 0.5 \cdot NdChar\\ \mathbf{elif}\;KbT \leq 4.5 \cdot 10^{+232}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Ev + Vef\right)\right) - mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \mathsf{fma}\left(NaChar, \frac{EAccept}{KbT}, \frac{\left(\left(mu + Vef\right) + EDonor\right) - Ec}{KbT} \cdot NdChar\right), \left(NaChar + NdChar\right) \cdot 0.5\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -8e+187)
   (+
    (/
     NaChar
     (- (+ (+ (/ Ev KbT) (/ Vef KbT)) (+ 2.0 (/ EAccept KbT))) (/ mu KbT)))
    (* 0.5 NdChar))
   (if (<= KbT 4.5e+232)
     (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Ev Vef)) mu) KbT))))
     (fma
      -0.25
      (fma
       NaChar
       (/ EAccept KbT)
       (* (/ (- (+ (+ mu Vef) EDonor) Ec) KbT) NdChar))
      (* (+ 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) {
	double tmp;
	if (KbT <= -8e+187) {
		tmp = (NaChar / ((((Ev / KbT) + (Vef / KbT)) + (2.0 + (EAccept / KbT))) - (mu / KbT))) + (0.5 * NdChar);
	} else if (KbT <= 4.5e+232) {
		tmp = NaChar / (1.0 + exp((((EAccept + (Ev + Vef)) - mu) / KbT)));
	} else {
		tmp = fma(-0.25, fma(NaChar, (EAccept / KbT), (((((mu + Vef) + EDonor) - Ec) / KbT) * NdChar)), ((NaChar + NdChar) * 0.5));
	}
	return tmp;
}

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -8e+187)
		tmp = Float64(Float64(NaChar / Float64(Float64(Float64(Float64(Ev / KbT) + Float64(Vef / KbT)) + Float64(2.0 + Float64(EAccept / KbT))) - Float64(mu / KbT))) + Float64(0.5 * NdChar));
	elseif (KbT <= 4.5e+232)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Ev + Vef)) - mu) / KbT))));
	else
		tmp = fma(-0.25, fma(NaChar, Float64(EAccept / KbT), Float64(Float64(Float64(Float64(Float64(mu + Vef) + EDonor) - Ec) / KbT) * NdChar)), Float64(Float64(NaChar + NdChar) * 0.5));
	end
	return tmp
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -8e+187], N[(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] + N[(0.5 * NdChar), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4.5e+232], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Ev + Vef), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.25 * N[(NaChar * N[(EAccept / KbT), $MachinePrecision] + N[(N[(N[(N[(N[(mu + Vef), $MachinePrecision] + EDonor), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision] * NdChar), $MachinePrecision]), $MachinePrecision] + N[(N[(NaChar + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -7.99999999999999926e187

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 81.7

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

   5. Applied rewrites 81.7%

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

   6. Taylor expanded in KbT around inf

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

      1. lower--.f64 N/A

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

      2. associate-+r+ N/A

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

      3. lower-+.f64 N/A

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

      4. lower-+.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower-+.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower-/.f64 N/A

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

      9. lower-/.f64 74.7

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

   8. Applied rewrites 74.7%

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

   if -7.99999999999999926e187 < KbT < 4.4999999999999998e232

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 65.1

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

   5. Applied rewrites 65.1%

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

   if 4.4999999999999998e232 < 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 73.0%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 73.0%

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

4. Final simplification 66.8%

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

Alternative 21: 57.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -8 \cdot 10^{+187}:\\ \;\;\;\;\frac{NaChar}{\left(\left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right) + \left(2 + \frac{EAccept}{KbT}\right)\right) - \frac{mu}{KbT}} + 0.5 \cdot NdChar\\ \mathbf{elif}\;KbT \leq 2.8 \cdot 10^{+232}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept + \left(Ev + Vef\right)}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(-0.25, \mathsf{fma}\left(NaChar, \frac{EAccept}{KbT}, \frac{\left(\left(mu + Vef\right) + EDonor\right) - Ec}{KbT} \cdot NdChar\right), \left(NaChar + NdChar\right) \cdot 0.5\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -8e+187)
   (+
    (/
     NaChar
     (- (+ (+ (/ Ev KbT) (/ Vef KbT)) (+ 2.0 (/ EAccept KbT))) (/ mu KbT)))
    (* 0.5 NdChar))
   (if (<= KbT 2.8e+232)
     (/ NaChar (+ 1.0 (exp (/ (+ EAccept (+ Ev Vef)) KbT))))
     (fma
      -0.25
      (fma
       NaChar
       (/ EAccept KbT)
       (* (/ (- (+ (+ mu Vef) EDonor) Ec) KbT) NdChar))
      (* (+ 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) {
	double tmp;
	if (KbT <= -8e+187) {
		tmp = (NaChar / ((((Ev / KbT) + (Vef / KbT)) + (2.0 + (EAccept / KbT))) - (mu / KbT))) + (0.5 * NdChar);
	} else if (KbT <= 2.8e+232) {
		tmp = NaChar / (1.0 + exp(((EAccept + (Ev + Vef)) / KbT)));
	} else {
		tmp = fma(-0.25, fma(NaChar, (EAccept / KbT), (((((mu + Vef) + EDonor) - Ec) / KbT) * NdChar)), ((NaChar + NdChar) * 0.5));
	}
	return tmp;
}

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -8e+187], N[(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] + N[(0.5 * NdChar), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.8e+232], N[(NaChar / N[(1.0 + N[Exp[N[(N[(EAccept + N[(Ev + Vef), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.25 * N[(NaChar * N[(EAccept / KbT), $MachinePrecision] + N[(N[(N[(N[(N[(mu + Vef), $MachinePrecision] + EDonor), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision] * NdChar), $MachinePrecision]), $MachinePrecision] + N[(N[(NaChar + NdChar), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if KbT < -7.99999999999999926e187

   1. Initial program 100.0%

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

   3. Taylor expanded in KbT around inf

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

      1. lower-*.f64 81.7

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

   5. Applied rewrites 81.7%

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

   6. Taylor expanded in KbT around inf

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

      1. lower--.f64 N/A

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

      2. associate-+r+ N/A

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

      3. lower-+.f64 N/A

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

      4. lower-+.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower-+.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower-/.f64 N/A

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

      9. lower-/.f64 74.7

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

   8. Applied rewrites 74.7%

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

   if -7.99999999999999926e187 < KbT < 2.7999999999999999e232

   1. Initial program 100.0%

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

   3. Taylor expanded in NdChar around 0

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

      1. lower-/.f64 N/A

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

      2. +-commutative N/A

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

      3. lower-+.f64 N/A

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

      4. lower-exp.f64 N/A

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

      5. lower-/.f64 N/A

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

      6. lower--.f64 N/A

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

      7. +-commutative N/A

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

      8. lower-+.f64 N/A

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

      9. lower-+.f64 65.1

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

   5. Applied rewrites 65.1%

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

   6. Taylor expanded in mu around 0

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

   8. Applied rewrites 60.5%

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

   if 2.7999999999999999e232 < 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 73.0%

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

   6. Taylor expanded in EAccept around inf

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

   8. Applied rewrites 73.0%

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

4. Final simplification 63.1%

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

Alternative 22: 19.8% accurate, 15.3× speedup

Math

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

Derivation

1. Split input into 2 regimes

2. if Ev < -4.60000000000000004e111 or 1.25000000000000009e-190 < 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 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 22.2

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

   5. Applied rewrites 22.2%

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

   6. Taylor expanded in NdChar around 0

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

   8. Applied rewrites 13.3%

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

   9. Taylor expanded in NdChar around inf

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

   11. Applied rewrites 18.0%

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

   if -4.60000000000000004e111 < Ev < 1.25000000000000009e-190

   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 31.3

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

   5. Applied rewrites 31.3%

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

   6. Taylor expanded in NdChar around 0

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

   8. Applied rewrites 24.2%

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

Alternative 23: 28.2% 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 26.5

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

5. Applied rewrites 26.5%

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

6. Final simplification 26.5%

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

Alternative 24: 18.7% 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 26.5

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

5. Applied rewrites 26.5%

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

6. Taylor expanded in NdChar around 0

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

8. Applied rewrites 18.4%

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

Reproduce

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