
(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))))))
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))));
}
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
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))));
}
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))))
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
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
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]
\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}
Sampling outcomes in binary64 precision:
Herbie found 28 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(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))))))
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))));
}
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
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))));
}
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))))
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
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
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]
\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 (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (pow E (/ (+ (- mu Ec) (+ Vef EDonor)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + pow(((double) M_E), (((mu - Ec) + (Vef + EDonor)) / KbT)))) + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
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.pow(Math.E, (((mu - Ec) + (Vef + EDonor)) / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.pow(math.e, (((mu - Ec) + (Vef + EDonor)) / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + (exp(1) ^ Float64(Float64(Float64(mu - Ec) + Float64(Vef + EDonor)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + (2.71828182845904523536 ^ (((mu - Ec) + (Vef + EDonor)) / KbT)))) + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Power[E, N[(N[(N[(mu - Ec), $MachinePrecision] + N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + {e}^{\left(\frac{\left(mu - Ec\right) + \left(Vef + EDonor\right)}{KbT}\right)}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
*-un-lft-identity99.9%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (+ (/ EAccept KbT) 2.0))
(t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_2 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_3 (+ t_2 (/ NaChar (+ (/ Ev KbT) (+ t_0 (/ (- Vef mu) KbT))))))
(t_4 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_5
(+
t_4
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT)))))))
(if (<= EAccept -6.8e-223)
t_1
(if (<= EAccept 6.8e-224)
t_3
(if (<= EAccept 6.2e-194)
(+ t_4 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= EAccept 3.3e-74)
t_3
(if (<= EAccept 1.25e-14)
t_5
(if (<= EAccept 4.5e+113)
(+
t_2
(/ NaChar (+ t_0 (* 0.5 (/ (* EAccept EAccept) (* KbT KbT))))))
(if (<= EAccept 9.8e+221)
t_5
(if (or (<= EAccept 3.3e+253) (not (<= EAccept 2.6e+280)))
t_1
(+
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (EAccept / KbT) + 2.0;
double t_1 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_3 = t_2 + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT))));
double t_4 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_5 = t_4 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
double tmp;
if (EAccept <= -6.8e-223) {
tmp = t_1;
} else if (EAccept <= 6.8e-224) {
tmp = t_3;
} else if (EAccept <= 6.2e-194) {
tmp = t_4 + (NdChar / (1.0 + (mu / KbT)));
} else if (EAccept <= 3.3e-74) {
tmp = t_3;
} else if (EAccept <= 1.25e-14) {
tmp = t_5;
} else if (EAccept <= 4.5e+113) {
tmp = t_2 + (NaChar / (t_0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (EAccept <= 9.8e+221) {
tmp = t_5;
} else if ((EAccept <= 3.3e+253) || !(EAccept <= 2.6e+280)) {
tmp = t_1;
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: tmp
t_0 = (eaccept / kbt) + 2.0d0
t_1 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_2 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_3 = t_2 + (nachar / ((ev / kbt) + (t_0 + ((vef - mu) / kbt))))
t_4 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_5 = t_4 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
if (eaccept <= (-6.8d-223)) then
tmp = t_1
else if (eaccept <= 6.8d-224) then
tmp = t_3
else if (eaccept <= 6.2d-194) then
tmp = t_4 + (ndchar / (1.0d0 + (mu / kbt)))
else if (eaccept <= 3.3d-74) then
tmp = t_3
else if (eaccept <= 1.25d-14) then
tmp = t_5
else if (eaccept <= 4.5d+113) then
tmp = t_2 + (nachar / (t_0 + (0.5d0 * ((eaccept * eaccept) / (kbt * kbt)))))
else if (eaccept <= 9.8d+221) then
tmp = t_5
else if ((eaccept <= 3.3d+253) .or. (.not. (eaccept <= 2.6d+280))) then
tmp = t_1
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (EAccept / KbT) + 2.0;
double t_1 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_2 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_3 = t_2 + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT))));
double t_4 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_5 = t_4 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
double tmp;
if (EAccept <= -6.8e-223) {
tmp = t_1;
} else if (EAccept <= 6.8e-224) {
tmp = t_3;
} else if (EAccept <= 6.2e-194) {
tmp = t_4 + (NdChar / (1.0 + (mu / KbT)));
} else if (EAccept <= 3.3e-74) {
tmp = t_3;
} else if (EAccept <= 1.25e-14) {
tmp = t_5;
} else if (EAccept <= 4.5e+113) {
tmp = t_2 + (NaChar / (t_0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (EAccept <= 9.8e+221) {
tmp = t_5;
} else if ((EAccept <= 3.3e+253) || !(EAccept <= 2.6e+280)) {
tmp = t_1;
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (EAccept / KbT) + 2.0 t_1 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_2 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_3 = t_2 + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))) t_4 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_5 = t_4 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) tmp = 0 if EAccept <= -6.8e-223: tmp = t_1 elif EAccept <= 6.8e-224: tmp = t_3 elif EAccept <= 6.2e-194: tmp = t_4 + (NdChar / (1.0 + (mu / KbT))) elif EAccept <= 3.3e-74: tmp = t_3 elif EAccept <= 1.25e-14: tmp = t_5 elif EAccept <= 4.5e+113: tmp = t_2 + (NaChar / (t_0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))) elif EAccept <= 9.8e+221: tmp = t_5 elif (EAccept <= 3.3e+253) or not (EAccept <= 2.6e+280): tmp = t_1 else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(EAccept / KbT) + 2.0) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_3 = Float64(t_2 + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(t_0 + Float64(Float64(Vef - mu) / KbT))))) t_4 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_5 = Float64(t_4 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))))) tmp = 0.0 if (EAccept <= -6.8e-223) tmp = t_1; elseif (EAccept <= 6.8e-224) tmp = t_3; elseif (EAccept <= 6.2e-194) tmp = Float64(t_4 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (EAccept <= 3.3e-74) tmp = t_3; elseif (EAccept <= 1.25e-14) tmp = t_5; elseif (EAccept <= 4.5e+113) tmp = Float64(t_2 + Float64(NaChar / Float64(t_0 + Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT)))))); elseif (EAccept <= 9.8e+221) tmp = t_5; elseif ((EAccept <= 3.3e+253) || !(EAccept <= 2.6e+280)) tmp = t_1; else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (EAccept / KbT) + 2.0; t_1 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_3 = t_2 + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))); t_4 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_5 = t_4 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))); tmp = 0.0; if (EAccept <= -6.8e-223) tmp = t_1; elseif (EAccept <= 6.8e-224) tmp = t_3; elseif (EAccept <= 6.2e-194) tmp = t_4 + (NdChar / (1.0 + (mu / KbT))); elseif (EAccept <= 3.3e-74) tmp = t_3; elseif (EAccept <= 1.25e-14) tmp = t_5; elseif (EAccept <= 4.5e+113) tmp = t_2 + (NaChar / (t_0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))); elseif (EAccept <= 9.8e+221) tmp = t_5; elseif ((EAccept <= 3.3e+253) || ~((EAccept <= 2.6e+280))) tmp = t_1; else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(t$95$0 + N[(N[(Vef - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$4 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -6.8e-223], t$95$1, If[LessEqual[EAccept, 6.8e-224], t$95$3, If[LessEqual[EAccept, 6.2e-194], N[(t$95$4 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.3e-74], t$95$3, If[LessEqual[EAccept, 1.25e-14], t$95$5, If[LessEqual[EAccept, 4.5e+113], N[(t$95$2 + N[(NaChar / N[(t$95$0 + N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 9.8e+221], t$95$5, If[Or[LessEqual[EAccept, 3.3e+253], N[Not[LessEqual[EAccept, 2.6e+280]], $MachinePrecision]], t$95$1, N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{EAccept}{KbT} + 2\\
t_1 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_3 := t_2 + \frac{NaChar}{\frac{Ev}{KbT} + \left(t_0 + \frac{Vef - mu}{KbT}\right)}\\
t_4 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_5 := t_4 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\
\mathbf{if}\;EAccept \leq -6.8 \cdot 10^{-223}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 6.8 \cdot 10^{-224}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;EAccept \leq 6.2 \cdot 10^{-194}:\\
\;\;\;\;t_4 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;EAccept \leq 3.3 \cdot 10^{-74}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;EAccept \leq 1.25 \cdot 10^{-14}:\\
\;\;\;\;t_5\\
\mathbf{elif}\;EAccept \leq 4.5 \cdot 10^{+113}:\\
\;\;\;\;t_2 + \frac{NaChar}{t_0 + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}}\\
\mathbf{elif}\;EAccept \leq 9.8 \cdot 10^{+221}:\\
\;\;\;\;t_5\\
\mathbf{elif}\;EAccept \leq 3.3 \cdot 10^{+253} \lor \neg \left(EAccept \leq 2.6 \cdot 10^{+280}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -6.7999999999999996e-223 or 9.7999999999999998e221 < EAccept < 3.2999999999999999e253 or 2.5999999999999999e280 < EAccept Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 71.9%
Taylor expanded in EAccept around 0 53.2%
Taylor expanded in NdChar around inf 64.6%
if -6.7999999999999996e-223 < EAccept < 6.79999999999999984e-224 or 6.2000000000000002e-194 < EAccept < 3.29999999999999996e-74Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 68.9%
associate--l+68.9%
associate-+r+68.9%
associate--l+68.9%
+-commutative68.9%
unsub-neg68.9%
+-commutative68.9%
neg-sub068.9%
associate-+l-68.9%
div-sub68.9%
unsub-neg68.9%
mul-1-neg68.9%
+-commutative68.9%
neg-sub068.9%
+-commutative68.9%
mul-1-neg68.9%
unsub-neg68.9%
Simplified68.9%
if 6.79999999999999984e-224 < EAccept < 6.2000000000000002e-194Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 87.5%
Taylor expanded in mu around inf 66.6%
if 3.29999999999999996e-74 < EAccept < 1.25e-14 or 4.5000000000000001e113 < EAccept < 9.7999999999999998e221Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 79.4%
if 1.25e-14 < EAccept < 4.5000000000000001e113Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 86.9%
Taylor expanded in EAccept around 0 72.9%
associate-+r+72.9%
+-commutative72.9%
unpow272.9%
unpow272.9%
Simplified72.9%
if 3.2999999999999999e253 < EAccept < 2.5999999999999999e280Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 89.2%
Taylor expanded in EDonor around inf 89.4%
Final simplification69.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(t_1 (+ (/ EAccept KbT) 2.0))
(t_2 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_3 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_4 (+ t_3 (/ NaChar (+ (/ Ev KbT) (+ t_1 (/ (- Vef mu) KbT))))))
(t_5 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_6
(+
t_5
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT)))))))
(if (<= EAccept -5.4e-223)
t_2
(if (<= EAccept 1.35e-225)
t_4
(if (<= EAccept 2.25e-194)
(+ t_5 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= EAccept 3.4e-74)
t_4
(if (<= EAccept 3.4e-13)
t_6
(if (<= EAccept 9e+114)
(+
t_3
(/ NaChar (+ t_1 (* 0.5 (/ (* EAccept EAccept) (* KbT KbT))))))
(if (<= EAccept 4.7e+221)
t_6
(if (<= EAccept 1.6e+252)
t_2
(if (<= EAccept 1.7e+273)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT))))))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
double t_1 = (EAccept / KbT) + 2.0;
double t_2 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_3 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_4 = t_3 + (NaChar / ((Ev / KbT) + (t_1 + ((Vef - mu) / KbT))));
double t_5 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_6 = t_5 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
double tmp;
if (EAccept <= -5.4e-223) {
tmp = t_2;
} else if (EAccept <= 1.35e-225) {
tmp = t_4;
} else if (EAccept <= 2.25e-194) {
tmp = t_5 + (NdChar / (1.0 + (mu / KbT)));
} else if (EAccept <= 3.4e-74) {
tmp = t_4;
} else if (EAccept <= 3.4e-13) {
tmp = t_6;
} else if (EAccept <= 9e+114) {
tmp = t_3 + (NaChar / (t_1 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (EAccept <= 4.7e+221) {
tmp = t_6;
} else if (EAccept <= 1.6e+252) {
tmp = t_2;
} else if (EAccept <= 1.7e+273) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else {
tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: t_6
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((eaccept / kbt)))
t_1 = (eaccept / kbt) + 2.0d0
t_2 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_3 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_4 = t_3 + (nachar / ((ev / kbt) + (t_1 + ((vef - mu) / kbt))))
t_5 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_6 = t_5 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
if (eaccept <= (-5.4d-223)) then
tmp = t_2
else if (eaccept <= 1.35d-225) then
tmp = t_4
else if (eaccept <= 2.25d-194) then
tmp = t_5 + (ndchar / (1.0d0 + (mu / kbt)))
else if (eaccept <= 3.4d-74) then
tmp = t_4
else if (eaccept <= 3.4d-13) then
tmp = t_6
else if (eaccept <= 9d+114) then
tmp = t_3 + (nachar / (t_1 + (0.5d0 * ((eaccept * eaccept) / (kbt * kbt)))))
else if (eaccept <= 4.7d+221) then
tmp = t_6
else if (eaccept <= 1.6d+252) then
tmp = t_2
else if (eaccept <= 1.7d+273) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else
tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
end if
code = tmp
end function
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 / (1.0 + Math.exp((EAccept / KbT)));
double t_1 = (EAccept / KbT) + 2.0;
double t_2 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_3 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_4 = t_3 + (NaChar / ((Ev / KbT) + (t_1 + ((Vef - mu) / KbT))));
double t_5 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_6 = t_5 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
double tmp;
if (EAccept <= -5.4e-223) {
tmp = t_2;
} else if (EAccept <= 1.35e-225) {
tmp = t_4;
} else if (EAccept <= 2.25e-194) {
tmp = t_5 + (NdChar / (1.0 + (mu / KbT)));
} else if (EAccept <= 3.4e-74) {
tmp = t_4;
} else if (EAccept <= 3.4e-13) {
tmp = t_6;
} else if (EAccept <= 9e+114) {
tmp = t_3 + (NaChar / (t_1 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (EAccept <= 4.7e+221) {
tmp = t_6;
} else if (EAccept <= 1.6e+252) {
tmp = t_2;
} else if (EAccept <= 1.7e+273) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else {
tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((EAccept / KbT))) t_1 = (EAccept / KbT) + 2.0 t_2 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_3 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_4 = t_3 + (NaChar / ((Ev / KbT) + (t_1 + ((Vef - mu) / KbT)))) t_5 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_6 = t_5 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) tmp = 0 if EAccept <= -5.4e-223: tmp = t_2 elif EAccept <= 1.35e-225: tmp = t_4 elif EAccept <= 2.25e-194: tmp = t_5 + (NdChar / (1.0 + (mu / KbT))) elif EAccept <= 3.4e-74: tmp = t_4 elif EAccept <= 3.4e-13: tmp = t_6 elif EAccept <= 9e+114: tmp = t_3 + (NaChar / (t_1 + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))) elif EAccept <= 4.7e+221: tmp = t_6 elif EAccept <= 1.6e+252: tmp = t_2 elif EAccept <= 1.7e+273: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) else: tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) t_1 = Float64(Float64(EAccept / KbT) + 2.0) t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_3 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_4 = Float64(t_3 + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(t_1 + Float64(Float64(Vef - mu) / KbT))))) t_5 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_6 = Float64(t_5 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))))) tmp = 0.0 if (EAccept <= -5.4e-223) tmp = t_2; elseif (EAccept <= 1.35e-225) tmp = t_4; elseif (EAccept <= 2.25e-194) tmp = Float64(t_5 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (EAccept <= 3.4e-74) tmp = t_4; elseif (EAccept <= 3.4e-13) tmp = t_6; elseif (EAccept <= 9e+114) tmp = Float64(t_3 + Float64(NaChar / Float64(t_1 + Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT)))))); elseif (EAccept <= 4.7e+221) tmp = t_6; elseif (EAccept <= 1.6e+252) tmp = t_2; elseif (EAccept <= 1.7e+273) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); else tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((EAccept / KbT))); t_1 = (EAccept / KbT) + 2.0; t_2 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_3 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_4 = t_3 + (NaChar / ((Ev / KbT) + (t_1 + ((Vef - mu) / KbT)))); t_5 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_6 = t_5 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))); tmp = 0.0; if (EAccept <= -5.4e-223) tmp = t_2; elseif (EAccept <= 1.35e-225) tmp = t_4; elseif (EAccept <= 2.25e-194) tmp = t_5 + (NdChar / (1.0 + (mu / KbT))); elseif (EAccept <= 3.4e-74) tmp = t_4; elseif (EAccept <= 3.4e-13) tmp = t_6; elseif (EAccept <= 9e+114) tmp = t_3 + (NaChar / (t_1 + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))); elseif (EAccept <= 4.7e+221) tmp = t_6; elseif (EAccept <= 1.6e+252) tmp = t_2; elseif (EAccept <= 1.7e+273) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); else tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$3 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(t$95$1 + N[(N[(Vef - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = N[(t$95$5 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -5.4e-223], t$95$2, If[LessEqual[EAccept, 1.35e-225], t$95$4, If[LessEqual[EAccept, 2.25e-194], N[(t$95$5 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.4e-74], t$95$4, If[LessEqual[EAccept, 3.4e-13], t$95$6, If[LessEqual[EAccept, 9e+114], N[(t$95$3 + N[(NaChar / N[(t$95$1 + N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 4.7e+221], t$95$6, If[LessEqual[EAccept, 1.6e+252], t$95$2, If[LessEqual[EAccept, 1.7e+273], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
t_1 := \frac{EAccept}{KbT} + 2\\
t_2 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_3 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_4 := t_3 + \frac{NaChar}{\frac{Ev}{KbT} + \left(t_1 + \frac{Vef - mu}{KbT}\right)}\\
t_5 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_6 := t_5 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\
\mathbf{if}\;EAccept \leq -5.4 \cdot 10^{-223}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;EAccept \leq 1.35 \cdot 10^{-225}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;EAccept \leq 2.25 \cdot 10^{-194}:\\
\;\;\;\;t_5 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;EAccept \leq 3.4 \cdot 10^{-74}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;EAccept \leq 3.4 \cdot 10^{-13}:\\
\;\;\;\;t_6\\
\mathbf{elif}\;EAccept \leq 9 \cdot 10^{+114}:\\
\;\;\;\;t_3 + \frac{NaChar}{t_1 + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}}\\
\mathbf{elif}\;EAccept \leq 4.7 \cdot 10^{+221}:\\
\;\;\;\;t_6\\
\mathbf{elif}\;EAccept \leq 1.6 \cdot 10^{+252}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;EAccept \leq 1.7 \cdot 10^{+273}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -5.39999999999999977e-223 or 4.70000000000000006e221 < EAccept < 1.6000000000000001e252Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in EAccept around inf 69.9%
Taylor expanded in EAccept around 0 55.0%
Taylor expanded in NdChar around inf 65.5%
if -5.39999999999999977e-223 < EAccept < 1.34999999999999996e-225 or 2.2499999999999999e-194 < EAccept < 3.4000000000000001e-74Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 68.4%
associate--l+68.4%
associate-+r+68.4%
associate--l+68.4%
+-commutative68.4%
unsub-neg68.4%
+-commutative68.4%
neg-sub068.4%
associate-+l-68.4%
div-sub68.4%
unsub-neg68.4%
mul-1-neg68.4%
+-commutative68.4%
neg-sub068.4%
+-commutative68.4%
mul-1-neg68.4%
unsub-neg68.4%
Simplified68.4%
if 1.34999999999999996e-225 < EAccept < 2.2499999999999999e-194Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 87.5%
Taylor expanded in mu around inf 66.6%
if 3.4000000000000001e-74 < EAccept < 3.40000000000000015e-13 or 9.0000000000000001e114 < EAccept < 4.70000000000000006e221Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 79.4%
if 3.40000000000000015e-13 < EAccept < 9.0000000000000001e114Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 86.9%
Taylor expanded in EAccept around 0 72.9%
associate-+r+72.9%
+-commutative72.9%
unpow272.9%
unpow272.9%
Simplified72.9%
if 1.6000000000000001e252 < EAccept < 1.69999999999999999e273Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 87.9%
Taylor expanded in EDonor around inf 88.1%
if 1.69999999999999999e273 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 100.0%
Taylor expanded in mu around inf 71.4%
Final simplification69.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_2 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(t_3 (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT)))))
(t_4 (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) t_2))
(t_5
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(+
(/ NaChar t_3)
(/
NaChar
(/
(*
KbT
(* t_3 (+ (+ (/ EAccept KbT) (/ Ev KbT)) (+ (/ Vef KbT) 2.0))))
mu))))))
(if (<= mu -1.75e+123)
t_4
(if (<= mu -2.25e+26)
t_5
(if (<= mu -0.00115)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) t_2)
(if (<= mu -3.7e-69)
t_1
(if (<= mu -3.6e-119)
(+ t_0 (/ NdChar (+ 1.0 (/ EDonor KbT))))
(if (<= mu -4.9e-191)
t_1
(if (<= mu 1.45e-142)
(+
t_0
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT)))))
(if (<= mu 2.3e+101) t_5 t_4))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_2 = NdChar / (1.0 + exp((mu / KbT)));
double t_3 = 2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)));
double t_4 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_2;
double t_5 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + ((NaChar / t_3) + (NaChar / ((KbT * (t_3 * (((EAccept / KbT) + (Ev / KbT)) + ((Vef / KbT) + 2.0)))) / mu)));
double tmp;
if (mu <= -1.75e+123) {
tmp = t_4;
} else if (mu <= -2.25e+26) {
tmp = t_5;
} else if (mu <= -0.00115) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_2;
} else if (mu <= -3.7e-69) {
tmp = t_1;
} else if (mu <= -3.6e-119) {
tmp = t_0 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (mu <= -4.9e-191) {
tmp = t_1;
} else if (mu <= 1.45e-142) {
tmp = t_0 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else if (mu <= 2.3e+101) {
tmp = t_5;
} else {
tmp = t_4;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_2 = ndchar / (1.0d0 + exp((mu / kbt)))
t_3 = 2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))
t_4 = (nachar / (1.0d0 + exp((-mu / kbt)))) + t_2
t_5 = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + ((nachar / t_3) + (nachar / ((kbt * (t_3 * (((eaccept / kbt) + (ev / kbt)) + ((vef / kbt) + 2.0d0)))) / mu)))
if (mu <= (-1.75d+123)) then
tmp = t_4
else if (mu <= (-2.25d+26)) then
tmp = t_5
else if (mu <= (-0.00115d0)) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + t_2
else if (mu <= (-3.7d-69)) then
tmp = t_1
else if (mu <= (-3.6d-119)) then
tmp = t_0 + (ndchar / (1.0d0 + (edonor / kbt)))
else if (mu <= (-4.9d-191)) then
tmp = t_1
else if (mu <= 1.45d-142) then
tmp = t_0 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
else if (mu <= 2.3d+101) then
tmp = t_5
else
tmp = t_4
end if
code = tmp
end function
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 / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_2 = NdChar / (1.0 + Math.exp((mu / KbT)));
double t_3 = 2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)));
double t_4 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + t_2;
double t_5 = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + ((NaChar / t_3) + (NaChar / ((KbT * (t_3 * (((EAccept / KbT) + (Ev / KbT)) + ((Vef / KbT) + 2.0)))) / mu)));
double tmp;
if (mu <= -1.75e+123) {
tmp = t_4;
} else if (mu <= -2.25e+26) {
tmp = t_5;
} else if (mu <= -0.00115) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + t_2;
} else if (mu <= -3.7e-69) {
tmp = t_1;
} else if (mu <= -3.6e-119) {
tmp = t_0 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (mu <= -4.9e-191) {
tmp = t_1;
} else if (mu <= 1.45e-142) {
tmp = t_0 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else if (mu <= 2.3e+101) {
tmp = t_5;
} else {
tmp = t_4;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_2 = NdChar / (1.0 + math.exp((mu / KbT))) t_3 = 2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT))) t_4 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + t_2 t_5 = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + ((NaChar / t_3) + (NaChar / ((KbT * (t_3 * (((EAccept / KbT) + (Ev / KbT)) + ((Vef / KbT) + 2.0)))) / mu))) tmp = 0 if mu <= -1.75e+123: tmp = t_4 elif mu <= -2.25e+26: tmp = t_5 elif mu <= -0.00115: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + t_2 elif mu <= -3.7e-69: tmp = t_1 elif mu <= -3.6e-119: tmp = t_0 + (NdChar / (1.0 + (EDonor / KbT))) elif mu <= -4.9e-191: tmp = t_1 elif mu <= 1.45e-142: tmp = t_0 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) elif mu <= 2.3e+101: tmp = t_5 else: tmp = t_4 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) t_3 = Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) t_4 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + t_2) t_5 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(Float64(NaChar / t_3) + Float64(NaChar / Float64(Float64(KbT * Float64(t_3 * Float64(Float64(Float64(EAccept / KbT) + Float64(Ev / KbT)) + Float64(Float64(Vef / KbT) + 2.0)))) / mu)))) tmp = 0.0 if (mu <= -1.75e+123) tmp = t_4; elseif (mu <= -2.25e+26) tmp = t_5; elseif (mu <= -0.00115) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + t_2); elseif (mu <= -3.7e-69) tmp = t_1; elseif (mu <= -3.6e-119) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT)))); elseif (mu <= -4.9e-191) tmp = t_1; elseif (mu <= 1.45e-142) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))))); elseif (mu <= 2.3e+101) tmp = t_5; else tmp = t_4; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_2 = NdChar / (1.0 + exp((mu / KbT))); t_3 = 2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT))); t_4 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_2; t_5 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + ((NaChar / t_3) + (NaChar / ((KbT * (t_3 * (((EAccept / KbT) + (Ev / KbT)) + ((Vef / KbT) + 2.0)))) / mu))); tmp = 0.0; if (mu <= -1.75e+123) tmp = t_4; elseif (mu <= -2.25e+26) tmp = t_5; elseif (mu <= -0.00115) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_2; elseif (mu <= -3.7e-69) tmp = t_1; elseif (mu <= -3.6e-119) tmp = t_0 + (NdChar / (1.0 + (EDonor / KbT))); elseif (mu <= -4.9e-191) tmp = t_1; elseif (mu <= 1.45e-142) tmp = t_0 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))); elseif (mu <= 2.3e+101) tmp = t_5; else tmp = t_4; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]}, Block[{t$95$5 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(NaChar / t$95$3), $MachinePrecision] + N[(NaChar / N[(N[(KbT * N[(t$95$3 * N[(N[(N[(EAccept / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.75e+123], t$95$4, If[LessEqual[mu, -2.25e+26], t$95$5, If[LessEqual[mu, -0.00115], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[mu, -3.7e-69], t$95$1, If[LessEqual[mu, -3.6e-119], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -4.9e-191], t$95$1, If[LessEqual[mu, 1.45e-142], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.3e+101], t$95$5, t$95$4]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
t_3 := 2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\\
t_4 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + t_2\\
t_5 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \left(\frac{NaChar}{t_3} + \frac{NaChar}{\frac{KbT \cdot \left(t_3 \cdot \left(\left(\frac{EAccept}{KbT} + \frac{Ev}{KbT}\right) + \left(\frac{Vef}{KbT} + 2\right)\right)\right)}{mu}}\right)\\
\mathbf{if}\;mu \leq -1.75 \cdot 10^{+123}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;mu \leq -2.25 \cdot 10^{+26}:\\
\;\;\;\;t_5\\
\mathbf{elif}\;mu \leq -0.00115:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + t_2\\
\mathbf{elif}\;mu \leq -3.7 \cdot 10^{-69}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;mu \leq -3.6 \cdot 10^{-119}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\
\mathbf{elif}\;mu \leq -4.9 \cdot 10^{-191}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;mu \leq 1.45 \cdot 10^{-142}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\
\mathbf{elif}\;mu \leq 2.3 \cdot 10^{+101}:\\
\;\;\;\;t_5\\
\mathbf{else}:\\
\;\;\;\;t_4\\
\end{array}
\end{array}
if mu < -1.75e123 or 2.3000000000000001e101 < mu Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in mu around inf 89.5%
neg-mul-189.5%
distribute-neg-frac89.5%
Simplified89.5%
Taylor expanded in mu around inf 81.2%
if -1.75e123 < mu < -2.24999999999999989e26 or 1.44999999999999995e-142 < mu < 2.3000000000000001e101Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 72.0%
associate--l+72.0%
associate-+r+72.0%
associate--l+72.0%
+-commutative72.0%
unsub-neg72.0%
+-commutative72.0%
neg-sub072.0%
associate-+l-72.0%
div-sub73.5%
unsub-neg73.5%
mul-1-neg73.5%
+-commutative73.5%
neg-sub073.5%
+-commutative73.5%
mul-1-neg73.5%
unsub-neg73.5%
Simplified73.5%
flip-+53.0%
distribute-neg-frac53.0%
distribute-neg-frac53.0%
distribute-neg-frac53.0%
Applied egg-rr53.0%
difference-of-squares57.4%
distribute-frac-neg57.4%
sub-neg57.4%
sub-neg57.4%
distribute-frac-neg57.4%
remove-double-neg57.4%
associate--l+57.4%
sub-neg57.4%
distribute-frac-neg57.4%
remove-double-neg57.4%
Simplified57.4%
Taylor expanded in mu around 0 72.2%
associate-/l*73.7%
associate-+r+73.7%
Simplified73.7%
if -2.24999999999999989e26 < mu < -0.00115Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 80.4%
Taylor expanded in mu around inf 61.9%
if -0.00115 < mu < -3.7000000000000002e-69 or -3.6e-119 < mu < -4.9e-191Initial program 99.5%
neg-sub099.5%
associate--r-99.5%
+-commutative99.5%
neg-sub099.5%
sub-neg99.5%
associate--l-99.5%
unsub-neg99.5%
+-commutative99.5%
associate-+l+99.5%
Simplified99.5%
Taylor expanded in EAccept around inf 69.3%
Taylor expanded in EAccept around 0 46.4%
Taylor expanded in NdChar around inf 87.9%
if -3.7000000000000002e-69 < mu < -3.6e-119Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in KbT around inf 56.3%
Taylor expanded in EDonor around inf 80.5%
if -4.9e-191 < mu < 1.44999999999999995e-142Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 70.9%
Final simplification77.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT))))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= mu -1.65e+89)
t_0
(if (<= mu -3.7e-227)
(+ t_1 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= mu 1.3e+178)
(+ t_1 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
double t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (mu <= -1.65e+89) {
tmp = t_0;
} else if (mu <= -3.7e-227) {
tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (mu <= 1.3e+178) {
tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
t_1 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (mu <= (-1.65d+89)) then
tmp = t_0
else if (mu <= (-3.7d-227)) then
tmp = t_1 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (mu <= 1.3d+178) then
tmp = t_1 + (nachar / (1.0d0 + exp((eaccept / kbt))))
else
tmp = t_0
end if
code = tmp
end function
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 / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
double t_1 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (mu <= -1.65e+89) {
tmp = t_0;
} else if (mu <= -3.7e-227) {
tmp = t_1 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (mu <= 1.3e+178) {
tmp = t_1 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) t_1 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if mu <= -1.65e+89: tmp = t_0 elif mu <= -3.7e-227: tmp = t_1 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif mu <= 1.3e+178: tmp = t_1 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) else: tmp = t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (mu <= -1.65e+89) tmp = t_0; elseif (mu <= -3.7e-227) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (mu <= 1.3e+178) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); else tmp = t_0; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (mu <= -1.65e+89) tmp = t_0; elseif (mu <= -3.7e-227) tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (mu <= 1.3e+178) tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT)))); else tmp = t_0; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.65e+89], t$95$0, If[LessEqual[mu, -3.7e-227], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.3e+178], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;mu \leq -1.65 \cdot 10^{+89}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;mu \leq -3.7 \cdot 10^{-227}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;mu \leq 1.3 \cdot 10^{+178}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if mu < -1.64999999999999987e89 or 1.3e178 < mu Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in mu around inf 92.4%
neg-mul-192.4%
distribute-neg-frac92.4%
Simplified92.4%
Taylor expanded in mu around inf 83.4%
if -1.64999999999999987e89 < mu < -3.69999999999999978e-227Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in Ev around inf 75.9%
if -3.69999999999999978e-227 < mu < 1.3e178Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 81.8%
Final simplification80.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT))))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= mu -2.45e+154)
t_0
(if (<= mu -2.15e-69)
(+ t_1 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
(if (<= mu 1.1e+179)
(+ t_1 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
double t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (mu <= -2.45e+154) {
tmp = t_0;
} else if (mu <= -2.15e-69) {
tmp = t_1 + (NaChar / (1.0 + exp((Vef / KbT))));
} else if (mu <= 1.1e+179) {
tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
t_1 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (mu <= (-2.45d+154)) then
tmp = t_0
else if (mu <= (-2.15d-69)) then
tmp = t_1 + (nachar / (1.0d0 + exp((vef / kbt))))
else if (mu <= 1.1d+179) then
tmp = t_1 + (nachar / (1.0d0 + exp((eaccept / kbt))))
else
tmp = t_0
end if
code = tmp
end function
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 / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
double t_1 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (mu <= -2.45e+154) {
tmp = t_0;
} else if (mu <= -2.15e-69) {
tmp = t_1 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
} else if (mu <= 1.1e+179) {
tmp = t_1 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) t_1 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if mu <= -2.45e+154: tmp = t_0 elif mu <= -2.15e-69: tmp = t_1 + (NaChar / (1.0 + math.exp((Vef / KbT)))) elif mu <= 1.1e+179: tmp = t_1 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) else: tmp = t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (mu <= -2.45e+154) tmp = t_0; elseif (mu <= -2.15e-69) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))); elseif (mu <= 1.1e+179) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); else tmp = t_0; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (mu <= -2.45e+154) tmp = t_0; elseif (mu <= -2.15e-69) tmp = t_1 + (NaChar / (1.0 + exp((Vef / KbT)))); elseif (mu <= 1.1e+179) tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT)))); else tmp = t_0; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.45e+154], t$95$0, If[LessEqual[mu, -2.15e-69], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.1e+179], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;mu \leq -2.45 \cdot 10^{+154}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;mu \leq -2.15 \cdot 10^{-69}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{elif}\;mu \leq 1.1 \cdot 10^{+179}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if mu < -2.4500000000000001e154 or 1.1e179 < mu Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in mu around inf 93.6%
neg-mul-193.6%
distribute-neg-frac93.6%
Simplified93.6%
Taylor expanded in mu around inf 84.8%
if -2.4500000000000001e154 < mu < -2.15e-69Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 80.4%
if -2.15e-69 < mu < 1.1e179Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 80.9%
Final simplification81.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))) (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= EAccept -3.1e-124)
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT))))
(if (<= EAccept 9.5e+133)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= -3.1e-124) {
tmp = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
} else if (EAccept <= 9.5e+133) {
tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (eaccept <= (-3.1d-124)) then
tmp = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
else if (eaccept <= 9.5d+133) then
tmp = t_0 + (nachar / (1.0d0 + exp((-mu / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= -3.1e-124) {
tmp = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
} else if (EAccept <= 9.5e+133) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if EAccept <= -3.1e-124: tmp = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) elif EAccept <= 9.5e+133: tmp = t_0 + (NaChar / (1.0 + math.exp((-mu / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (EAccept <= -3.1e-124) tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))); elseif (EAccept <= 9.5e+133) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (EAccept <= -3.1e-124) tmp = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); elseif (EAccept <= 9.5e+133) tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -3.1e-124], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 9.5e+133], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;EAccept \leq -3.1 \cdot 10^{-124}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 9.5 \cdot 10^{+133}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -3.0999999999999998e-124Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in EAccept around inf 70.2%
Taylor expanded in EAccept around 0 53.8%
Taylor expanded in NdChar around inf 64.0%
if -3.0999999999999998e-124 < EAccept < 9.49999999999999996e133Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 82.3%
neg-mul-182.3%
distribute-neg-frac82.3%
Simplified82.3%
if 9.49999999999999996e133 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 94.0%
Final simplification79.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= Ev -1.1e+119)
t_0
(if (<= Ev -4.4e+64)
(+ t_1 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= Ev -1.62e-71)
t_0
(if (<= Ev -1.45e-198)
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Ev 1.1e-158)
(+
t_1
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT)))))
(+
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (Ev <= -1.1e+119) {
tmp = t_0;
} else if (Ev <= -4.4e+64) {
tmp = t_1 + (NdChar / (1.0 + (mu / KbT)));
} else if (Ev <= -1.62e-71) {
tmp = t_0;
} else if (Ev <= -1.45e-198) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Ev <= 1.1e-158) {
tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
}
return tmp;
}
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 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (ev <= (-1.1d+119)) then
tmp = t_0
else if (ev <= (-4.4d+64)) then
tmp = t_1 + (ndchar / (1.0d0 + (mu / kbt)))
else if (ev <= (-1.62d-71)) then
tmp = t_0
else if (ev <= (-1.45d-198)) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (ev <= 1.1d-158) then
tmp = t_1 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (Ev <= -1.1e+119) {
tmp = t_0;
} else if (Ev <= -4.4e+64) {
tmp = t_1 + (NdChar / (1.0 + (mu / KbT)));
} else if (Ev <= -1.62e-71) {
tmp = t_0;
} else if (Ev <= -1.45e-198) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Ev <= 1.1e-158) {
tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if Ev <= -1.1e+119: tmp = t_0 elif Ev <= -4.4e+64: tmp = t_1 + (NdChar / (1.0 + (mu / KbT))) elif Ev <= -1.62e-71: tmp = t_0 elif Ev <= -1.45e-198: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Ev <= 1.1e-158: tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (Ev <= -1.1e+119) tmp = t_0; elseif (Ev <= -4.4e+64) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (Ev <= -1.62e-71) tmp = t_0; elseif (Ev <= -1.45e-198) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Ev <= 1.1e-158) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (Ev <= -1.1e+119) tmp = t_0; elseif (Ev <= -4.4e+64) tmp = t_1 + (NdChar / (1.0 + (mu / KbT))); elseif (Ev <= -1.62e-71) tmp = t_0; elseif (Ev <= -1.45e-198) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Ev <= 1.1e-158) tmp = t_1 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))); else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -1.1e+119], t$95$0, If[LessEqual[Ev, -4.4e+64], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -1.62e-71], t$95$0, If[LessEqual[Ev, -1.45e-198], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 1.1e-158], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;Ev \leq -1.1 \cdot 10^{+119}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;Ev \leq -4.4 \cdot 10^{+64}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;Ev \leq -1.62 \cdot 10^{-71}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;Ev \leq -1.45 \cdot 10^{-198}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Ev \leq 1.1 \cdot 10^{-158}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\end{array}
\end{array}
if Ev < -1.1000000000000001e119 or -4.40000000000000004e64 < Ev < -1.6200000000000001e-71Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in EAccept around inf 67.2%
Taylor expanded in EAccept around 0 52.2%
Taylor expanded in NdChar around inf 72.1%
if -1.1000000000000001e119 < Ev < -4.40000000000000004e64Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 53.9%
Taylor expanded in mu around inf 67.2%
if -1.6200000000000001e-71 < Ev < -1.45e-198Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 87.2%
neg-mul-187.2%
distribute-neg-frac87.2%
Simplified87.2%
Taylor expanded in EDonor around inf 71.6%
if -1.45e-198 < Ev < 1.1000000000000001e-158Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 67.5%
if 1.1000000000000001e-158 < Ev Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 77.5%
Taylor expanded in mu around inf 56.1%
Final simplification65.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= mu -5.7e+149) (not (<= mu 1.1e+177)))
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((mu <= -5.7e+149) || !(mu <= 1.1e+177)) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
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 ((mu <= (-5.7d+149)) .or. (.not. (mu <= 1.1d+177))) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
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 ((mu <= -5.7e+149) || !(mu <= 1.1e+177)) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (mu <= -5.7e+149) or not (mu <= 1.1e+177): tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((mu <= -5.7e+149) || !(mu <= 1.1e+177)) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((mu <= -5.7e+149) || ~((mu <= 1.1e+177))) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[mu, -5.7e+149], N[Not[LessEqual[mu, 1.1e+177]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;mu \leq -5.7 \cdot 10^{+149} \lor \neg \left(mu \leq 1.1 \cdot 10^{+177}\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if mu < -5.69999999999999965e149 or 1.0999999999999999e177 < mu Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in mu around inf 92.3%
neg-mul-192.3%
distribute-neg-frac92.3%
Simplified92.3%
Taylor expanded in mu around inf 83.5%
if -5.69999999999999965e149 < mu < 1.0999999999999999e177Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 78.7%
Final simplification80.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (+ (/ EAccept KbT) 2.0))
(t_1 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_2 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_3 (+ t_2 (/ NaChar (+ (/ Ev KbT) (+ t_0 (/ (- Vef mu) KbT))))))
(t_4 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_5
(+
t_4
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT)))))))
(if (<= EAccept -7e-223)
t_1
(if (<= EAccept 1.95e-225)
t_3
(if (<= EAccept 5e-193)
(+ t_4 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= EAccept 3.8e-74)
t_3
(if (<= EAccept 4.5e-12)
t_5
(if (<= EAccept 1.4e+112)
(+
t_2
(/ NaChar (+ t_0 (* 0.5 (/ (* EAccept EAccept) (* KbT KbT))))))
(if (or (<= EAccept 9e+221)
(and (not (<= EAccept 7e+243)) (<= EAccept 1.05e+273)))
t_5
t_1)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (EAccept / KbT) + 2.0;
double t_1 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_3 = t_2 + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT))));
double t_4 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_5 = t_4 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
double tmp;
if (EAccept <= -7e-223) {
tmp = t_1;
} else if (EAccept <= 1.95e-225) {
tmp = t_3;
} else if (EAccept <= 5e-193) {
tmp = t_4 + (NdChar / (1.0 + (mu / KbT)));
} else if (EAccept <= 3.8e-74) {
tmp = t_3;
} else if (EAccept <= 4.5e-12) {
tmp = t_5;
} else if (EAccept <= 1.4e+112) {
tmp = t_2 + (NaChar / (t_0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if ((EAccept <= 9e+221) || (!(EAccept <= 7e+243) && (EAccept <= 1.05e+273))) {
tmp = t_5;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: tmp
t_0 = (eaccept / kbt) + 2.0d0
t_1 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_2 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_3 = t_2 + (nachar / ((ev / kbt) + (t_0 + ((vef - mu) / kbt))))
t_4 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_5 = t_4 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
if (eaccept <= (-7d-223)) then
tmp = t_1
else if (eaccept <= 1.95d-225) then
tmp = t_3
else if (eaccept <= 5d-193) then
tmp = t_4 + (ndchar / (1.0d0 + (mu / kbt)))
else if (eaccept <= 3.8d-74) then
tmp = t_3
else if (eaccept <= 4.5d-12) then
tmp = t_5
else if (eaccept <= 1.4d+112) then
tmp = t_2 + (nachar / (t_0 + (0.5d0 * ((eaccept * eaccept) / (kbt * kbt)))))
else if ((eaccept <= 9d+221) .or. (.not. (eaccept <= 7d+243)) .and. (eaccept <= 1.05d+273)) then
tmp = t_5
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (EAccept / KbT) + 2.0;
double t_1 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_2 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_3 = t_2 + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT))));
double t_4 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_5 = t_4 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
double tmp;
if (EAccept <= -7e-223) {
tmp = t_1;
} else if (EAccept <= 1.95e-225) {
tmp = t_3;
} else if (EAccept <= 5e-193) {
tmp = t_4 + (NdChar / (1.0 + (mu / KbT)));
} else if (EAccept <= 3.8e-74) {
tmp = t_3;
} else if (EAccept <= 4.5e-12) {
tmp = t_5;
} else if (EAccept <= 1.4e+112) {
tmp = t_2 + (NaChar / (t_0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if ((EAccept <= 9e+221) || (!(EAccept <= 7e+243) && (EAccept <= 1.05e+273))) {
tmp = t_5;
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (EAccept / KbT) + 2.0 t_1 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_2 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_3 = t_2 + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))) t_4 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_5 = t_4 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) tmp = 0 if EAccept <= -7e-223: tmp = t_1 elif EAccept <= 1.95e-225: tmp = t_3 elif EAccept <= 5e-193: tmp = t_4 + (NdChar / (1.0 + (mu / KbT))) elif EAccept <= 3.8e-74: tmp = t_3 elif EAccept <= 4.5e-12: tmp = t_5 elif EAccept <= 1.4e+112: tmp = t_2 + (NaChar / (t_0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))) elif (EAccept <= 9e+221) or (not (EAccept <= 7e+243) and (EAccept <= 1.05e+273)): tmp = t_5 else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(EAccept / KbT) + 2.0) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_3 = Float64(t_2 + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(t_0 + Float64(Float64(Vef - mu) / KbT))))) t_4 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_5 = Float64(t_4 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))))) tmp = 0.0 if (EAccept <= -7e-223) tmp = t_1; elseif (EAccept <= 1.95e-225) tmp = t_3; elseif (EAccept <= 5e-193) tmp = Float64(t_4 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (EAccept <= 3.8e-74) tmp = t_3; elseif (EAccept <= 4.5e-12) tmp = t_5; elseif (EAccept <= 1.4e+112) tmp = Float64(t_2 + Float64(NaChar / Float64(t_0 + Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT)))))); elseif ((EAccept <= 9e+221) || (!(EAccept <= 7e+243) && (EAccept <= 1.05e+273))) tmp = t_5; else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (EAccept / KbT) + 2.0; t_1 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_3 = t_2 + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))); t_4 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_5 = t_4 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))); tmp = 0.0; if (EAccept <= -7e-223) tmp = t_1; elseif (EAccept <= 1.95e-225) tmp = t_3; elseif (EAccept <= 5e-193) tmp = t_4 + (NdChar / (1.0 + (mu / KbT))); elseif (EAccept <= 3.8e-74) tmp = t_3; elseif (EAccept <= 4.5e-12) tmp = t_5; elseif (EAccept <= 1.4e+112) tmp = t_2 + (NaChar / (t_0 + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))); elseif ((EAccept <= 9e+221) || (~((EAccept <= 7e+243)) && (EAccept <= 1.05e+273))) tmp = t_5; else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(t$95$0 + N[(N[(Vef - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$4 + N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -7e-223], t$95$1, If[LessEqual[EAccept, 1.95e-225], t$95$3, If[LessEqual[EAccept, 5e-193], N[(t$95$4 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.8e-74], t$95$3, If[LessEqual[EAccept, 4.5e-12], t$95$5, If[LessEqual[EAccept, 1.4e+112], N[(t$95$2 + N[(NaChar / N[(t$95$0 + N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EAccept, 9e+221], And[N[Not[LessEqual[EAccept, 7e+243]], $MachinePrecision], LessEqual[EAccept, 1.05e+273]]], t$95$5, t$95$1]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{EAccept}{KbT} + 2\\
t_1 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_3 := t_2 + \frac{NaChar}{\frac{Ev}{KbT} + \left(t_0 + \frac{Vef - mu}{KbT}\right)}\\
t_4 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_5 := t_4 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\
\mathbf{if}\;EAccept \leq -7 \cdot 10^{-223}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 1.95 \cdot 10^{-225}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;EAccept \leq 5 \cdot 10^{-193}:\\
\;\;\;\;t_4 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;EAccept \leq 3.8 \cdot 10^{-74}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;EAccept \leq 4.5 \cdot 10^{-12}:\\
\;\;\;\;t_5\\
\mathbf{elif}\;EAccept \leq 1.4 \cdot 10^{+112}:\\
\;\;\;\;t_2 + \frac{NaChar}{t_0 + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}}\\
\mathbf{elif}\;EAccept \leq 9 \cdot 10^{+221} \lor \neg \left(EAccept \leq 7 \cdot 10^{+243}\right) \land EAccept \leq 1.05 \cdot 10^{+273}:\\
\;\;\;\;t_5\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if EAccept < -7.00000000000000018e-223 or 9.0000000000000004e221 < EAccept < 6.99999999999999976e243 or 1.05000000000000001e273 < EAccept Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 71.2%
Taylor expanded in EAccept around 0 51.2%
Taylor expanded in NdChar around inf 63.7%
if -7.00000000000000018e-223 < EAccept < 1.95e-225 or 5.0000000000000005e-193 < EAccept < 3.7999999999999996e-74Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 68.9%
associate--l+68.9%
associate-+r+68.9%
associate--l+68.9%
+-commutative68.9%
unsub-neg68.9%
+-commutative68.9%
neg-sub068.9%
associate-+l-68.9%
div-sub68.9%
unsub-neg68.9%
mul-1-neg68.9%
+-commutative68.9%
neg-sub068.9%
+-commutative68.9%
mul-1-neg68.9%
unsub-neg68.9%
Simplified68.9%
if 1.95e-225 < EAccept < 5.0000000000000005e-193Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 87.5%
Taylor expanded in mu around inf 66.6%
if 3.7999999999999996e-74 < EAccept < 4.49999999999999981e-12 or 1.4000000000000001e112 < EAccept < 9.0000000000000004e221 or 6.99999999999999976e243 < EAccept < 1.05000000000000001e273Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 78.4%
if 4.49999999999999981e-12 < EAccept < 1.4000000000000001e112Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 86.9%
Taylor expanded in EAccept around 0 72.9%
associate-+r+72.9%
+-commutative72.9%
unpow272.9%
unpow272.9%
Simplified72.9%
Final simplification68.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (+ t_0 (/ NdChar (+ 1.0 (/ mu KbT)))))
(t_2 (+ (/ EAccept KbT) 2.0))
(t_3 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_4 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_5 (+ t_4 (/ NaChar (+ (/ Ev KbT) (+ t_2 (/ (- Vef mu) KbT)))))))
(if (<= EAccept -2.1e-223)
t_3
(if (<= EAccept 3.9e-224)
t_5
(if (<= EAccept 2.2e-189)
t_1
(if (<= EAccept 3.6e-74)
t_5
(if (<= EAccept 7.2e-57)
t_1
(if (<= EAccept 5.8e+124)
(+
t_4
(/ NaChar (+ t_2 (* 0.5 (/ (* EAccept EAccept) (* KbT KbT))))))
(if (<= EAccept 9.5e+221)
(+ t_0 (/ NdChar 2.0))
(if (or (<= EAccept 3.5e+254) (not (<= EAccept 7.2e+272)))
t_3
(+
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(* NdChar 0.5))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + (mu / KbT)));
double t_2 = (EAccept / KbT) + 2.0;
double t_3 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_4 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_5 = t_4 + (NaChar / ((Ev / KbT) + (t_2 + ((Vef - mu) / KbT))));
double tmp;
if (EAccept <= -2.1e-223) {
tmp = t_3;
} else if (EAccept <= 3.9e-224) {
tmp = t_5;
} else if (EAccept <= 2.2e-189) {
tmp = t_1;
} else if (EAccept <= 3.6e-74) {
tmp = t_5;
} else if (EAccept <= 7.2e-57) {
tmp = t_1;
} else if (EAccept <= 5.8e+124) {
tmp = t_4 + (NaChar / (t_2 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (EAccept <= 9.5e+221) {
tmp = t_0 + (NdChar / 2.0);
} else if ((EAccept <= 3.5e+254) || !(EAccept <= 7.2e+272)) {
tmp = t_3;
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = t_0 + (ndchar / (1.0d0 + (mu / kbt)))
t_2 = (eaccept / kbt) + 2.0d0
t_3 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_4 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_5 = t_4 + (nachar / ((ev / kbt) + (t_2 + ((vef - mu) / kbt))))
if (eaccept <= (-2.1d-223)) then
tmp = t_3
else if (eaccept <= 3.9d-224) then
tmp = t_5
else if (eaccept <= 2.2d-189) then
tmp = t_1
else if (eaccept <= 3.6d-74) then
tmp = t_5
else if (eaccept <= 7.2d-57) then
tmp = t_1
else if (eaccept <= 5.8d+124) then
tmp = t_4 + (nachar / (t_2 + (0.5d0 * ((eaccept * eaccept) / (kbt * kbt)))))
else if (eaccept <= 9.5d+221) then
tmp = t_0 + (ndchar / 2.0d0)
else if ((eaccept <= 3.5d+254) .or. (.not. (eaccept <= 7.2d+272))) then
tmp = t_3
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
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 / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + (mu / KbT)));
double t_2 = (EAccept / KbT) + 2.0;
double t_3 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_4 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_5 = t_4 + (NaChar / ((Ev / KbT) + (t_2 + ((Vef - mu) / KbT))));
double tmp;
if (EAccept <= -2.1e-223) {
tmp = t_3;
} else if (EAccept <= 3.9e-224) {
tmp = t_5;
} else if (EAccept <= 2.2e-189) {
tmp = t_1;
} else if (EAccept <= 3.6e-74) {
tmp = t_5;
} else if (EAccept <= 7.2e-57) {
tmp = t_1;
} else if (EAccept <= 5.8e+124) {
tmp = t_4 + (NaChar / (t_2 + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (EAccept <= 9.5e+221) {
tmp = t_0 + (NdChar / 2.0);
} else if ((EAccept <= 3.5e+254) || !(EAccept <= 7.2e+272)) {
tmp = t_3;
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = t_0 + (NdChar / (1.0 + (mu / KbT))) t_2 = (EAccept / KbT) + 2.0 t_3 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_4 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_5 = t_4 + (NaChar / ((Ev / KbT) + (t_2 + ((Vef - mu) / KbT)))) tmp = 0 if EAccept <= -2.1e-223: tmp = t_3 elif EAccept <= 3.9e-224: tmp = t_5 elif EAccept <= 2.2e-189: tmp = t_1 elif EAccept <= 3.6e-74: tmp = t_5 elif EAccept <= 7.2e-57: tmp = t_1 elif EAccept <= 5.8e+124: tmp = t_4 + (NaChar / (t_2 + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))) elif EAccept <= 9.5e+221: tmp = t_0 + (NdChar / 2.0) elif (EAccept <= 3.5e+254) or not (EAccept <= 7.2e+272): tmp = t_3 else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))) t_2 = Float64(Float64(EAccept / KbT) + 2.0) t_3 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_4 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_5 = Float64(t_4 + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(t_2 + Float64(Float64(Vef - mu) / KbT))))) tmp = 0.0 if (EAccept <= -2.1e-223) tmp = t_3; elseif (EAccept <= 3.9e-224) tmp = t_5; elseif (EAccept <= 2.2e-189) tmp = t_1; elseif (EAccept <= 3.6e-74) tmp = t_5; elseif (EAccept <= 7.2e-57) tmp = t_1; elseif (EAccept <= 5.8e+124) tmp = Float64(t_4 + Float64(NaChar / Float64(t_2 + Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT)))))); elseif (EAccept <= 9.5e+221) tmp = Float64(t_0 + Float64(NdChar / 2.0)); elseif ((EAccept <= 3.5e+254) || !(EAccept <= 7.2e+272)) tmp = t_3; else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = t_0 + (NdChar / (1.0 + (mu / KbT))); t_2 = (EAccept / KbT) + 2.0; t_3 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_4 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_5 = t_4 + (NaChar / ((Ev / KbT) + (t_2 + ((Vef - mu) / KbT)))); tmp = 0.0; if (EAccept <= -2.1e-223) tmp = t_3; elseif (EAccept <= 3.9e-224) tmp = t_5; elseif (EAccept <= 2.2e-189) tmp = t_1; elseif (EAccept <= 3.6e-74) tmp = t_5; elseif (EAccept <= 7.2e-57) tmp = t_1; elseif (EAccept <= 5.8e+124) tmp = t_4 + (NaChar / (t_2 + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))); elseif (EAccept <= 9.5e+221) tmp = t_0 + (NdChar / 2.0); elseif ((EAccept <= 3.5e+254) || ~((EAccept <= 7.2e+272))) tmp = t_3; else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]}, Block[{t$95$3 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$4 + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(t$95$2 + N[(N[(Vef - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -2.1e-223], t$95$3, If[LessEqual[EAccept, 3.9e-224], t$95$5, If[LessEqual[EAccept, 2.2e-189], t$95$1, If[LessEqual[EAccept, 3.6e-74], t$95$5, If[LessEqual[EAccept, 7.2e-57], t$95$1, If[LessEqual[EAccept, 5.8e+124], N[(t$95$4 + N[(NaChar / N[(t$95$2 + N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 9.5e+221], N[(t$95$0 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EAccept, 3.5e+254], N[Not[LessEqual[EAccept, 7.2e+272]], $MachinePrecision]], t$95$3, N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := t_0 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
t_2 := \frac{EAccept}{KbT} + 2\\
t_3 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_4 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_5 := t_4 + \frac{NaChar}{\frac{Ev}{KbT} + \left(t_2 + \frac{Vef - mu}{KbT}\right)}\\
\mathbf{if}\;EAccept \leq -2.1 \cdot 10^{-223}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;EAccept \leq 3.9 \cdot 10^{-224}:\\
\;\;\;\;t_5\\
\mathbf{elif}\;EAccept \leq 2.2 \cdot 10^{-189}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 3.6 \cdot 10^{-74}:\\
\;\;\;\;t_5\\
\mathbf{elif}\;EAccept \leq 7.2 \cdot 10^{-57}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 5.8 \cdot 10^{+124}:\\
\;\;\;\;t_4 + \frac{NaChar}{t_2 + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}}\\
\mathbf{elif}\;EAccept \leq 9.5 \cdot 10^{+221}:\\
\;\;\;\;t_0 + \frac{NdChar}{2}\\
\mathbf{elif}\;EAccept \leq 3.5 \cdot 10^{+254} \lor \neg \left(EAccept \leq 7.2 \cdot 10^{+272}\right):\\
\;\;\;\;t_3\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if EAccept < -2.09999999999999982e-223 or 9.50000000000000044e221 < EAccept < 3.50000000000000017e254 or 7.1999999999999995e272 < EAccept Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in EAccept around inf 72.6%
Taylor expanded in EAccept around 0 52.8%
Taylor expanded in NdChar around inf 64.7%
if -2.09999999999999982e-223 < EAccept < 3.8999999999999998e-224 or 2.20000000000000019e-189 < EAccept < 3.6000000000000002e-74Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 69.7%
associate--l+69.7%
associate-+r+69.7%
associate--l+69.7%
+-commutative69.7%
unsub-neg69.7%
+-commutative69.7%
neg-sub069.7%
associate-+l-69.7%
div-sub69.7%
unsub-neg69.7%
mul-1-neg69.7%
+-commutative69.7%
neg-sub069.7%
+-commutative69.7%
mul-1-neg69.7%
unsub-neg69.7%
Simplified69.7%
if 3.8999999999999998e-224 < EAccept < 2.20000000000000019e-189 or 3.6000000000000002e-74 < EAccept < 7.2000000000000005e-57Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 84.6%
Taylor expanded in mu around inf 64.9%
if 7.2000000000000005e-57 < EAccept < 5.80000000000000043e124Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 83.8%
Taylor expanded in EAccept around 0 68.4%
associate-+r+68.4%
+-commutative68.4%
unpow268.4%
unpow268.4%
Simplified68.4%
if 5.80000000000000043e124 < EAccept < 9.50000000000000044e221Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 72.0%
if 3.50000000000000017e254 < EAccept < 7.1999999999999995e272Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 86.1%
Taylor expanded in KbT around inf 86.4%
Final simplification67.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_2 (+ t_1 (/ NdChar (+ 1.0 (/ mu KbT))))))
(if (<= NaChar -0.00092)
t_2
(if (<= NaChar -8e-57)
t_0
(if (<= NaChar -8.6e-78)
(+ t_1 (/ NdChar (+ 1.0 (/ EDonor KbT))))
(if (<= NaChar -2.2e-111)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ (/ EAccept KbT) 2.0)))
(if (<= NaChar 2.6e+23) t_0 t_2)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / (1.0 + (mu / KbT)));
double tmp;
if (NaChar <= -0.00092) {
tmp = t_2;
} else if (NaChar <= -8e-57) {
tmp = t_0;
} else if (NaChar <= -8.6e-78) {
tmp = t_1 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (NaChar <= -2.2e-111) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else if (NaChar <= 2.6e+23) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_2 = t_1 + (ndchar / (1.0d0 + (mu / kbt)))
if (nachar <= (-0.00092d0)) then
tmp = t_2
else if (nachar <= (-8d-57)) then
tmp = t_0
else if (nachar <= (-8.6d-78)) then
tmp = t_1 + (ndchar / (1.0d0 + (edonor / kbt)))
else if (nachar <= (-2.2d-111)) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
else if (nachar <= 2.6d+23) then
tmp = t_0
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / (1.0 + (mu / KbT)));
double tmp;
if (NaChar <= -0.00092) {
tmp = t_2;
} else if (NaChar <= -8e-57) {
tmp = t_0;
} else if (NaChar <= -8.6e-78) {
tmp = t_1 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (NaChar <= -2.2e-111) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else if (NaChar <= 2.6e+23) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_2 = t_1 + (NdChar / (1.0 + (mu / KbT))) tmp = 0 if NaChar <= -0.00092: tmp = t_2 elif NaChar <= -8e-57: tmp = t_0 elif NaChar <= -8.6e-78: tmp = t_1 + (NdChar / (1.0 + (EDonor / KbT))) elif NaChar <= -2.2e-111: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) elif NaChar <= 2.6e+23: tmp = t_0 else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_2 = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))) tmp = 0.0 if (NaChar <= -0.00092) tmp = t_2; elseif (NaChar <= -8e-57) tmp = t_0; elseif (NaChar <= -8.6e-78) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT)))); elseif (NaChar <= -2.2e-111) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))); elseif (NaChar <= 2.6e+23) tmp = t_0; else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_2 = t_1 + (NdChar / (1.0 + (mu / KbT))); tmp = 0.0; if (NaChar <= -0.00092) tmp = t_2; elseif (NaChar <= -8e-57) tmp = t_0; elseif (NaChar <= -8.6e-78) tmp = t_1 + (NdChar / (1.0 + (EDonor / KbT))); elseif (NaChar <= -2.2e-111) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)); elseif (NaChar <= 2.6e+23) tmp = t_0; else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -0.00092], t$95$2, If[LessEqual[NaChar, -8e-57], t$95$0, If[LessEqual[NaChar, -8.6e-78], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -2.2e-111], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.6e+23], t$95$0, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_2 := t_1 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{if}\;NaChar \leq -0.00092:\\
\;\;\;\;t_2\\
\mathbf{elif}\;NaChar \leq -8 \cdot 10^{-57}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq -8.6 \cdot 10^{-78}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\
\mathbf{elif}\;NaChar \leq -2.2 \cdot 10^{-111}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{elif}\;NaChar \leq 2.6 \cdot 10^{+23}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if NaChar < -9.2000000000000003e-4 or 2.59999999999999992e23 < NaChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 65.7%
Taylor expanded in mu around inf 66.3%
if -9.2000000000000003e-4 < NaChar < -7.99999999999999964e-57 or -2.2e-111 < NaChar < 2.59999999999999992e23Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 77.0%
Taylor expanded in EAccept around 0 66.8%
Taylor expanded in NdChar around inf 74.7%
if -7.99999999999999964e-57 < NaChar < -8.59999999999999987e-78Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.6%
Taylor expanded in EDonor around inf 100.0%
if -8.59999999999999987e-78 < NaChar < -2.2e-111Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 66.2%
Taylor expanded in EAccept around 0 63.2%
Final simplification70.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -470.0)
(not
(or (<= NaChar 8.5e+23)
(and (not (<= NaChar 2.9e+92)) (<= NaChar 2.45e+173)))))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar 2.0))
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -470.0) || !((NaChar <= 8.5e+23) || (!(NaChar <= 2.9e+92) && (NaChar <= 2.45e+173)))) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
} else {
tmp = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
}
return tmp;
}
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 ((nachar <= (-470.0d0)) .or. (.not. (nachar <= 8.5d+23) .or. (.not. (nachar <= 2.9d+92)) .and. (nachar <= 2.45d+173))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / 2.0d0)
else
tmp = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
end if
code = tmp
end function
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 ((NaChar <= -470.0) || !((NaChar <= 8.5e+23) || (!(NaChar <= 2.9e+92) && (NaChar <= 2.45e+173)))) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
} else {
tmp = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -470.0) or not ((NaChar <= 8.5e+23) or (not (NaChar <= 2.9e+92) and (NaChar <= 2.45e+173))): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0) else: tmp = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -470.0) || !((NaChar <= 8.5e+23) || (!(NaChar <= 2.9e+92) && (NaChar <= 2.45e+173)))) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / 2.0)); else tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -470.0) || ~(((NaChar <= 8.5e+23) || (~((NaChar <= 2.9e+92)) && (NaChar <= 2.45e+173))))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0); else tmp = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -470.0], N[Not[Or[LessEqual[NaChar, 8.5e+23], And[N[Not[LessEqual[NaChar, 2.9e+92]], $MachinePrecision], LessEqual[NaChar, 2.45e+173]]]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -470 \lor \neg \left(NaChar \leq 8.5 \cdot 10^{+23} \lor \neg \left(NaChar \leq 2.9 \cdot 10^{+92}\right) \land NaChar \leq 2.45 \cdot 10^{+173}\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
\end{array}
\end{array}
if NaChar < -470 or 8.5000000000000001e23 < NaChar < 2.9000000000000001e92 or 2.45e173 < NaChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 63.7%
if -470 < NaChar < 8.5000000000000001e23 or 2.9000000000000001e92 < NaChar < 2.45e173Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 74.5%
Taylor expanded in EAccept around 0 62.3%
Taylor expanded in NdChar around inf 70.9%
Final simplification68.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_2 (+ t_1 (/ NdChar 2.0))))
(if (<= NaChar -620.0)
t_2
(if (<= NaChar 1.1e+24)
t_0
(if (<= NaChar 3.85e+93)
(+ t_1 (/ (* NdChar KbT) mu))
(if (<= NaChar 1.75e+173) t_0 t_2))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / 2.0);
double tmp;
if (NaChar <= -620.0) {
tmp = t_2;
} else if (NaChar <= 1.1e+24) {
tmp = t_0;
} else if (NaChar <= 3.85e+93) {
tmp = t_1 + ((NdChar * KbT) / mu);
} else if (NaChar <= 1.75e+173) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_2 = t_1 + (ndchar / 2.0d0)
if (nachar <= (-620.0d0)) then
tmp = t_2
else if (nachar <= 1.1d+24) then
tmp = t_0
else if (nachar <= 3.85d+93) then
tmp = t_1 + ((ndchar * kbt) / mu)
else if (nachar <= 1.75d+173) then
tmp = t_0
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / 2.0);
double tmp;
if (NaChar <= -620.0) {
tmp = t_2;
} else if (NaChar <= 1.1e+24) {
tmp = t_0;
} else if (NaChar <= 3.85e+93) {
tmp = t_1 + ((NdChar * KbT) / mu);
} else if (NaChar <= 1.75e+173) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_2 = t_1 + (NdChar / 2.0) tmp = 0 if NaChar <= -620.0: tmp = t_2 elif NaChar <= 1.1e+24: tmp = t_0 elif NaChar <= 3.85e+93: tmp = t_1 + ((NdChar * KbT) / mu) elif NaChar <= 1.75e+173: tmp = t_0 else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_2 = Float64(t_1 + Float64(NdChar / 2.0)) tmp = 0.0 if (NaChar <= -620.0) tmp = t_2; elseif (NaChar <= 1.1e+24) tmp = t_0; elseif (NaChar <= 3.85e+93) tmp = Float64(t_1 + Float64(Float64(NdChar * KbT) / mu)); elseif (NaChar <= 1.75e+173) tmp = t_0; else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_2 = t_1 + (NdChar / 2.0); tmp = 0.0; if (NaChar <= -620.0) tmp = t_2; elseif (NaChar <= 1.1e+24) tmp = t_0; elseif (NaChar <= 3.85e+93) tmp = t_1 + ((NdChar * KbT) / mu); elseif (NaChar <= 1.75e+173) tmp = t_0; else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -620.0], t$95$2, If[LessEqual[NaChar, 1.1e+24], t$95$0, If[LessEqual[NaChar, 3.85e+93], N[(t$95$1 + N[(N[(NdChar * KbT), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.75e+173], t$95$0, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_2 := t_1 + \frac{NdChar}{2}\\
\mathbf{if}\;NaChar \leq -620:\\
\;\;\;\;t_2\\
\mathbf{elif}\;NaChar \leq 1.1 \cdot 10^{+24}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq 3.85 \cdot 10^{+93}:\\
\;\;\;\;t_1 + \frac{NdChar \cdot KbT}{mu}\\
\mathbf{elif}\;NaChar \leq 1.75 \cdot 10^{+173}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if NaChar < -620 or 1.75e173 < NaChar Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in KbT around inf 64.4%
if -620 < NaChar < 1.10000000000000001e24 or 3.85000000000000002e93 < NaChar < 1.75e173Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 74.4%
Taylor expanded in EAccept around 0 62.7%
Taylor expanded in NdChar around inf 71.4%
if 1.10000000000000001e24 < NaChar < 3.85000000000000002e93Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 73.9%
Taylor expanded in mu around inf 67.4%
Final simplification68.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= NaChar -1.65e-75)
(+ t_1 (/ NdChar (+ 1.0 (/ EDonor KbT))))
(if (<= NaChar 9.5e+23)
t_0
(if (<= NaChar 4.6e+93)
(+ t_1 (/ (* NdChar KbT) mu))
(if (<= NaChar 4.2e+173) t_0 (+ t_1 (/ NdChar 2.0))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -1.65e-75) {
tmp = t_1 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (NaChar <= 9.5e+23) {
tmp = t_0;
} else if (NaChar <= 4.6e+93) {
tmp = t_1 + ((NdChar * KbT) / mu);
} else if (NaChar <= 4.2e+173) {
tmp = t_0;
} else {
tmp = t_1 + (NdChar / 2.0);
}
return tmp;
}
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 = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-1.65d-75)) then
tmp = t_1 + (ndchar / (1.0d0 + (edonor / kbt)))
else if (nachar <= 9.5d+23) then
tmp = t_0
else if (nachar <= 4.6d+93) then
tmp = t_1 + ((ndchar * kbt) / mu)
else if (nachar <= 4.2d+173) then
tmp = t_0
else
tmp = t_1 + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -1.65e-75) {
tmp = t_1 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (NaChar <= 9.5e+23) {
tmp = t_0;
} else if (NaChar <= 4.6e+93) {
tmp = t_1 + ((NdChar * KbT) / mu);
} else if (NaChar <= 4.2e+173) {
tmp = t_0;
} else {
tmp = t_1 + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if NaChar <= -1.65e-75: tmp = t_1 + (NdChar / (1.0 + (EDonor / KbT))) elif NaChar <= 9.5e+23: tmp = t_0 elif NaChar <= 4.6e+93: tmp = t_1 + ((NdChar * KbT) / mu) elif NaChar <= 4.2e+173: tmp = t_0 else: tmp = t_1 + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (NaChar <= -1.65e-75) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT)))); elseif (NaChar <= 9.5e+23) tmp = t_0; elseif (NaChar <= 4.6e+93) tmp = Float64(t_1 + Float64(Float64(NdChar * KbT) / mu)); elseif (NaChar <= 4.2e+173) tmp = t_0; else tmp = Float64(t_1 + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -1.65e-75) tmp = t_1 + (NdChar / (1.0 + (EDonor / KbT))); elseif (NaChar <= 9.5e+23) tmp = t_0; elseif (NaChar <= 4.6e+93) tmp = t_1 + ((NdChar * KbT) / mu); elseif (NaChar <= 4.2e+173) tmp = t_0; else tmp = t_1 + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.65e-75], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 9.5e+23], t$95$0, If[LessEqual[NaChar, 4.6e+93], N[(t$95$1 + N[(N[(NdChar * KbT), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 4.2e+173], t$95$0, N[(t$95$1 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -1.65 \cdot 10^{-75}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\
\mathbf{elif}\;NaChar \leq 9.5 \cdot 10^{+23}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq 4.6 \cdot 10^{+93}:\\
\;\;\;\;t_1 + \frac{NdChar \cdot KbT}{mu}\\
\mathbf{elif}\;NaChar \leq 4.2 \cdot 10^{+173}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_1 + \frac{NdChar}{2}\\
\end{array}
\end{array}
if NaChar < -1.65e-75Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in KbT around inf 59.9%
Taylor expanded in EDonor around inf 58.5%
if -1.65e-75 < NaChar < 9.50000000000000038e23 or 4.6000000000000003e93 < NaChar < 4.2e173Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 75.7%
Taylor expanded in EAccept around 0 64.2%
Taylor expanded in NdChar around inf 73.3%
if 9.50000000000000038e23 < NaChar < 4.6000000000000003e93Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 73.9%
Taylor expanded in mu around inf 67.4%
if 4.2e173 < NaChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 77.0%
Final simplification68.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= KbT -3.65e+28) (not (<= KbT 1.35e+170)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar 2.0))
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((KbT <= -3.65e+28) || !(KbT <= 1.35e+170)) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
} else {
tmp = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
}
return tmp;
}
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 <= (-3.65d+28)) .or. (.not. (kbt <= 1.35d+170))) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / 2.0d0)
else
tmp = ndchar / (1.0d0 + exp((((vef + (mu + edonor)) - ec) / kbt)))
end if
code = tmp
end function
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 <= -3.65e+28) || !(KbT <= 1.35e+170)) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
} else {
tmp = NdChar / (1.0 + Math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (KbT <= -3.65e+28) or not (KbT <= 1.35e+170): tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0) else: tmp = NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((KbT <= -3.65e+28) || !(KbT <= 1.35e+170)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / 2.0)); else tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((KbT <= -3.65e+28) || ~((KbT <= 1.35e+170))) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0); else tmp = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -3.65e+28], N[Not[LessEqual[KbT, 1.35e+170]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -3.65 \cdot 10^{+28} \lor \neg \left(KbT \leq 1.35 \cdot 10^{+170}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}\\
\end{array}
\end{array}
if KbT < -3.6499999999999999e28 or 1.3500000000000001e170 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 71.7%
if -3.6499999999999999e28 < KbT < 1.3500000000000001e170Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 67.3%
Taylor expanded in EAccept around 0 45.0%
Taylor expanded in NdChar around inf 62.5%
Final simplification65.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ (- Vef mu) KbT))
(t_1 (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5)))
(t_2 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(t_3 (- (+ (/ EAccept KbT) 2.0) t_0)))
(if (<= NaChar -330.0)
t_1
(if (<= NaChar 3.2e-167)
t_2
(if (<= NaChar 2.5e-41)
(+
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT))))
(/
NaChar
(+ (/ Ev KbT) (/ (* (+ 2.0 (+ (/ EAccept KbT) t_0)) t_3) t_3))))
(if (<= NaChar 5.8e+23) t_2 t_1))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (Vef - mu) / KbT;
double t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
double t_2 = NdChar / (1.0 + exp((mu / KbT)));
double t_3 = ((EAccept / KbT) + 2.0) - t_0;
double tmp;
if (NaChar <= -330.0) {
tmp = t_1;
} else if (NaChar <= 3.2e-167) {
tmp = t_2;
} else if (NaChar <= 2.5e-41) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (((2.0 + ((EAccept / KbT) + t_0)) * t_3) / t_3)));
} else if (NaChar <= 5.8e+23) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
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 = (vef - mu) / kbt
t_1 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
t_2 = ndchar / (1.0d0 + exp((mu / kbt)))
t_3 = ((eaccept / kbt) + 2.0d0) - t_0
if (nachar <= (-330.0d0)) then
tmp = t_1
else if (nachar <= 3.2d-167) then
tmp = t_2
else if (nachar <= 2.5d-41) then
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))) + (nachar / ((ev / kbt) + (((2.0d0 + ((eaccept / kbt) + t_0)) * t_3) / t_3)))
else if (nachar <= 5.8d+23) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
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 = (Vef - mu) / KbT;
double t_1 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
double t_2 = NdChar / (1.0 + Math.exp((mu / KbT)));
double t_3 = ((EAccept / KbT) + 2.0) - t_0;
double tmp;
if (NaChar <= -330.0) {
tmp = t_1;
} else if (NaChar <= 3.2e-167) {
tmp = t_2;
} else if (NaChar <= 2.5e-41) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (((2.0 + ((EAccept / KbT) + t_0)) * t_3) / t_3)));
} else if (NaChar <= 5.8e+23) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (Vef - mu) / KbT t_1 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) t_2 = NdChar / (1.0 + math.exp((mu / KbT))) t_3 = ((EAccept / KbT) + 2.0) - t_0 tmp = 0 if NaChar <= -330.0: tmp = t_1 elif NaChar <= 3.2e-167: tmp = t_2 elif NaChar <= 2.5e-41: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (((2.0 + ((EAccept / KbT) + t_0)) * t_3) / t_3))) elif NaChar <= 5.8e+23: tmp = t_2 else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(Vef - mu) / KbT) t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)) t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) t_3 = Float64(Float64(Float64(EAccept / KbT) + 2.0) - t_0) tmp = 0.0 if (NaChar <= -330.0) tmp = t_1; elseif (NaChar <= 3.2e-167) tmp = t_2; elseif (NaChar <= 2.5e-41) tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + t_0)) * t_3) / t_3)))); elseif (NaChar <= 5.8e+23) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (Vef - mu) / KbT; t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); t_2 = NdChar / (1.0 + exp((mu / KbT))); t_3 = ((EAccept / KbT) + 2.0) - t_0; tmp = 0.0; if (NaChar <= -330.0) tmp = t_1; elseif (NaChar <= 3.2e-167) tmp = t_2; elseif (NaChar <= 2.5e-41) tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (((2.0 + ((EAccept / KbT) + t_0)) * t_3) / t_3))); elseif (NaChar <= 5.8e+23) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(Vef - mu), $MachinePrecision] / KbT), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision] - t$95$0), $MachinePrecision]}, If[LessEqual[NaChar, -330.0], t$95$1, If[LessEqual[NaChar, 3.2e-167], t$95$2, If[LessEqual[NaChar, 2.5e-41], N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision] * t$95$3), $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 5.8e+23], t$95$2, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{Vef - mu}{KbT}\\
t_1 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
t_3 := \left(\frac{EAccept}{KbT} + 2\right) - t_0\\
\mathbf{if}\;NaChar \leq -330:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NaChar \leq 3.2 \cdot 10^{-167}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;NaChar \leq 2.5 \cdot 10^{-41}:\\
\;\;\;\;\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\frac{Ev}{KbT} + \frac{\left(2 + \left(\frac{EAccept}{KbT} + t_0\right)\right) \cdot t_3}{t_3}}\\
\mathbf{elif}\;NaChar \leq 5.8 \cdot 10^{+23}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if NaChar < -330 or 5.80000000000000025e23 < NaChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 69.1%
Taylor expanded in KbT around inf 45.0%
if -330 < NaChar < 3.2000000000000002e-167 or 2.4999999999999998e-41 < NaChar < 5.80000000000000025e23Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 56.6%
Taylor expanded in mu around inf 40.3%
Taylor expanded in NdChar around inf 46.7%
if 3.2000000000000002e-167 < NaChar < 2.4999999999999998e-41Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 67.1%
associate--l+67.1%
associate-+r+67.1%
associate--l+67.1%
+-commutative67.1%
unsub-neg67.1%
+-commutative67.1%
neg-sub067.1%
associate-+l-67.1%
div-sub67.1%
unsub-neg67.1%
mul-1-neg67.1%
+-commutative67.1%
neg-sub067.1%
+-commutative67.1%
mul-1-neg67.1%
unsub-neg67.1%
Simplified67.1%
flip-+65.9%
distribute-neg-frac65.9%
distribute-neg-frac65.9%
distribute-neg-frac65.9%
Applied egg-rr65.9%
difference-of-squares65.9%
distribute-frac-neg65.9%
sub-neg65.9%
sub-neg65.9%
distribute-frac-neg65.9%
remove-double-neg65.9%
associate--l+65.9%
sub-neg65.9%
distribute-frac-neg65.9%
remove-double-neg65.9%
Simplified65.9%
Taylor expanded in KbT around inf 54.9%
Final simplification46.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NaChar -5.3)
(+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (* NdChar 0.5))
(if (<= NaChar -7.2e-308)
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(if (<= NaChar 0.0075)
(+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -5.3) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5);
} else if (NaChar <= -7.2e-308) {
tmp = NdChar / (1.0 + exp((mu / KbT)));
} else if (NaChar <= 0.0075) {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT))));
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
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 (nachar <= (-5.3d0)) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar * 0.5d0)
else if (nachar <= (-7.2d-308)) then
tmp = ndchar / (1.0d0 + exp((mu / kbt)))
else if (nachar <= 0.0075d0) then
tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + exp((-ec / kbt))))
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
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 (NaChar <= -5.3) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar * 0.5);
} else if (NaChar <= -7.2e-308) {
tmp = NdChar / (1.0 + Math.exp((mu / KbT)));
} else if (NaChar <= 0.0075) {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NaChar <= -5.3: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar * 0.5) elif NaChar <= -7.2e-308: tmp = NdChar / (1.0 + math.exp((mu / KbT))) elif NaChar <= 0.0075: tmp = (NaChar / 2.0) + (NdChar / (1.0 + math.exp((-Ec / KbT)))) else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NaChar <= -5.3) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar * 0.5)); elseif (NaChar <= -7.2e-308) tmp = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))); elseif (NaChar <= 0.0075) tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NaChar <= -5.3) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5); elseif (NaChar <= -7.2e-308) tmp = NdChar / (1.0 + exp((mu / KbT))); elseif (NaChar <= 0.0075) tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT)))); else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -5.3], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -7.2e-308], N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 0.0075], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -5.3:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{elif}\;NaChar \leq -7.2 \cdot 10^{-308}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{elif}\;NaChar \leq 0.0075:\\
\;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NaChar < -5.29999999999999982Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in mu around inf 71.0%
neg-mul-171.0%
distribute-neg-frac71.0%
Simplified71.0%
Taylor expanded in KbT around inf 43.7%
if -5.29999999999999982 < NaChar < -7.1999999999999997e-308Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 45.8%
Taylor expanded in mu around inf 32.4%
Taylor expanded in NdChar around inf 46.1%
if -7.1999999999999997e-308 < NaChar < 0.0074999999999999997Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 63.7%
Taylor expanded in Ec around inf 49.4%
mul-1-neg49.4%
Simplified49.4%
if 0.0074999999999999997 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 69.7%
Taylor expanded in KbT around inf 47.6%
Final simplification46.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (or (<= NdChar -4e+30) (not (<= NdChar 1.12e+25))) (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0)) (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (* NdChar 0.5))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -4e+30) || !(NdChar <= 1.12e+25)) {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
} else {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
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 <= (-4d+30)) .or. (.not. (ndchar <= 1.12d+25))) then
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / 2.0d0)
else
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
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 <= -4e+30) || !(NdChar <= 1.12e+25)) {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 2.0);
} else {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -4e+30) or not (NdChar <= 1.12e+25): tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 2.0) else: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -4e+30) || !(NdChar <= 1.12e+25)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / 2.0)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -4e+30) || ~((NdChar <= 1.12e+25))) tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0); else tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -4e+30], N[Not[LessEqual[NdChar, 1.12e+25]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -4 \cdot 10^{+30} \lor \neg \left(NdChar \leq 1.12 \cdot 10^{+25}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NdChar < -4.0000000000000001e30 or 1.1200000000000001e25 < NdChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 61.2%
Taylor expanded in mu around inf 43.9%
if -4.0000000000000001e30 < NdChar < 1.1200000000000001e25Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in mu around inf 68.1%
neg-mul-168.1%
distribute-neg-frac68.1%
Simplified68.1%
Taylor expanded in KbT around inf 43.7%
Final simplification43.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (or (<= NdChar -0.0005) (not (<= NdChar 4.2e+117))) (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0)) (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -0.0005) || !(NdChar <= 4.2e+117)) {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
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 <= (-0.0005d0)) .or. (.not. (ndchar <= 4.2d+117))) then
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / 2.0d0)
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
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 <= -0.0005) || !(NdChar <= 4.2e+117)) {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 2.0);
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -0.0005) or not (NdChar <= 4.2e+117): tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 2.0) else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -0.0005) || !(NdChar <= 4.2e+117)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / 2.0)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -0.0005) || ~((NdChar <= 4.2e+117))) tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0); else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -0.0005], N[Not[LessEqual[NdChar, 4.2e+117]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -0.0005 \lor \neg \left(NdChar \leq 4.2 \cdot 10^{+117}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NdChar < -5.0000000000000001e-4 or 4.2000000000000002e117 < NdChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 64.0%
Taylor expanded in mu around inf 46.8%
if -5.0000000000000001e-4 < NdChar < 4.2000000000000002e117Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 67.1%
Taylor expanded in KbT around inf 41.2%
Final simplification43.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ mu EDonor)) Ec) KbT)))))
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((((Vef + (mu + EDonor)) - Ec) / KbT)));
}
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((((vef + (mu + edonor)) - ec) / kbt)))
end function
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((((Vef + (mu + EDonor)) - Ec) / KbT)));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return NdChar / (1.0 + math.exp((((Vef + (mu + EDonor)) - Ec) / KbT)))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(mu + EDonor)) - Ec) / KbT)))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = NdChar / (1.0 + exp((((Vef + (mu + EDonor)) - Ec) / KbT))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(mu + EDonor\right)\right) - Ec}{KbT}}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 72.2%
Taylor expanded in EAccept around 0 54.9%
Taylor expanded in NdChar around inf 58.1%
Final simplification58.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (+ (/ EAccept KbT) 2.0)))
(if (<= KbT -7500000000000.0)
(+
(/
NdChar
(+
1.0
(- (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ Ec KbT))))
(/ NaChar (+ (/ Ev KbT) (+ t_0 (/ (- Vef mu) KbT)))))
(if (<= KbT 1.4e+155)
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(+ (/ NdChar 2.0) (/ NaChar t_0))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (EAccept / KbT) + 2.0;
double tmp;
if (KbT <= -7500000000000.0) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT))));
} else if (KbT <= 1.4e+155) {
tmp = NdChar / (1.0 + exp((mu / KbT)));
} else {
tmp = (NdChar / 2.0) + (NaChar / t_0);
}
return tmp;
}
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 = (eaccept / kbt) + 2.0d0
if (kbt <= (-7500000000000.0d0)) then
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))) + (nachar / ((ev / kbt) + (t_0 + ((vef - mu) / kbt))))
else if (kbt <= 1.4d+155) then
tmp = ndchar / (1.0d0 + exp((mu / kbt)))
else
tmp = (ndchar / 2.0d0) + (nachar / t_0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (EAccept / KbT) + 2.0;
double tmp;
if (KbT <= -7500000000000.0) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT))));
} else if (KbT <= 1.4e+155) {
tmp = NdChar / (1.0 + Math.exp((mu / KbT)));
} else {
tmp = (NdChar / 2.0) + (NaChar / t_0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (EAccept / KbT) + 2.0 tmp = 0 if KbT <= -7500000000000.0: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))) elif KbT <= 1.4e+155: tmp = NdChar / (1.0 + math.exp((mu / KbT))) else: tmp = (NdChar / 2.0) + (NaChar / t_0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(EAccept / KbT) + 2.0) tmp = 0.0 if (KbT <= -7500000000000.0) tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(t_0 + Float64(Float64(Vef - mu) / KbT))))); elseif (KbT <= 1.4e+155) tmp = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))); else tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / t_0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (EAccept / KbT) + 2.0; tmp = 0.0; if (KbT <= -7500000000000.0) tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))); elseif (KbT <= 1.4e+155) tmp = NdChar / (1.0 + exp((mu / KbT))); else tmp = (NdChar / 2.0) + (NaChar / t_0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]}, If[LessEqual[KbT, -7500000000000.0], N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(t$95$0 + N[(N[(Vef - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.4e+155], N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{EAccept}{KbT} + 2\\
\mathbf{if}\;KbT \leq -7500000000000:\\
\;\;\;\;\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\frac{Ev}{KbT} + \left(t_0 + \frac{Vef - mu}{KbT}\right)}\\
\mathbf{elif}\;KbT \leq 1.4 \cdot 10^{+155}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{t_0}\\
\end{array}
\end{array}
if KbT < -7.5e12Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 66.9%
associate--l+66.9%
associate-+r+66.9%
associate--l+66.9%
+-commutative66.9%
unsub-neg66.9%
+-commutative66.9%
neg-sub066.9%
associate-+l-66.9%
div-sub66.9%
unsub-neg66.9%
mul-1-neg66.9%
+-commutative66.9%
neg-sub066.9%
+-commutative66.9%
mul-1-neg66.9%
unsub-neg66.9%
Simplified66.9%
Taylor expanded in KbT around inf 48.3%
if -7.5e12 < KbT < 1.40000000000000008e155Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 35.4%
Taylor expanded in mu around inf 26.4%
Taylor expanded in NdChar around inf 33.7%
if 1.40000000000000008e155 < KbT Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in EAccept around inf 85.5%
Taylor expanded in EAccept around 0 74.3%
Taylor expanded in KbT around inf 61.1%
Final simplification41.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(+
(/
NdChar
(+
1.0
(- (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ Ec KbT))))
(/ NaChar (+ (/ Ev KbT) (+ (+ (/ EAccept KbT) 2.0) (/ (- Vef mu) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (((EAccept / KbT) + 2.0) + ((Vef - mu) / KbT))));
}
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 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))) + (nachar / ((ev / kbt) + (((eaccept / kbt) + 2.0d0) + ((vef - mu) / kbt))))
end function
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 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (((EAccept / KbT) + 2.0) + ((Vef - mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (((EAccept / KbT) + 2.0) + ((Vef - mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(Float64(Float64(EAccept / KbT) + 2.0) + Float64(Float64(Vef - mu) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / ((Ev / KbT) + (((EAccept / KbT) + 2.0) + ((Vef - mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision] + N[(N[(Vef - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\frac{Ev}{KbT} + \left(\left(\frac{EAccept}{KbT} + 2\right) + \frac{Vef - mu}{KbT}\right)}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 55.3%
associate--l+55.3%
associate-+r+55.3%
associate--l+55.3%
+-commutative55.3%
unsub-neg55.3%
+-commutative55.3%
neg-sub055.3%
associate-+l-55.3%
div-sub56.1%
unsub-neg56.1%
mul-1-neg56.1%
+-commutative56.1%
neg-sub056.1%
+-commutative56.1%
mul-1-neg56.1%
unsub-neg56.1%
Simplified56.1%
Taylor expanded in KbT around inf 30.6%
Final simplification30.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (+ (/ EAccept KbT) 2.0)) (t_1 (/ NaChar t_0)))
(if (<= KbT -6.8e+82)
(+ (/ NaChar (+ (/ Ev KbT) (+ t_0 (/ (- Vef mu) KbT)))) (* NdChar 0.5))
(if (<= KbT 1.05e-39) t_1 (+ (/ NdChar 2.0) t_1)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (EAccept / KbT) + 2.0;
double t_1 = NaChar / t_0;
double tmp;
if (KbT <= -6.8e+82) {
tmp = (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))) + (NdChar * 0.5);
} else if (KbT <= 1.05e-39) {
tmp = t_1;
} else {
tmp = (NdChar / 2.0) + t_1;
}
return tmp;
}
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 = (eaccept / kbt) + 2.0d0
t_1 = nachar / t_0
if (kbt <= (-6.8d+82)) then
tmp = (nachar / ((ev / kbt) + (t_0 + ((vef - mu) / kbt)))) + (ndchar * 0.5d0)
else if (kbt <= 1.05d-39) then
tmp = t_1
else
tmp = (ndchar / 2.0d0) + t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (EAccept / KbT) + 2.0;
double t_1 = NaChar / t_0;
double tmp;
if (KbT <= -6.8e+82) {
tmp = (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))) + (NdChar * 0.5);
} else if (KbT <= 1.05e-39) {
tmp = t_1;
} else {
tmp = (NdChar / 2.0) + t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (EAccept / KbT) + 2.0 t_1 = NaChar / t_0 tmp = 0 if KbT <= -6.8e+82: tmp = (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))) + (NdChar * 0.5) elif KbT <= 1.05e-39: tmp = t_1 else: tmp = (NdChar / 2.0) + t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(EAccept / KbT) + 2.0) t_1 = Float64(NaChar / t_0) tmp = 0.0 if (KbT <= -6.8e+82) tmp = Float64(Float64(NaChar / Float64(Float64(Ev / KbT) + Float64(t_0 + Float64(Float64(Vef - mu) / KbT)))) + Float64(NdChar * 0.5)); elseif (KbT <= 1.05e-39) tmp = t_1; else tmp = Float64(Float64(NdChar / 2.0) + t_1); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (EAccept / KbT) + 2.0; t_1 = NaChar / t_0; tmp = 0.0; if (KbT <= -6.8e+82) tmp = (NaChar / ((Ev / KbT) + (t_0 + ((Vef - mu) / KbT)))) + (NdChar * 0.5); elseif (KbT <= 1.05e-39) tmp = t_1; else tmp = (NdChar / 2.0) + t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / t$95$0), $MachinePrecision]}, If[LessEqual[KbT, -6.8e+82], N[(N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + N[(t$95$0 + N[(N[(Vef - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.05e-39], t$95$1, N[(N[(NdChar / 2.0), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{EAccept}{KbT} + 2\\
t_1 := \frac{NaChar}{t_0}\\
\mathbf{if}\;KbT \leq -6.8 \cdot 10^{+82}:\\
\;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + \left(t_0 + \frac{Vef - mu}{KbT}\right)} + NdChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 1.05 \cdot 10^{-39}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{2} + t_1\\
\end{array}
\end{array}
if KbT < -6.79999999999999989e82Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 66.2%
associate--l+66.2%
associate-+r+66.2%
associate--l+66.2%
+-commutative66.2%
unsub-neg66.2%
+-commutative66.2%
neg-sub066.2%
associate-+l-66.2%
div-sub66.2%
unsub-neg66.2%
mul-1-neg66.2%
+-commutative66.2%
neg-sub066.2%
+-commutative66.2%
mul-1-neg66.2%
unsub-neg66.2%
Simplified66.2%
Taylor expanded in KbT around inf 50.2%
if -6.79999999999999989e82 < KbT < 1.04999999999999997e-39Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 68.2%
Taylor expanded in EAccept around 0 45.4%
Taylor expanded in NaChar around -inf 19.0%
if 1.04999999999999997e-39 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 76.5%
Taylor expanded in EAccept around 0 63.7%
Taylor expanded in KbT around inf 44.7%
Final simplification32.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ (/ EAccept KbT) 2.0))))
(if (<= KbT -2.8e+83)
(* 0.5 (+ NdChar NaChar))
(if (<= KbT 2e-39) t_0 (+ (/ NdChar 2.0) t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / ((EAccept / KbT) + 2.0);
double tmp;
if (KbT <= -2.8e+83) {
tmp = 0.5 * (NdChar + NaChar);
} else if (KbT <= 2e-39) {
tmp = t_0;
} else {
tmp = (NdChar / 2.0) + t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / ((eaccept / kbt) + 2.0d0)
if (kbt <= (-2.8d+83)) then
tmp = 0.5d0 * (ndchar + nachar)
else if (kbt <= 2d-39) then
tmp = t_0
else
tmp = (ndchar / 2.0d0) + t_0
end if
code = tmp
end function
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 / ((EAccept / KbT) + 2.0);
double tmp;
if (KbT <= -2.8e+83) {
tmp = 0.5 * (NdChar + NaChar);
} else if (KbT <= 2e-39) {
tmp = t_0;
} else {
tmp = (NdChar / 2.0) + t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / ((EAccept / KbT) + 2.0) tmp = 0 if KbT <= -2.8e+83: tmp = 0.5 * (NdChar + NaChar) elif KbT <= 2e-39: tmp = t_0 else: tmp = (NdChar / 2.0) + t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0)) tmp = 0.0 if (KbT <= -2.8e+83) tmp = Float64(0.5 * Float64(NdChar + NaChar)); elseif (KbT <= 2e-39) tmp = t_0; else tmp = Float64(Float64(NdChar / 2.0) + t_0); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / ((EAccept / KbT) + 2.0); tmp = 0.0; if (KbT <= -2.8e+83) tmp = 0.5 * (NdChar + NaChar); elseif (KbT <= 2e-39) tmp = t_0; else tmp = (NdChar / 2.0) + t_0; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.8e+83], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2e-39], t$95$0, N[(N[(NdChar / 2.0), $MachinePrecision] + t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{if}\;KbT \leq -2.8 \cdot 10^{+83}:\\
\;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\
\mathbf{elif}\;KbT \leq 2 \cdot 10^{-39}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{2} + t_0\\
\end{array}
\end{array}
if KbT < -2.8e83Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 66.7%
Taylor expanded in mu around inf 54.3%
Taylor expanded in mu around 0 48.7%
distribute-lft-out48.7%
Simplified48.7%
if -2.8e83 < KbT < 1.99999999999999986e-39Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 68.2%
Taylor expanded in EAccept around 0 45.4%
Taylor expanded in NaChar around -inf 19.0%
if 1.99999999999999986e-39 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 76.5%
Taylor expanded in EAccept around 0 63.7%
Taylor expanded in KbT around inf 44.7%
Final simplification32.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (* 0.5 (+ NdChar NaChar)))
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);
}
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
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);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return 0.5 * (NdChar + NaChar)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(0.5 * Float64(NdChar + NaChar)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.5 * (NdChar + NaChar); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \left(NdChar + NaChar\right)
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 48.7%
Taylor expanded in mu around inf 37.3%
Taylor expanded in mu around 0 28.4%
distribute-lft-out28.4%
Simplified28.4%
Final simplification28.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (* NaChar 0.5))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NaChar * 0.5;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = nachar * 0.5d0
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NaChar * 0.5;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return NaChar * 0.5
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(NaChar * 0.5) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = NaChar * 0.5; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NaChar * 0.5), $MachinePrecision]
\begin{array}{l}
\\
NaChar \cdot 0.5
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 48.7%
Taylor expanded in mu around inf 37.3%
Taylor expanded in NdChar around 0 19.5%
Final simplification19.5%
herbie shell --seed 2023230
(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))))))