Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 33.1s

Alternatives: 20

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 60.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{Vef}{KbT}} + 1\\ t_1 := \frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\ t_2 := \frac{NdChar}{e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}} + 1}\\ t_3 := \frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + \frac{NdChar}{e^{\frac{mu}{KbT}} + 1}\\ \mathbf{if}\;Vef \leq -1.9 \cdot 10^{+214}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq -5.6 \cdot 10^{+101}:\\ \;\;\;\;t_2 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;Vef \leq -1.55 \cdot 10^{+66}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}} + 1} + NdChar \cdot 0.5\\ \mathbf{elif}\;Vef \leq -3.8 \cdot 10^{-15}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;Vef \leq -5.7 \cdot 10^{-70}:\\ \;\;\;\;t_2 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;Vef \leq 7.5 \cdot 10^{+37}:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (exp (/ Vef KbT)) 1.0))
        (t_1 (+ (/ NaChar t_0) (/ NdChar t_0)))
        (t_2 (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0)))
        (t_3
         (+
          (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))
          (/ NdChar (+ (exp (/ mu KbT)) 1.0)))))
   (if (<= Vef -1.9e+214)
     t_1
     (if (<= Vef -5.6e+101)
       (+ t_2 (/ NaChar (+ (/ Ev KbT) 2.0)))
       (if (<= Vef -1.55e+66)
         (+
          (/ NaChar (+ (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)) 1.0))
          (* NdChar 0.5))
         (if (<= Vef -3.8e-15)
           t_3
           (if (<= Vef -5.7e-70)
             (+
              t_2
              (/
               NaChar
               (-
                (+ 2.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
                (/ mu KbT))))
             (if (<= Vef 7.5e+37) t_3 t_1))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = exp((Vef / KbT)) + 1.0;
	double t_1 = (NaChar / t_0) + (NdChar / t_0);
	double t_2 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_3 = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((mu / KbT)) + 1.0));
	double tmp;
	if (Vef <= -1.9e+214) {
		tmp = t_1;
	} else if (Vef <= -5.6e+101) {
		tmp = t_2 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (Vef <= -1.55e+66) {
		tmp = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	} else if (Vef <= -3.8e-15) {
		tmp = t_3;
	} else if (Vef <= -5.7e-70) {
		tmp = t_2 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else if (Vef <= 7.5e+37) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = exp((vef / kbt)) + 1.0d0
    t_1 = (nachar / t_0) + (ndchar / t_0)
    t_2 = ndchar / (exp(((mu + (edonor + (vef - ec))) / kbt)) + 1.0d0)
    t_3 = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + (ndchar / (exp((mu / kbt)) + 1.0d0))
    if (vef <= (-1.9d+214)) then
        tmp = t_1
    else if (vef <= (-5.6d+101)) then
        tmp = t_2 + (nachar / ((ev / kbt) + 2.0d0))
    else if (vef <= (-1.55d+66)) then
        tmp = (nachar / (exp(((vef + (eaccept + (ev - mu))) / kbt)) + 1.0d0)) + (ndchar * 0.5d0)
    else if (vef <= (-3.8d-15)) then
        tmp = t_3
    else if (vef <= (-5.7d-70)) then
        tmp = t_2 + (nachar / ((2.0d0 + ((eaccept / kbt) + ((ev / kbt) + (vef / kbt)))) - (mu / kbt)))
    else if (vef <= 7.5d+37) then
        tmp = t_3
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = Math.exp((Vef / KbT)) + 1.0;
	double t_1 = (NaChar / t_0) + (NdChar / t_0);
	double t_2 = NdChar / (Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_3 = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (Math.exp((mu / KbT)) + 1.0));
	double tmp;
	if (Vef <= -1.9e+214) {
		tmp = t_1;
	} else if (Vef <= -5.6e+101) {
		tmp = t_2 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (Vef <= -1.55e+66) {
		tmp = (NaChar / (Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	} else if (Vef <= -3.8e-15) {
		tmp = t_3;
	} else if (Vef <= -5.7e-70) {
		tmp = t_2 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else if (Vef <= 7.5e+37) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = math.exp((Vef / KbT)) + 1.0
	t_1 = (NaChar / t_0) + (NdChar / t_0)
	t_2 = NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)
	t_3 = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (math.exp((mu / KbT)) + 1.0))
	tmp = 0
	if Vef <= -1.9e+214:
		tmp = t_1
	elif Vef <= -5.6e+101:
		tmp = t_2 + (NaChar / ((Ev / KbT) + 2.0))
	elif Vef <= -1.55e+66:
		tmp = (NaChar / (math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5)
	elif Vef <= -3.8e-15:
		tmp = t_3
	elif Vef <= -5.7e-70:
		tmp = t_2 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)))
	elif Vef <= 7.5e+37:
		tmp = t_3
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(exp(Float64(Vef / KbT)) + 1.0)
	t_1 = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0))
	t_2 = Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0))
	t_3 = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0)))
	tmp = 0.0
	if (Vef <= -1.9e+214)
		tmp = t_1;
	elseif (Vef <= -5.6e+101)
		tmp = Float64(t_2 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	elseif (Vef <= -1.55e+66)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)) + 1.0)) + Float64(NdChar * 0.5));
	elseif (Vef <= -3.8e-15)
		tmp = t_3;
	elseif (Vef <= -5.7e-70)
		tmp = Float64(t_2 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT))));
	elseif (Vef <= 7.5e+37)
		tmp = t_3;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp((Vef / KbT)) + 1.0;
	t_1 = (NaChar / t_0) + (NdChar / t_0);
	t_2 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	t_3 = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((mu / KbT)) + 1.0));
	tmp = 0.0;
	if (Vef <= -1.9e+214)
		tmp = t_1;
	elseif (Vef <= -5.6e+101)
		tmp = t_2 + (NaChar / ((Ev / KbT) + 2.0));
	elseif (Vef <= -1.55e+66)
		tmp = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	elseif (Vef <= -3.8e-15)
		tmp = t_3;
	elseif (Vef <= -5.7e-70)
		tmp = t_2 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	elseif (Vef <= 7.5e+37)
		tmp = t_3;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -1.9e+214], t$95$1, If[LessEqual[Vef, -5.6e+101], N[(t$95$2 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -1.55e+66], N[(N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -3.8e-15], t$95$3, If[LessEqual[Vef, -5.7e-70], N[(t$95$2 + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Ev / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 7.5e+37], t$95$3, t$95$1]]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 70.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{Vef}{KbT}} + 1\\ t_1 := \frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\ \mathbf{if}\;Vef \leq -8.8 \cdot 10^{+213}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Vef \leq -3.4 \cdot 10^{+101}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}} + 1} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;Vef \leq -6.4 \cdot 10^{+68}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}} + 1} + NdChar \cdot 0.5\\ \mathbf{elif}\;Vef \leq -8.8 \cdot 10^{-10}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + \frac{NdChar}{e^{\frac{mu}{KbT}} + 1}\\ \mathbf{elif}\;Vef \leq 2.45 \cdot 10^{+116}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1} + \frac{NdChar}{e^{\frac{\left(mu + EDonor\right) - Ec}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (exp (/ Vef KbT)) 1.0))
        (t_1 (+ (/ NaChar t_0) (/ NdChar t_0))))
   (if (<= Vef -8.8e+213)
     t_1
     (if (<= Vef -3.4e+101)
       (+
        (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0))
        (/ NaChar (+ (/ Ev KbT) 2.0)))
       (if (<= Vef -6.4e+68)
         (+
          (/ NaChar (+ (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)) 1.0))
          (* NdChar 0.5))
         (if (<= Vef -8.8e-10)
           (+
            (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))
            (/ NdChar (+ (exp (/ mu KbT)) 1.0)))
           (if (<= Vef 2.45e+116)
             (+
              (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
              (/ NdChar (+ (exp (/ (- (+ mu EDonor) Ec) KbT)) 1.0)))
             t_1)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = exp((Vef / KbT)) + 1.0;
	double t_1 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -8.8e+213) {
		tmp = t_1;
	} else if (Vef <= -3.4e+101) {
		tmp = (NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Ev / KbT) + 2.0));
	} else if (Vef <= -6.4e+68) {
		tmp = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	} else if (Vef <= -8.8e-10) {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((mu / KbT)) + 1.0));
	} else if (Vef <= 2.45e+116) {
		tmp = (NaChar / (exp((Ev / KbT)) + 1.0)) + (NdChar / (exp((((mu + EDonor) - Ec) / KbT)) + 1.0));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = exp((vef / kbt)) + 1.0d0
    t_1 = (nachar / t_0) + (ndchar / t_0)
    if (vef <= (-8.8d+213)) then
        tmp = t_1
    else if (vef <= (-3.4d+101)) then
        tmp = (ndchar / (exp(((mu + (edonor + (vef - ec))) / kbt)) + 1.0d0)) + (nachar / ((ev / kbt) + 2.0d0))
    else if (vef <= (-6.4d+68)) then
        tmp = (nachar / (exp(((vef + (eaccept + (ev - mu))) / kbt)) + 1.0d0)) + (ndchar * 0.5d0)
    else if (vef <= (-8.8d-10)) then
        tmp = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + (ndchar / (exp((mu / kbt)) + 1.0d0))
    else if (vef <= 2.45d+116) then
        tmp = (nachar / (exp((ev / kbt)) + 1.0d0)) + (ndchar / (exp((((mu + edonor) - ec) / kbt)) + 1.0d0))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = Math.exp((Vef / KbT)) + 1.0;
	double t_1 = (NaChar / t_0) + (NdChar / t_0);
	double tmp;
	if (Vef <= -8.8e+213) {
		tmp = t_1;
	} else if (Vef <= -3.4e+101) {
		tmp = (NdChar / (Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Ev / KbT) + 2.0));
	} else if (Vef <= -6.4e+68) {
		tmp = (NaChar / (Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	} else if (Vef <= -8.8e-10) {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (Math.exp((mu / KbT)) + 1.0));
	} else if (Vef <= 2.45e+116) {
		tmp = (NaChar / (Math.exp((Ev / KbT)) + 1.0)) + (NdChar / (Math.exp((((mu + EDonor) - Ec) / KbT)) + 1.0));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = math.exp((Vef / KbT)) + 1.0
	t_1 = (NaChar / t_0) + (NdChar / t_0)
	tmp = 0
	if Vef <= -8.8e+213:
		tmp = t_1
	elif Vef <= -3.4e+101:
		tmp = (NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Ev / KbT) + 2.0))
	elif Vef <= -6.4e+68:
		tmp = (NaChar / (math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5)
	elif Vef <= -8.8e-10:
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (math.exp((mu / KbT)) + 1.0))
	elif Vef <= 2.45e+116:
		tmp = (NaChar / (math.exp((Ev / KbT)) + 1.0)) + (NdChar / (math.exp((((mu + EDonor) - Ec) / KbT)) + 1.0))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(exp(Float64(Vef / KbT)) + 1.0)
	t_1 = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0))
	tmp = 0.0
	if (Vef <= -8.8e+213)
		tmp = t_1;
	elseif (Vef <= -3.4e+101)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0)) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	elseif (Vef <= -6.4e+68)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)) + 1.0)) + Float64(NdChar * 0.5));
	elseif (Vef <= -8.8e-10)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(mu / KbT)) + 1.0)));
	elseif (Vef <= 2.45e+116)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(Float64(Float64(mu + EDonor) - Ec) / KbT)) + 1.0)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp((Vef / KbT)) + 1.0;
	t_1 = (NaChar / t_0) + (NdChar / t_0);
	tmp = 0.0;
	if (Vef <= -8.8e+213)
		tmp = t_1;
	elseif (Vef <= -3.4e+101)
		tmp = (NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Ev / KbT) + 2.0));
	elseif (Vef <= -6.4e+68)
		tmp = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	elseif (Vef <= -8.8e-10)
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((mu / KbT)) + 1.0));
	elseif (Vef <= 2.45e+116)
		tmp = (NaChar / (exp((Ev / KbT)) + 1.0)) + (NdChar / (exp((((mu + EDonor) - Ec) / KbT)) + 1.0));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 52.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{KbT} \cdot \left(Vef + Ev\right)\\ t_1 := \frac{NdChar}{e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}} + 1}\\ t_2 := \left(\frac{mu}{KbT} - t_0\right) - \frac{EAccept}{KbT}\\ \mathbf{if}\;EAccept \leq 1.5 \cdot 10^{-172}:\\ \;\;\;\;t_1 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;EAccept \leq 1.32 \cdot 10^{-121}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 7.8 \cdot 10^{+21}:\\ \;\;\;\;t_1 + \frac{NaChar}{\frac{4 + \left(\frac{EAccept}{KbT} + \left(t_0 - \frac{mu}{KbT}\right)\right) \cdot t_2}{2 + t_2}}\\ \mathbf{elif}\;EAccept \leq 4.4 \cdot 10^{+147} \lor \neg \left(EAccept \leq 2.2 \cdot 10^{+166}\right):\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + \frac{NdChar}{e^{\frac{Vef}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;t_1 + \frac{KbT}{\frac{EAccept}{NaChar}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 KbT) (+ Vef Ev)))
        (t_1 (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0)))
        (t_2 (- (- (/ mu KbT) t_0) (/ EAccept KbT))))
   (if (<= EAccept 1.5e-172)
     (+
      t_1
      (/
       NaChar
       (-
        (+ 2.0 (+ (/ EAccept KbT) (/ (/ (+ (* KbT Ev) (* Vef KbT)) KbT) KbT)))
        (/ mu KbT))))
     (if (<= EAccept 1.32e-121)
       (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
       (if (<= EAccept 7.8e+21)
         (+
          t_1
          (/
           NaChar
           (/
            (+ 4.0 (* (+ (/ EAccept KbT) (- t_0 (/ mu KbT))) t_2))
            (+ 2.0 t_2))))
         (if (or (<= EAccept 4.4e+147) (not (<= EAccept 2.2e+166)))
           (+
            (/ NaChar (+ (exp (/ EAccept KbT)) 1.0))
            (/ NdChar (+ (exp (/ Vef KbT)) 1.0)))
           (+ t_1 (/ KbT (/ EAccept NaChar)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (1.0 / KbT) * (Vef + Ev);
	double t_1 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_2 = ((mu / KbT) - t_0) - (EAccept / KbT);
	double tmp;
	if (EAccept <= 1.5e-172) {
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (EAccept <= 1.32e-121) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else if (EAccept <= 7.8e+21) {
		tmp = t_1 + (NaChar / ((4.0 + (((EAccept / KbT) + (t_0 - (mu / KbT))) * t_2)) / (2.0 + t_2)));
	} else if ((EAccept <= 4.4e+147) || !(EAccept <= 2.2e+166)) {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((Vef / KbT)) + 1.0));
	} else {
		tmp = t_1 + (KbT / (EAccept / NaChar));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (1.0d0 / kbt) * (vef + ev)
    t_1 = ndchar / (exp(((mu + (edonor + (vef - ec))) / kbt)) + 1.0d0)
    t_2 = ((mu / kbt) - t_0) - (eaccept / kbt)
    if (eaccept <= 1.5d-172) then
        tmp = t_1 + (nachar / ((2.0d0 + ((eaccept / kbt) + ((((kbt * ev) + (vef * kbt)) / kbt) / kbt))) - (mu / kbt)))
    else if (eaccept <= 1.32d-121) then
        tmp = nachar / (exp((ev / kbt)) + 1.0d0)
    else if (eaccept <= 7.8d+21) then
        tmp = t_1 + (nachar / ((4.0d0 + (((eaccept / kbt) + (t_0 - (mu / kbt))) * t_2)) / (2.0d0 + t_2)))
    else if ((eaccept <= 4.4d+147) .or. (.not. (eaccept <= 2.2d+166))) then
        tmp = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + (ndchar / (exp((vef / kbt)) + 1.0d0))
    else
        tmp = t_1 + (kbt / (eaccept / nachar))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (1.0 / KbT) * (Vef + Ev);
	double t_1 = NdChar / (Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_2 = ((mu / KbT) - t_0) - (EAccept / KbT);
	double tmp;
	if (EAccept <= 1.5e-172) {
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (EAccept <= 1.32e-121) {
		tmp = NaChar / (Math.exp((Ev / KbT)) + 1.0);
	} else if (EAccept <= 7.8e+21) {
		tmp = t_1 + (NaChar / ((4.0 + (((EAccept / KbT) + (t_0 - (mu / KbT))) * t_2)) / (2.0 + t_2)));
	} else if ((EAccept <= 4.4e+147) || !(EAccept <= 2.2e+166)) {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (Math.exp((Vef / KbT)) + 1.0));
	} else {
		tmp = t_1 + (KbT / (EAccept / NaChar));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (1.0 / KbT) * (Vef + Ev)
	t_1 = NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)
	t_2 = ((mu / KbT) - t_0) - (EAccept / KbT)
	tmp = 0
	if EAccept <= 1.5e-172:
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)))
	elif EAccept <= 1.32e-121:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	elif EAccept <= 7.8e+21:
		tmp = t_1 + (NaChar / ((4.0 + (((EAccept / KbT) + (t_0 - (mu / KbT))) * t_2)) / (2.0 + t_2)))
	elif (EAccept <= 4.4e+147) or not (EAccept <= 2.2e+166):
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + (NdChar / (math.exp((Vef / KbT)) + 1.0))
	else:
		tmp = t_1 + (KbT / (EAccept / NaChar))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(1.0 / KbT) * Float64(Vef + Ev))
	t_1 = Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0))
	t_2 = Float64(Float64(Float64(mu / KbT) - t_0) - Float64(EAccept / KbT))
	tmp = 0.0
	if (EAccept <= 1.5e-172)
		tmp = Float64(t_1 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Float64(Float64(KbT * Ev) + Float64(Vef * KbT)) / KbT) / KbT))) - Float64(mu / KbT))));
	elseif (EAccept <= 1.32e-121)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	elseif (EAccept <= 7.8e+21)
		tmp = Float64(t_1 + Float64(NaChar / Float64(Float64(4.0 + Float64(Float64(Float64(EAccept / KbT) + Float64(t_0 - Float64(mu / KbT))) * t_2)) / Float64(2.0 + t_2))));
	elseif ((EAccept <= 4.4e+147) || !(EAccept <= 2.2e+166))
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)));
	else
		tmp = Float64(t_1 + Float64(KbT / Float64(EAccept / NaChar)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (1.0 / KbT) * (Vef + Ev);
	t_1 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	t_2 = ((mu / KbT) - t_0) - (EAccept / KbT);
	tmp = 0.0;
	if (EAccept <= 1.5e-172)
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	elseif (EAccept <= 1.32e-121)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	elseif (EAccept <= 7.8e+21)
		tmp = t_1 + (NaChar / ((4.0 + (((EAccept / KbT) + (t_0 - (mu / KbT))) * t_2)) / (2.0 + t_2)));
	elseif ((EAccept <= 4.4e+147) || ~((EAccept <= 2.2e+166)))
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar / (exp((Vef / KbT)) + 1.0));
	else
		tmp = t_1 + (KbT / (EAccept / NaChar));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(1.0 / KbT), $MachinePrecision] * N[(Vef + Ev), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(mu / KbT), $MachinePrecision] - t$95$0), $MachinePrecision] - N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, 1.5e-172], N[(t$95$1 + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(N[(N[(KbT * Ev), $MachinePrecision] + N[(Vef * KbT), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.32e-121], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 7.8e+21], N[(t$95$1 + N[(NaChar / N[(N[(4.0 + N[(N[(N[(EAccept / KbT), $MachinePrecision] + N[(t$95$0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision] / N[(2.0 + t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EAccept, 4.4e+147], N[Not[LessEqual[EAccept, 2.2e+166]], $MachinePrecision]], N[(N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(KbT / N[(EAccept / NaChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 54.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\frac{Vef}{KbT}} + 1\\ t_1 := \frac{NdChar}{e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}} + 1}\\ t_2 := \frac{NdChar}{t_0}\\ \mathbf{if}\;EAccept \leq 8 \cdot 10^{-169}:\\ \;\;\;\;t_1 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;EAccept \leq 10^{-122}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{elif}\;EAccept \leq 8.6 \cdot 10^{-84}:\\ \;\;\;\;t_1 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{elif}\;EAccept \leq 3 \cdot 10^{+71}:\\ \;\;\;\;\frac{NaChar}{t_0} + t_2\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (exp (/ Vef KbT)) 1.0))
        (t_1 (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0)))
        (t_2 (/ NdChar t_0)))
   (if (<= EAccept 8e-169)
     (+
      t_1
      (/
       NaChar
       (-
        (+ 2.0 (+ (/ EAccept KbT) (/ (/ (+ (* KbT Ev) (* Vef KbT)) KbT) KbT)))
        (/ mu KbT))))
     (if (<= EAccept 1e-122)
       (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
       (if (<= EAccept 8.6e-84)
         (+ t_1 (/ NaChar (+ (/ Ev KbT) 2.0)))
         (if (<= EAccept 3e+71)
           (+ (/ NaChar t_0) t_2)
           (+ (/ NaChar (+ (exp (/ EAccept KbT)) 1.0)) t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = exp((Vef / KbT)) + 1.0;
	double t_1 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_2 = NdChar / t_0;
	double tmp;
	if (EAccept <= 8e-169) {
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (EAccept <= 1e-122) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else if (EAccept <= 8.6e-84) {
		tmp = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (EAccept <= 3e+71) {
		tmp = (NaChar / t_0) + t_2;
	} else {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = exp((vef / kbt)) + 1.0d0
    t_1 = ndchar / (exp(((mu + (edonor + (vef - ec))) / kbt)) + 1.0d0)
    t_2 = ndchar / t_0
    if (eaccept <= 8d-169) then
        tmp = t_1 + (nachar / ((2.0d0 + ((eaccept / kbt) + ((((kbt * ev) + (vef * kbt)) / kbt) / kbt))) - (mu / kbt)))
    else if (eaccept <= 1d-122) then
        tmp = nachar / (exp((ev / kbt)) + 1.0d0)
    else if (eaccept <= 8.6d-84) then
        tmp = t_1 + (nachar / ((ev / kbt) + 2.0d0))
    else if (eaccept <= 3d+71) then
        tmp = (nachar / t_0) + t_2
    else
        tmp = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = Math.exp((Vef / KbT)) + 1.0;
	double t_1 = NdChar / (Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_2 = NdChar / t_0;
	double tmp;
	if (EAccept <= 8e-169) {
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (EAccept <= 1e-122) {
		tmp = NaChar / (Math.exp((Ev / KbT)) + 1.0);
	} else if (EAccept <= 8.6e-84) {
		tmp = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	} else if (EAccept <= 3e+71) {
		tmp = (NaChar / t_0) + t_2;
	} else {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = math.exp((Vef / KbT)) + 1.0
	t_1 = NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)
	t_2 = NdChar / t_0
	tmp = 0
	if EAccept <= 8e-169:
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)))
	elif EAccept <= 1e-122:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	elif EAccept <= 8.6e-84:
		tmp = t_1 + (NaChar / ((Ev / KbT) + 2.0))
	elif EAccept <= 3e+71:
		tmp = (NaChar / t_0) + t_2
	else:
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(exp(Float64(Vef / KbT)) + 1.0)
	t_1 = Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0))
	t_2 = Float64(NdChar / t_0)
	tmp = 0.0
	if (EAccept <= 8e-169)
		tmp = Float64(t_1 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Float64(Float64(KbT * Ev) + Float64(Vef * KbT)) / KbT) / KbT))) - Float64(mu / KbT))));
	elseif (EAccept <= 1e-122)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	elseif (EAccept <= 8.6e-84)
		tmp = Float64(t_1 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)));
	elseif (EAccept <= 3e+71)
		tmp = Float64(Float64(NaChar / t_0) + t_2);
	else
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + t_2);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = exp((Vef / KbT)) + 1.0;
	t_1 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	t_2 = NdChar / t_0;
	tmp = 0.0;
	if (EAccept <= 8e-169)
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	elseif (EAccept <= 1e-122)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	elseif (EAccept <= 8.6e-84)
		tmp = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	elseif (EAccept <= 3e+71)
		tmp = (NaChar / t_0) + t_2;
	else
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + t_2;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 73.2% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 71.4% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 72.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 56.6% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}} + 1} + NdChar \cdot 0.5\\ t_1 := \frac{NdChar}{e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}} + 1}\\ t_2 := t_1 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{if}\;NdChar \leq -7.5 \cdot 10^{-25}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq -1.08 \cdot 10^{-225}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NdChar \leq -2 \cdot 10^{-306}:\\ \;\;\;\;t_1 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \frac{\frac{KbT \cdot Ev + Vef \cdot KbT}{KbT}}{KbT}\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 5.5 \cdot 10^{+127}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)) 1.0))
          (* NdChar 0.5)))
        (t_1 (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0)))
        (t_2 (+ t_1 (/ NaChar (+ (/ Ev KbT) 2.0)))))
   (if (<= NdChar -7.5e-25)
     t_2
     (if (<= NdChar -1.08e-225)
       t_0
       (if (<= NdChar -2e-306)
         (+
          t_1
          (/
           NaChar
           (-
            (+
             2.0
             (+ (/ EAccept KbT) (/ (/ (+ (* KbT Ev) (* Vef KbT)) KbT) KbT)))
            (/ mu KbT))))
         (if (<= NdChar 5.5e+127) t_0 t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	double t_1 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_2 = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	double tmp;
	if (NdChar <= -7.5e-25) {
		tmp = t_2;
	} else if (NdChar <= -1.08e-225) {
		tmp = t_0;
	} else if (NdChar <= -2e-306) {
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (NdChar <= 5.5e+127) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (nachar / (exp(((vef + (eaccept + (ev - mu))) / kbt)) + 1.0d0)) + (ndchar * 0.5d0)
    t_1 = ndchar / (exp(((mu + (edonor + (vef - ec))) / kbt)) + 1.0d0)
    t_2 = t_1 + (nachar / ((ev / kbt) + 2.0d0))
    if (ndchar <= (-7.5d-25)) then
        tmp = t_2
    else if (ndchar <= (-1.08d-225)) then
        tmp = t_0
    else if (ndchar <= (-2d-306)) then
        tmp = t_1 + (nachar / ((2.0d0 + ((eaccept / kbt) + ((((kbt * ev) + (vef * kbt)) / kbt) / kbt))) - (mu / kbt)))
    else if (ndchar <= 5.5d+127) then
        tmp = t_0
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	double t_1 = NdChar / (Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_2 = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	double tmp;
	if (NdChar <= -7.5e-25) {
		tmp = t_2;
	} else if (NdChar <= -1.08e-225) {
		tmp = t_0;
	} else if (NdChar <= -2e-306) {
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	} else if (NdChar <= 5.5e+127) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5)
	t_1 = NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)
	t_2 = t_1 + (NaChar / ((Ev / KbT) + 2.0))
	tmp = 0
	if NdChar <= -7.5e-25:
		tmp = t_2
	elif NdChar <= -1.08e-225:
		tmp = t_0
	elif NdChar <= -2e-306:
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)))
	elif NdChar <= 5.5e+127:
		tmp = t_0
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)) + 1.0)) + Float64(NdChar * 0.5))
	t_1 = Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0))
	t_2 = Float64(t_1 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)))
	tmp = 0.0
	if (NdChar <= -7.5e-25)
		tmp = t_2;
	elseif (NdChar <= -1.08e-225)
		tmp = t_0;
	elseif (NdChar <= -2e-306)
		tmp = Float64(t_1 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Float64(Float64(KbT * Ev) + Float64(Vef * KbT)) / KbT) / KbT))) - Float64(mu / KbT))));
	elseif (NdChar <= 5.5e+127)
		tmp = t_0;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	t_1 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	t_2 = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	tmp = 0.0;
	if (NdChar <= -7.5e-25)
		tmp = t_2;
	elseif (NdChar <= -1.08e-225)
		tmp = t_0;
	elseif (NdChar <= -2e-306)
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((((KbT * Ev) + (Vef * KbT)) / KbT) / KbT))) - (mu / KbT)));
	elseif (NdChar <= 5.5e+127)
		tmp = t_0;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 56.7% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}} + 1} + NdChar \cdot 0.5\\ t_1 := \frac{NdChar}{e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}} + 1}\\ t_2 := t_1 + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\ \mathbf{if}\;NdChar \leq -8.5 \cdot 10^{-24}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq -5 \cdot 10^{-226}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NdChar \leq -2 \cdot 10^{-306}:\\ \;\;\;\;t_1 + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Ev}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NdChar \leq 5.5 \cdot 10^{+127}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)) 1.0))
          (* NdChar 0.5)))
        (t_1 (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0)))
        (t_2 (+ t_1 (/ NaChar (+ (/ Ev KbT) 2.0)))))
   (if (<= NdChar -8.5e-24)
     t_2
     (if (<= NdChar -5e-226)
       t_0
       (if (<= NdChar -2e-306)
         (+
          t_1
          (/
           NaChar
           (-
            (+ 2.0 (+ (/ EAccept KbT) (+ (/ Ev KbT) (/ Vef KbT))))
            (/ mu KbT))))
         (if (<= NdChar 5.5e+127) t_0 t_2))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	double t_1 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_2 = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	double tmp;
	if (NdChar <= -8.5e-24) {
		tmp = t_2;
	} else if (NdChar <= -5e-226) {
		tmp = t_0;
	} else if (NdChar <= -2e-306) {
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else if (NdChar <= 5.5e+127) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (nachar / (exp(((vef + (eaccept + (ev - mu))) / kbt)) + 1.0d0)) + (ndchar * 0.5d0)
    t_1 = ndchar / (exp(((mu + (edonor + (vef - ec))) / kbt)) + 1.0d0)
    t_2 = t_1 + (nachar / ((ev / kbt) + 2.0d0))
    if (ndchar <= (-8.5d-24)) then
        tmp = t_2
    else if (ndchar <= (-5d-226)) then
        tmp = t_0
    else if (ndchar <= (-2d-306)) then
        tmp = t_1 + (nachar / ((2.0d0 + ((eaccept / kbt) + ((ev / kbt) + (vef / kbt)))) - (mu / kbt)))
    else if (ndchar <= 5.5d+127) then
        tmp = t_0
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	double t_1 = NdChar / (Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	double t_2 = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	double tmp;
	if (NdChar <= -8.5e-24) {
		tmp = t_2;
	} else if (NdChar <= -5e-226) {
		tmp = t_0;
	} else if (NdChar <= -2e-306) {
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	} else if (NdChar <= 5.5e+127) {
		tmp = t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5)
	t_1 = NdChar / (math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)
	t_2 = t_1 + (NaChar / ((Ev / KbT) + 2.0))
	tmp = 0
	if NdChar <= -8.5e-24:
		tmp = t_2
	elif NdChar <= -5e-226:
		tmp = t_0
	elif NdChar <= -2e-306:
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)))
	elif NdChar <= 5.5e+127:
		tmp = t_0
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)) + 1.0)) + Float64(NdChar * 0.5))
	t_1 = Float64(NdChar / Float64(exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)) + 1.0))
	t_2 = Float64(t_1 + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)))
	tmp = 0.0
	if (NdChar <= -8.5e-24)
		tmp = t_2;
	elseif (NdChar <= -5e-226)
		tmp = t_0;
	elseif (NdChar <= -2e-306)
		tmp = Float64(t_1 + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Ev / KbT) + Float64(Vef / KbT)))) - Float64(mu / KbT))));
	elseif (NdChar <= 5.5e+127)
		tmp = t_0;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	t_1 = NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0);
	t_2 = t_1 + (NaChar / ((Ev / KbT) + 2.0));
	tmp = 0.0;
	if (NdChar <= -8.5e-24)
		tmp = t_2;
	elseif (NdChar <= -5e-226)
		tmp = t_0;
	elseif (NdChar <= -2e-306)
		tmp = t_1 + (NaChar / ((2.0 + ((EAccept / KbT) + ((Ev / KbT) + (Vef / KbT)))) - (mu / KbT)));
	elseif (NdChar <= 5.5e+127)
		tmp = t_0;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 46.7% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -1.7 \cdot 10^{+154}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} + \frac{KbT \cdot NaChar}{Ev}\\ \mathbf{elif}\;NdChar \leq -1.1 \cdot 10^{-22}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{elif}\;NdChar \leq 1.4 \cdot 10^{+138}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}} + 1} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -1.7e+154)
   (+ (/ NdChar (+ (exp (/ Vef KbT)) 1.0)) (/ (* KbT NaChar) Ev))
   (if (<= NdChar -1.1e-22)
     (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
     (if (<= NdChar 1.4e+138)
       (+
        (/ NaChar (+ (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)) 1.0))
        (* NdChar 0.5))
       (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NdChar <= -1.7e+154) {
		tmp = (NdChar / (exp((Vef / KbT)) + 1.0)) + ((KbT * NaChar) / Ev);
	} else if (NdChar <= -1.1e-22) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else if (NdChar <= 1.4e+138) {
		tmp = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	} else {
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (ndchar <= (-1.7d+154)) then
        tmp = (ndchar / (exp((vef / kbt)) + 1.0d0)) + ((kbt * nachar) / ev)
    else if (ndchar <= (-1.1d-22)) then
        tmp = nachar / (exp((ev / kbt)) + 1.0d0)
    else if (ndchar <= 1.4d+138) then
        tmp = (nachar / (exp(((vef + (eaccept + (ev - mu))) / kbt)) + 1.0d0)) + (ndchar * 0.5d0)
    else
        tmp = ndchar / (exp((edonor / kbt)) + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NdChar <= -1.7e+154) {
		tmp = (NdChar / (Math.exp((Vef / KbT)) + 1.0)) + ((KbT * NaChar) / Ev);
	} else if (NdChar <= -1.1e-22) {
		tmp = NaChar / (Math.exp((Ev / KbT)) + 1.0);
	} else if (NdChar <= 1.4e+138) {
		tmp = (NaChar / (Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	} else {
		tmp = NdChar / (Math.exp((EDonor / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NdChar <= -1.7e+154:
		tmp = (NdChar / (math.exp((Vef / KbT)) + 1.0)) + ((KbT * NaChar) / Ev)
	elif NdChar <= -1.1e-22:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	elif NdChar <= 1.4e+138:
		tmp = (NaChar / (math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5)
	else:
		tmp = NdChar / (math.exp((EDonor / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NdChar <= -1.7e+154)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)) + Float64(Float64(KbT * NaChar) / Ev));
	elseif (NdChar <= -1.1e-22)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	elseif (NdChar <= 1.4e+138)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)) + 1.0)) + Float64(NdChar * 0.5));
	else
		tmp = Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NdChar <= -1.7e+154)
		tmp = (NdChar / (exp((Vef / KbT)) + 1.0)) + ((KbT * NaChar) / Ev);
	elseif (NdChar <= -1.1e-22)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	elseif (NdChar <= 1.4e+138)
		tmp = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	else
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -1.7e+154], N[(N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(N[(KbT * NaChar), $MachinePrecision] / Ev), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -1.1e-22], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.4e+138], N[(N[(NaChar / N[(N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 58.0% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -1.56e-24) (not (<= NdChar 5.4e+127)))
   (+
    (/ NdChar (+ (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)) 1.0))
    (/ NaChar (+ (/ Ev KbT) 2.0)))
   (+
    (/ NaChar (+ (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)) 1.0))
    (* 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 ((NdChar <= -1.56e-24) || !(NdChar <= 5.4e+127)) {
		tmp = (NdChar / (exp(((mu + (EDonor + (Vef - Ec))) / KbT)) + 1.0)) + (NaChar / ((Ev / KbT) + 2.0));
	} else {
		tmp = (NaChar / (exp(((Vef + (EAccept + (Ev - mu))) / KbT)) + 1.0)) + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 53.3% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 14: 40.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{if}\;NdChar \leq -1.25 \cdot 10^{+160}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NdChar \leq 2.2 \cdot 10^{-290}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{elif}\;NdChar \leq 3.2 \cdot 10^{+130}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + 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 (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))))
   (if (<= NdChar -1.25e+160)
     t_0
     (if (<= NdChar 2.2e-290)
       (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
       (if (<= NdChar 3.2e+130)
         (+ (/ NaChar (+ (exp (/ EAccept KbT)) 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 = NdChar / (exp((EDonor / KbT)) + 1.0);
	double tmp;
	if (NdChar <= -1.25e+160) {
		tmp = t_0;
	} else if (NdChar <= 2.2e-290) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else if (NdChar <= 3.2e+130) {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (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) :: tmp
    t_0 = ndchar / (exp((edonor / kbt)) + 1.0d0)
    if (ndchar <= (-1.25d+160)) then
        tmp = t_0
    else if (ndchar <= 2.2d-290) then
        tmp = nachar / (exp((ev / kbt)) + 1.0d0)
    else if (ndchar <= 3.2d+130) then
        tmp = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + (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 = NdChar / (Math.exp((EDonor / KbT)) + 1.0);
	double tmp;
	if (NdChar <= -1.25e+160) {
		tmp = t_0;
	} else if (NdChar <= 2.2e-290) {
		tmp = NaChar / (Math.exp((Ev / KbT)) + 1.0);
	} else if (NdChar <= 3.2e+130) {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + (NdChar * 0.5);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (math.exp((EDonor / KbT)) + 1.0)
	tmp = 0
	if NdChar <= -1.25e+160:
		tmp = t_0
	elif NdChar <= 2.2e-290:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	elif NdChar <= 3.2e+130:
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 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(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0))
	tmp = 0.0
	if (NdChar <= -1.25e+160)
		tmp = t_0;
	elseif (NdChar <= 2.2e-290)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	elseif (NdChar <= 3.2e+130)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + Float64(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 = NdChar / (exp((EDonor / KbT)) + 1.0);
	tmp = 0.0;
	if (NdChar <= -1.25e+160)
		tmp = t_0;
	elseif (NdChar <= 2.2e-290)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	elseif (NdChar <= 3.2e+130)
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (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[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.25e+160], t$95$0, If[LessEqual[NdChar, 2.2e-290], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 3.2e+130], N[(N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 15: 38.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -2.3 \cdot 10^{+154}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{Vef}{KbT}} + 1} + \frac{KbT \cdot NaChar}{Ev}\\ \mathbf{elif}\;NdChar \leq 2.2 \cdot 10^{-291}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{elif}\;NdChar \leq 4.1 \cdot 10^{+133}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{EAccept}{KbT}} + 1} + NdChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NdChar -2.3e+154)
   (+ (/ NdChar (+ (exp (/ Vef KbT)) 1.0)) (/ (* KbT NaChar) Ev))
   (if (<= NdChar 2.2e-291)
     (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
     (if (<= NdChar 4.1e+133)
       (+ (/ NaChar (+ (exp (/ EAccept KbT)) 1.0)) (* NdChar 0.5))
       (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NdChar <= -2.3e+154) {
		tmp = (NdChar / (exp((Vef / KbT)) + 1.0)) + ((KbT * NaChar) / Ev);
	} else if (NdChar <= 2.2e-291) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else if (NdChar <= 4.1e+133) {
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar * 0.5);
	} else {
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (ndchar <= (-2.3d+154)) then
        tmp = (ndchar / (exp((vef / kbt)) + 1.0d0)) + ((kbt * nachar) / ev)
    else if (ndchar <= 2.2d-291) then
        tmp = nachar / (exp((ev / kbt)) + 1.0d0)
    else if (ndchar <= 4.1d+133) then
        tmp = (nachar / (exp((eaccept / kbt)) + 1.0d0)) + (ndchar * 0.5d0)
    else
        tmp = ndchar / (exp((edonor / kbt)) + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (NdChar <= -2.3e+154) {
		tmp = (NdChar / (Math.exp((Vef / KbT)) + 1.0)) + ((KbT * NaChar) / Ev);
	} else if (NdChar <= 2.2e-291) {
		tmp = NaChar / (Math.exp((Ev / KbT)) + 1.0);
	} else if (NdChar <= 4.1e+133) {
		tmp = (NaChar / (Math.exp((EAccept / KbT)) + 1.0)) + (NdChar * 0.5);
	} else {
		tmp = NdChar / (Math.exp((EDonor / KbT)) + 1.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NdChar <= -2.3e+154:
		tmp = (NdChar / (math.exp((Vef / KbT)) + 1.0)) + ((KbT * NaChar) / Ev)
	elif NdChar <= 2.2e-291:
		tmp = NaChar / (math.exp((Ev / KbT)) + 1.0)
	elif NdChar <= 4.1e+133:
		tmp = (NaChar / (math.exp((EAccept / KbT)) + 1.0)) + (NdChar * 0.5)
	else:
		tmp = NdChar / (math.exp((EDonor / KbT)) + 1.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NdChar <= -2.3e+154)
		tmp = Float64(Float64(NdChar / Float64(exp(Float64(Vef / KbT)) + 1.0)) + Float64(Float64(KbT * NaChar) / Ev));
	elseif (NdChar <= 2.2e-291)
		tmp = Float64(NaChar / Float64(exp(Float64(Ev / KbT)) + 1.0));
	elseif (NdChar <= 4.1e+133)
		tmp = Float64(Float64(NaChar / Float64(exp(Float64(EAccept / KbT)) + 1.0)) + Float64(NdChar * 0.5));
	else
		tmp = Float64(NdChar / Float64(exp(Float64(EDonor / KbT)) + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (NdChar <= -2.3e+154)
		tmp = (NdChar / (exp((Vef / KbT)) + 1.0)) + ((KbT * NaChar) / Ev);
	elseif (NdChar <= 2.2e-291)
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	elseif (NdChar <= 4.1e+133)
		tmp = (NaChar / (exp((EAccept / KbT)) + 1.0)) + (NdChar * 0.5);
	else
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -2.3e+154], N[(N[(NdChar / N[(N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(N[(KbT * NaChar), $MachinePrecision] / Ev), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.2e-291], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 4.1e+133], N[(N[(NaChar / N[(N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 16: 40.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -1.42 \cdot 10^{+163} \lor \neg \left(NdChar \leq 4.8 \cdot 10^{+127}\right):\\ \;\;\;\;\frac{NdChar}{e^{\frac{EDonor}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -1.42e+163) (not (<= NdChar 4.8e+127)))
   (/ NdChar (+ (exp (/ EDonor KbT)) 1.0))
   (/ NaChar (+ (exp (/ Ev KbT)) 1.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -1.42e+163) || !(NdChar <= 4.8e+127)) {
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	} else {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -1.42e+163) || ~((NdChar <= 4.8e+127)))
		tmp = NdChar / (exp((EDonor / KbT)) + 1.0);
	else
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.42e+163], N[Not[LessEqual[NdChar, 4.8e+127]], $MachinePrecision]], N[(NdChar / N[(N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 17: 40.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.5 \cdot 10^{+97}:\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{elif}\;KbT \leq 3.35 \cdot 10^{+159}:\\ \;\;\;\;\frac{NaChar}{e^{\frac{Ev}{KbT}} + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + 2} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.5e+97)
   (* 0.5 (+ NdChar NaChar))
   (if (<= KbT 3.35e+159)
     (/ NaChar (+ (exp (/ Ev KbT)) 1.0))
     (+ (/ NaChar (+ (/ Ev KbT) 2.0)) (* 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 <= -1.5e+97) {
		tmp = 0.5 * (NdChar + NaChar);
	} else if (KbT <= 3.35e+159) {
		tmp = NaChar / (exp((Ev / KbT)) + 1.0);
	} else {
		tmp = (NaChar / ((Ev / KbT) + 2.0)) + (NdChar * 0.5);
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.5e+97], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.35e+159], N[(NaChar / N[(N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 18: 28.2% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.1 \cdot 10^{-68} \lor \neg \left(KbT \leq 2.4 \cdot 10^{-294}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;NaChar \cdot \frac{KbT}{Ev}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -2.1e-68) (not (<= KbT 2.4e-294)))
   (* 0.5 (+ NdChar NaChar))
   (* NaChar (/ KbT Ev))))

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 <= -2.1e-68) || !(KbT <= 2.4e-294)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar * (KbT / Ev);
	}
	return tmp;
}

Fortran

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

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -2.1e-68) || !(KbT <= 2.4e-294)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar * (KbT / Ev);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -2.1e-68) or not (KbT <= 2.4e-294):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar * (KbT / Ev)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -2.1e-68) || !(KbT <= 2.4e-294))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar * Float64(KbT / Ev));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -2.1e-68) || ~((KbT <= 2.4e-294)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar * (KbT / Ev);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -2.1e-68], N[Not[LessEqual[KbT, 2.4e-294]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar * N[(KbT / Ev), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 19: 27.6% accurate, 45.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 20: 18.0% accurate, 76.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Reproduce

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