
(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 26 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 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))) (* NaChar (/ 1.0 (+ 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 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (1.0 + exp(((Vef + ((Ev + 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(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar * (1.0d0 / (1.0d0 + exp(((vef + ((ev + 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(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (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.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (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(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar * Float64(1.0 / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (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[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * N[(1.0 / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + NaChar \cdot \frac{1}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}}
\end{array}
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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Final simplification100.0%
(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 (exp (/ mu KbT))))))
(t_2 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_3 (+ t_2 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))))
(if (<= Vef -15500000000000.0)
t_3
(if (<= Vef -4.6e-129)
t_1
(if (<= Vef 8.5e-124)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Vef 2.35e+23)
t_1
(if (<= Vef 1.6e+132)
(+ t_2 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
t_3)))))))
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 + exp((mu / KbT))));
double t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_3 = t_2 + (NaChar / (1.0 + exp((Vef / KbT))));
double tmp;
if (Vef <= -15500000000000.0) {
tmp = t_3;
} else if (Vef <= -4.6e-129) {
tmp = t_1;
} else if (Vef <= 8.5e-124) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Vef <= 2.35e+23) {
tmp = t_1;
} else if (Vef <= 1.6e+132) {
tmp = t_2 + (NaChar / (1.0 + exp((-mu / KbT))));
} else {
tmp = t_3;
}
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 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
t_2 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_3 = t_2 + (nachar / (1.0d0 + exp((vef / kbt))))
if (vef <= (-15500000000000.0d0)) then
tmp = t_3
else if (vef <= (-4.6d-129)) then
tmp = t_1
else if (vef <= 8.5d-124) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (vef <= 2.35d+23) then
tmp = t_1
else if (vef <= 1.6d+132) then
tmp = t_2 + (nachar / (1.0d0 + exp((-mu / kbt))))
else
tmp = t_3
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 + Math.exp((mu / KbT))));
double t_2 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_3 = t_2 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
double tmp;
if (Vef <= -15500000000000.0) {
tmp = t_3;
} else if (Vef <= -4.6e-129) {
tmp = t_1;
} else if (Vef <= 8.5e-124) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Vef <= 2.35e+23) {
tmp = t_1;
} else if (Vef <= 1.6e+132) {
tmp = t_2 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
} else {
tmp = t_3;
}
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 + math.exp((mu / KbT)))) t_2 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_3 = t_2 + (NaChar / (1.0 + math.exp((Vef / KbT)))) tmp = 0 if Vef <= -15500000000000.0: tmp = t_3 elif Vef <= -4.6e-129: tmp = t_1 elif Vef <= 8.5e-124: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Vef <= 2.35e+23: tmp = t_1 elif Vef <= 1.6e+132: tmp = t_2 + (NaChar / (1.0 + math.exp((-mu / KbT)))) else: tmp = t_3 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 + exp(Float64(mu / 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(1.0 + exp(Float64(Vef / KbT))))) tmp = 0.0 if (Vef <= -15500000000000.0) tmp = t_3; elseif (Vef <= -4.6e-129) tmp = t_1; elseif (Vef <= 8.5e-124) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Vef <= 2.35e+23) tmp = t_1; elseif (Vef <= 1.6e+132) tmp = Float64(t_2 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))); else tmp = t_3; 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 + exp((mu / KbT)))); t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_3 = t_2 + (NaChar / (1.0 + exp((Vef / KbT)))); tmp = 0.0; if (Vef <= -15500000000000.0) tmp = t_3; elseif (Vef <= -4.6e-129) tmp = t_1; elseif (Vef <= 8.5e-124) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Vef <= 2.35e+23) tmp = t_1; elseif (Vef <= 1.6e+132) tmp = t_2 + (NaChar / (1.0 + exp((-mu / KbT)))); else tmp = t_3; 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[Exp[N[(mu / KbT), $MachinePrecision]], $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[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -15500000000000.0], t$95$3, If[LessEqual[Vef, -4.6e-129], t$95$1, If[LessEqual[Vef, 8.5e-124], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2.35e+23], t$95$1, If[LessEqual[Vef, 1.6e+132], N[(t$95$2 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]]]]
\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 + e^{\frac{mu}{KbT}}}\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_3 := t_2 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;Vef \leq -15500000000000:\\
\;\;\;\;t_3\\
\mathbf{elif}\;Vef \leq -4.6 \cdot 10^{-129}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Vef \leq 8.5 \cdot 10^{-124}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Vef \leq 2.35 \cdot 10^{+23}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Vef \leq 1.6 \cdot 10^{+132}:\\
\;\;\;\;t_2 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if Vef < -1.55e13 or 1.5999999999999999e132 < Vef 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 Vef around inf 89.6%
if -1.55e13 < Vef < -4.5999999999999999e-129 or 8.5000000000000002e-124 < Vef < 2.3499999999999999e23Initial 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 90.8%
if -4.5999999999999999e-129 < Vef < 8.5000000000000002e-124Initial 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 EDonor around inf 79.8%
if 2.3499999999999999e23 < Vef < 1.5999999999999999e132Initial 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 93.6%
associate-*r/57.5%
mul-1-neg57.5%
Simplified93.6%
Final simplification87.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT))))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_2 (+ t_1 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))))
(if (<= Vef -2.75e+14)
t_2
(if (<= Vef -7e-129)
t_0
(if (<= Vef 1.9e-127)
(+
(*
NaChar
(/ 1.0 (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT)))))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Vef 1.45e+23)
t_0
(if (<= Vef 3.1e+130)
(+ t_1 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
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 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
double t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_2 = t_1 + (NaChar / (1.0 + exp((Vef / KbT))));
double tmp;
if (Vef <= -2.75e+14) {
tmp = t_2;
} else if (Vef <= -7e-129) {
tmp = t_0;
} else if (Vef <= 1.9e-127) {
tmp = (NaChar * (1.0 / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT))))) + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Vef <= 1.45e+23) {
tmp = t_0;
} else if (Vef <= 3.1e+130) {
tmp = t_1 + (NaChar / (1.0 + exp((-mu / KbT))));
} 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 = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
t_1 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_2 = t_1 + (nachar / (1.0d0 + exp((vef / kbt))))
if (vef <= (-2.75d+14)) then
tmp = t_2
else if (vef <= (-7d-129)) then
tmp = t_0
else if (vef <= 1.9d-127) then
tmp = (nachar * (1.0d0 / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt))))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (vef <= 1.45d+23) then
tmp = t_0
else if (vef <= 3.1d+130) then
tmp = t_1 + (nachar / (1.0d0 + exp((-mu / kbt))))
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 = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
double t_1 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_2 = t_1 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
double tmp;
if (Vef <= -2.75e+14) {
tmp = t_2;
} else if (Vef <= -7e-129) {
tmp = t_0;
} else if (Vef <= 1.9e-127) {
tmp = (NaChar * (1.0 / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Vef <= 1.45e+23) {
tmp = t_0;
} else if (Vef <= 3.1e+130) {
tmp = t_1 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
} else {
tmp = t_2;
}
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)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) t_1 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_2 = t_1 + (NaChar / (1.0 + math.exp((Vef / KbT)))) tmp = 0 if Vef <= -2.75e+14: tmp = t_2 elif Vef <= -7e-129: tmp = t_0 elif Vef <= 1.9e-127: tmp = (NaChar * (1.0 / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Vef <= 1.45e+23: tmp = t_0 elif Vef <= 3.1e+130: tmp = t_1 + (NaChar / (1.0 + math.exp((-mu / KbT)))) else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - 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)))) t_2 = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))) tmp = 0.0 if (Vef <= -2.75e+14) tmp = t_2; elseif (Vef <= -7e-129) tmp = t_0; elseif (Vef <= 1.9e-127) tmp = Float64(Float64(NaChar * Float64(1.0 / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT))))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Vef <= 1.45e+23) tmp = t_0; elseif (Vef <= 3.1e+130) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))); else tmp = t_2; 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)))) + (NdChar / (1.0 + exp((mu / KbT)))); t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_2 = t_1 + (NaChar / (1.0 + exp((Vef / KbT)))); tmp = 0.0; if (Vef <= -2.75e+14) tmp = t_2; elseif (Vef <= -7e-129) tmp = t_0; elseif (Vef <= 1.9e-127) tmp = (NaChar * (1.0 / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT))))) + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Vef <= 1.45e+23) tmp = t_0; elseif (Vef <= 3.1e+130) tmp = t_1 + (NaChar / (1.0 + exp((-mu / KbT)))); else tmp = t_2; 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[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / 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]}, Block[{t$95$2 = N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -2.75e+14], t$95$2, If[LessEqual[Vef, -7e-129], t$95$0, If[LessEqual[Vef, 1.9e-127], N[(N[(NaChar * N[(1.0 / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.45e+23], t$95$0, If[LessEqual[Vef, 3.1e+130], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - 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}}}\\
t_2 := t_1 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;Vef \leq -2.75 \cdot 10^{+14}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;Vef \leq -7 \cdot 10^{-129}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;Vef \leq 1.9 \cdot 10^{-127}:\\
\;\;\;\;NaChar \cdot \frac{1}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Vef \leq 1.45 \cdot 10^{+23}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;Vef \leq 3.1 \cdot 10^{+130}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if Vef < -2.75e14 or 3.1e130 < Vef 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 Vef around inf 89.6%
if -2.75e14 < Vef < -6.9999999999999995e-129 or 1.90000000000000001e-127 < Vef < 1.45000000000000006e23Initial 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 90.8%
if -6.9999999999999995e-129 < Vef < 1.90000000000000001e-127Initial 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in EDonor around inf 79.8%
if 1.45000000000000006e23 < Vef < 3.1e130Initial 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 93.6%
associate-*r/57.5%
mul-1-neg57.5%
Simplified93.6%
Final simplification87.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(t_2 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_3 (+ (/ EAccept KbT) 2.0)))
(if (<= EAccept -2.8e-250)
(+ t_1 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= EAccept 5.6e-75)
(+
t_0
(*
NaChar
(/
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ (/ Vef KbT) 2.0)))
(/ mu KbT)))))
(if (<= EAccept 1.85e+42)
(+ t_2 (/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))
(if (<= EAccept 2.05e+114)
(+
t_0
(/ NaChar (+ t_3 (/ (* 0.5 (* EAccept EAccept)) (* KbT KbT)))))
(if (<= EAccept 1.1e+182)
(+ t_2 (* NdChar 0.5))
(if (or (<= EAccept 8.4e+214) (not (<= EAccept 1.45e+296)))
(+ t_0 (/ NaChar t_3))
(+ t_1 (/ 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 t_1 = NdChar / (1.0 + exp((EDonor / KbT)));
double t_2 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_3 = (EAccept / KbT) + 2.0;
double tmp;
if (EAccept <= -2.8e-250) {
tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (EAccept <= 5.6e-75) {
tmp = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
} else if (EAccept <= 1.85e+42) {
tmp = t_2 + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
} else if (EAccept <= 2.05e+114) {
tmp = t_0 + (NaChar / (t_3 + ((0.5 * (EAccept * EAccept)) / (KbT * KbT))));
} else if (EAccept <= 1.1e+182) {
tmp = t_2 + (NdChar * 0.5);
} else if ((EAccept <= 8.4e+214) || !(EAccept <= 1.45e+296)) {
tmp = t_0 + (NaChar / t_3);
} else {
tmp = t_1 + (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) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_1 = ndchar / (1.0d0 + exp((edonor / kbt)))
t_2 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_3 = (eaccept / kbt) + 2.0d0
if (eaccept <= (-2.8d-250)) then
tmp = t_1 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (eaccept <= 5.6d-75) then
tmp = t_0 + (nachar * (1.0d0 / (((ev / kbt) + ((eaccept / kbt) + ((vef / kbt) + 2.0d0))) - (mu / kbt))))
else if (eaccept <= 1.85d+42) then
tmp = t_2 + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
else if (eaccept <= 2.05d+114) then
tmp = t_0 + (nachar / (t_3 + ((0.5d0 * (eaccept * eaccept)) / (kbt * kbt))))
else if (eaccept <= 1.1d+182) then
tmp = t_2 + (ndchar * 0.5d0)
else if ((eaccept <= 8.4d+214) .or. (.not. (eaccept <= 1.45d+296))) then
tmp = t_0 + (nachar / t_3)
else
tmp = t_1 + (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 t_1 = NdChar / (1.0 + Math.exp((EDonor / KbT)));
double t_2 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_3 = (EAccept / KbT) + 2.0;
double tmp;
if (EAccept <= -2.8e-250) {
tmp = t_1 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (EAccept <= 5.6e-75) {
tmp = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
} else if (EAccept <= 1.85e+42) {
tmp = t_2 + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
} else if (EAccept <= 2.05e+114) {
tmp = t_0 + (NaChar / (t_3 + ((0.5 * (EAccept * EAccept)) / (KbT * KbT))));
} else if (EAccept <= 1.1e+182) {
tmp = t_2 + (NdChar * 0.5);
} else if ((EAccept <= 8.4e+214) || !(EAccept <= 1.45e+296)) {
tmp = t_0 + (NaChar / t_3);
} else {
tmp = t_1 + (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))) t_1 = NdChar / (1.0 + math.exp((EDonor / KbT))) t_2 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_3 = (EAccept / KbT) + 2.0 tmp = 0 if EAccept <= -2.8e-250: tmp = t_1 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif EAccept <= 5.6e-75: tmp = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) elif EAccept <= 1.85e+42: tmp = t_2 + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))) elif EAccept <= 2.05e+114: tmp = t_0 + (NaChar / (t_3 + ((0.5 * (EAccept * EAccept)) / (KbT * KbT)))) elif EAccept <= 1.1e+182: tmp = t_2 + (NdChar * 0.5) elif (EAccept <= 8.4e+214) or not (EAccept <= 1.45e+296): tmp = t_0 + (NaChar / t_3) else: tmp = t_1 + (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)))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_3 = Float64(Float64(EAccept / KbT) + 2.0) tmp = 0.0 if (EAccept <= -2.8e-250) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (EAccept <= 5.6e-75) tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + 2.0))) - Float64(mu / KbT))))); elseif (EAccept <= 1.85e+42) tmp = Float64(t_2 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT))))); elseif (EAccept <= 2.05e+114) tmp = Float64(t_0 + Float64(NaChar / Float64(t_3 + Float64(Float64(0.5 * Float64(EAccept * EAccept)) / Float64(KbT * KbT))))); elseif (EAccept <= 1.1e+182) tmp = Float64(t_2 + Float64(NdChar * 0.5)); elseif ((EAccept <= 8.4e+214) || !(EAccept <= 1.45e+296)) tmp = Float64(t_0 + Float64(NaChar / t_3)); else tmp = Float64(t_1 + 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))); t_1 = NdChar / (1.0 + exp((EDonor / KbT))); t_2 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_3 = (EAccept / KbT) + 2.0; tmp = 0.0; if (EAccept <= -2.8e-250) tmp = t_1 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (EAccept <= 5.6e-75) tmp = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))); elseif (EAccept <= 1.85e+42) tmp = t_2 + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))); elseif (EAccept <= 2.05e+114) tmp = t_0 + (NaChar / (t_3 + ((0.5 * (EAccept * EAccept)) / (KbT * KbT)))); elseif (EAccept <= 1.1e+182) tmp = t_2 + (NdChar * 0.5); elseif ((EAccept <= 8.4e+214) || ~((EAccept <= 1.45e+296))) tmp = t_0 + (NaChar / t_3); else tmp = t_1 + (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]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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$3 = N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]}, If[LessEqual[EAccept, -2.8e-250], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 5.6e-75], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.85e+42], N[(t$95$2 + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 2.05e+114], N[(t$95$0 + N[(NaChar / N[(t$95$3 + N[(N[(0.5 * N[(EAccept * EAccept), $MachinePrecision]), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.1e+182], N[(t$95$2 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EAccept, 8.4e+214], N[Not[LessEqual[EAccept, 1.45e+296]], $MachinePrecision]], N[(t$95$0 + N[(NaChar / t$95$3), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + 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}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
t_2 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_3 := \frac{EAccept}{KbT} + 2\\
\mathbf{if}\;EAccept \leq -2.8 \cdot 10^{-250}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 5.6 \cdot 10^{-75}:\\
\;\;\;\;t_0 + NaChar \cdot \frac{1}{\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right)\right) - \frac{mu}{KbT}}\\
\mathbf{elif}\;EAccept \leq 1.85 \cdot 10^{+42}:\\
\;\;\;\;t_2 + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\
\mathbf{elif}\;EAccept \leq 2.05 \cdot 10^{+114}:\\
\;\;\;\;t_0 + \frac{NaChar}{t_3 + \frac{0.5 \cdot \left(EAccept \cdot EAccept\right)}{KbT \cdot KbT}}\\
\mathbf{elif}\;EAccept \leq 1.1 \cdot 10^{+182}:\\
\;\;\;\;t_2 + NdChar \cdot 0.5\\
\mathbf{elif}\;EAccept \leq 8.4 \cdot 10^{+214} \lor \neg \left(EAccept \leq 1.45 \cdot 10^{+296}\right):\\
\;\;\;\;t_0 + \frac{NaChar}{t_3}\\
\mathbf{else}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -2.80000000000000028e-250Initial 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 EDonor around inf 71.3%
Taylor expanded in Ev around inf 53.9%
if -2.80000000000000028e-250 < EAccept < 5.59999999999999996e-75Initial 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 63.4%
if 5.59999999999999996e-75 < EAccept < 1.84999999999999998e42Initial 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 EDonor around inf 65.8%
Taylor expanded in EDonor around 0 56.0%
if 1.84999999999999998e42 < EAccept < 2.05e114Initial 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 59.6%
Taylor expanded in EAccept around 0 49.7%
associate-+r+49.7%
associate-*r/49.7%
unpow249.7%
unpow249.7%
Simplified49.7%
if 2.05e114 < EAccept < 1.09999999999999998e182Initial 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.6%
if 1.09999999999999998e182 < EAccept < 8.4000000000000003e214 or 1.45000000000000002e296 < 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 80.6%
Taylor expanded in EAccept around 0 71.5%
if 8.4000000000000003e214 < EAccept < 1.45000000000000002e296Initial 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 82.0%
Taylor expanded in EDonor around inf 70.7%
Final simplification58.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ 1.0 (exp (/ Ev KbT)))))))
(if (<= EAccept -1.3e-252)
t_0
(if (<= EAccept 9e-73)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(*
NaChar
(/
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ (/ Vef KbT) 2.0)))
(/ mu KbT)))))
(if (<= EAccept 3.5e+26)
t_0
(if (or (<= EAccept 5.8e+97) (not (<= EAccept 1.3e+125)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ Vef (+ mu EDonor)) KbT))))
(/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(+
(/ NaChar (+ 1.0 (exp (/ Vef KbT))))
(/ NdChar (+ 1.0 (exp (/ (- Ec) 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((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
double tmp;
if (EAccept <= -1.3e-252) {
tmp = t_0;
} else if (EAccept <= 9e-73) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
} else if (EAccept <= 3.5e+26) {
tmp = t_0;
} else if ((EAccept <= 5.8e+97) || !(EAccept <= 1.3e+125)) {
tmp = (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
} else {
tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((-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) :: t_0
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
if (eaccept <= (-1.3d-252)) then
tmp = t_0
else if (eaccept <= 9d-73) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar * (1.0d0 / (((ev / kbt) + ((eaccept / kbt) + ((vef / kbt) + 2.0d0))) - (mu / kbt))))
else if (eaccept <= 3.5d+26) then
tmp = t_0
else if ((eaccept <= 5.8d+97) .or. (.not. (eaccept <= 1.3d+125))) then
tmp = (ndchar / (1.0d0 + exp(((vef + (mu + edonor)) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
else
tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((-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 t_0 = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
double tmp;
if (EAccept <= -1.3e-252) {
tmp = t_0;
} else if (EAccept <= 9e-73) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
} else if (EAccept <= 3.5e+26) {
tmp = t_0;
} else if ((EAccept <= 5.8e+97) || !(EAccept <= 1.3e+125)) {
tmp = (NdChar / (1.0 + Math.exp(((Vef + (mu + EDonor)) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else {
tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT)))) tmp = 0 if EAccept <= -1.3e-252: tmp = t_0 elif EAccept <= 9e-73: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) elif EAccept <= 3.5e+26: tmp = t_0 elif (EAccept <= 5.8e+97) or not (EAccept <= 1.3e+125): tmp = (NdChar / (1.0 + math.exp(((Vef + (mu + EDonor)) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) else: tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((-Ec / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))) tmp = 0.0 if (EAccept <= -1.3e-252) tmp = t_0; elseif (EAccept <= 9e-73) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar * Float64(1.0 / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + 2.0))) - Float64(mu / KbT))))); elseif (EAccept <= 3.5e+26) tmp = t_0; elseif ((EAccept <= 5.8e+97) || !(EAccept <= 1.3e+125)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu + EDonor)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT)))); tmp = 0.0; if (EAccept <= -1.3e-252) tmp = t_0; elseif (EAccept <= 9e-73) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))); elseif (EAccept <= 3.5e+26) tmp = t_0; elseif ((EAccept <= 5.8e+97) || ~((EAccept <= 1.3e+125))) tmp = (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT)))); else tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -1.3e-252], t$95$0, If[LessEqual[EAccept, 9e-73], 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[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.5e+26], t$95$0, If[Or[LessEqual[EAccept, 5.8e+97], N[Not[LessEqual[EAccept, 1.3e+125]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{if}\;EAccept \leq -1.3 \cdot 10^{-252}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;EAccept \leq 9 \cdot 10^{-73}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + NaChar \cdot \frac{1}{\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right)\right) - \frac{mu}{KbT}}\\
\mathbf{elif}\;EAccept \leq 3.5 \cdot 10^{+26}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;EAccept \leq 5.8 \cdot 10^{+97} \lor \neg \left(EAccept \leq 1.3 \cdot 10^{+125}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef + \left(mu + EDonor\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -1.3e-252 or 9e-73 < EAccept < 3.4999999999999999e26Initial 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 EDonor around inf 70.6%
Taylor expanded in Ev around inf 53.4%
if -1.3e-252 < EAccept < 9e-73Initial 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 65.9%
if 3.4999999999999999e26 < EAccept < 5.79999999999999974e97 or 1.30000000000000002e125 < 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 75.7%
Taylor expanded in Ec around 0 74.1%
if 5.79999999999999974e97 < EAccept < 1.30000000000000002e125Initial 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 82.3%
Taylor expanded in Ec around inf 65.1%
associate-*r/65.1%
mul-1-neg65.1%
Simplified65.1%
Final simplification60.5%
(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 (exp (/ mu KbT))))))
(t_2
(+
(/ NaChar (+ 1.0 (exp (/ Vef KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ Vef (+ mu EDonor)) KbT)))))))
(if (<= Vef -180000000.0)
t_2
(if (<= Vef -3.4e-129)
t_1
(if (<= Vef 1.36e-123)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Vef 1.35e+106) t_1 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 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
double t_2 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT))));
double tmp;
if (Vef <= -180000000.0) {
tmp = t_2;
} else if (Vef <= -3.4e-129) {
tmp = t_1;
} else if (Vef <= 1.36e-123) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Vef <= 1.35e+106) {
tmp = t_1;
} 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 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
t_2 = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp(((vef + (mu + edonor)) / kbt))))
if (vef <= (-180000000.0d0)) then
tmp = t_2
else if (vef <= (-3.4d-129)) then
tmp = t_1
else if (vef <= 1.36d-123) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (vef <= 1.35d+106) then
tmp = t_1
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 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
double t_2 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef + (mu + EDonor)) / KbT))));
double tmp;
if (Vef <= -180000000.0) {
tmp = t_2;
} else if (Vef <= -3.4e-129) {
tmp = t_1;
} else if (Vef <= 1.36e-123) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Vef <= 1.35e+106) {
tmp = t_1;
} else {
tmp = t_2;
}
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 + math.exp((mu / KbT)))) t_2 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp(((Vef + (mu + EDonor)) / KbT)))) tmp = 0 if Vef <= -180000000.0: tmp = t_2 elif Vef <= -3.4e-129: tmp = t_1 elif Vef <= 1.36e-123: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Vef <= 1.35e+106: tmp = t_1 else: tmp = t_2 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 + exp(Float64(mu / KbT))))) t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu + EDonor)) / KbT))))) tmp = 0.0 if (Vef <= -180000000.0) tmp = t_2; elseif (Vef <= -3.4e-129) tmp = t_1; elseif (Vef <= 1.36e-123) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Vef <= 1.35e+106) tmp = t_1; else tmp = t_2; 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 + exp((mu / KbT)))); t_2 = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))); tmp = 0.0; if (Vef <= -180000000.0) tmp = t_2; elseif (Vef <= -3.4e-129) tmp = t_1; elseif (Vef <= 1.36e-123) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Vef <= 1.35e+106) tmp = t_1; else tmp = t_2; 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[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -180000000.0], t$95$2, If[LessEqual[Vef, -3.4e-129], t$95$1, If[LessEqual[Vef, 1.36e-123], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.35e+106], t$95$1, t$95$2]]]]]]]
\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 + e^{\frac{mu}{KbT}}}\\
t_2 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu + EDonor\right)}{KbT}}}\\
\mathbf{if}\;Vef \leq -180000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;Vef \leq -3.4 \cdot 10^{-129}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Vef \leq 1.36 \cdot 10^{-123}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Vef \leq 1.35 \cdot 10^{+106}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if Vef < -1.8e8 or 1.35000000000000003e106 < Vef 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 Vef around inf 88.3%
Taylor expanded in Ec around 0 84.6%
if -1.8e8 < Vef < -3.40000000000000013e-129 or 1.36e-123 < Vef < 1.35000000000000003e106Initial 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.8%
if -3.40000000000000013e-129 < Vef < 1.36e-123Initial 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 EDonor around inf 79.8%
Final simplification83.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 (exp (/ mu KbT))))))
(t_2
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (exp (/ Vef KbT)))))))
(if (<= Vef -9000000000.0)
t_2
(if (<= Vef -3.8e-129)
t_1
(if (<= Vef 2.25e-125)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Vef 3e+106) t_1 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 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
double t_2 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((Vef / KbT))));
double tmp;
if (Vef <= -9000000000.0) {
tmp = t_2;
} else if (Vef <= -3.8e-129) {
tmp = t_1;
} else if (Vef <= 2.25e-125) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Vef <= 3e+106) {
tmp = t_1;
} 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 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
t_2 = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + exp((vef / kbt))))
if (vef <= (-9000000000.0d0)) then
tmp = t_2
else if (vef <= (-3.8d-129)) then
tmp = t_1
else if (vef <= 2.25d-125) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (vef <= 3d+106) then
tmp = t_1
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 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
double t_2 = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + Math.exp((Vef / KbT))));
double tmp;
if (Vef <= -9000000000.0) {
tmp = t_2;
} else if (Vef <= -3.8e-129) {
tmp = t_1;
} else if (Vef <= 2.25e-125) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Vef <= 3e+106) {
tmp = t_1;
} else {
tmp = t_2;
}
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 + math.exp((mu / KbT)))) t_2 = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + math.exp((Vef / KbT)))) tmp = 0 if Vef <= -9000000000.0: tmp = t_2 elif Vef <= -3.8e-129: tmp = t_1 elif Vef <= 2.25e-125: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Vef <= 3e+106: tmp = t_1 else: tmp = t_2 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 + exp(Float64(mu / KbT))))) t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))) tmp = 0.0 if (Vef <= -9000000000.0) tmp = t_2; elseif (Vef <= -3.8e-129) tmp = t_1; elseif (Vef <= 2.25e-125) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Vef <= 3e+106) tmp = t_1; else tmp = t_2; 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 + exp((mu / KbT)))); t_2 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((Vef / KbT)))); tmp = 0.0; if (Vef <= -9000000000.0) tmp = t_2; elseif (Vef <= -3.8e-129) tmp = t_1; elseif (Vef <= 2.25e-125) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Vef <= 3e+106) tmp = t_1; else tmp = t_2; 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[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -9000000000.0], t$95$2, If[LessEqual[Vef, -3.8e-129], t$95$1, If[LessEqual[Vef, 2.25e-125], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 3e+106], t$95$1, t$95$2]]]]]]]
\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 + e^{\frac{mu}{KbT}}}\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;Vef \leq -9000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;Vef \leq -3.8 \cdot 10^{-129}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Vef \leq 2.25 \cdot 10^{-125}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Vef \leq 3 \cdot 10^{+106}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if Vef < -9e9 or 3.0000000000000001e106 < Vef 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 Vef around inf 88.3%
if -9e9 < Vef < -3.79999999999999985e-129 or 2.25000000000000006e-125 < Vef < 3.0000000000000001e106Initial 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.8%
if -3.79999999999999985e-129 < Vef < 2.25000000000000006e-125Initial 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 EDonor around inf 79.8%
Final simplification85.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_2 (+ (/ EAccept KbT) 2.0)))
(if (<= EAccept -1.45e-242)
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= EAccept 3.5e-75)
(+
t_0
(*
NaChar
(/
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ (/ Vef KbT) 2.0)))
(/ mu KbT)))))
(if (<= EAccept 2.05e+42)
(+ t_1 (/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))
(if (<= EAccept 5.6e+114)
(+
t_0
(/ NaChar (+ t_2 (/ (* 0.5 (* EAccept EAccept)) (* KbT KbT)))))
(if (<= EAccept 2.2e+181)
(+ t_1 (* NdChar 0.5))
(if (<= EAccept 1.35e+216)
(+ t_0 (/ NaChar t_2))
(+
(/ NdChar (+ 1.0 (exp (/ mu 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 t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = (EAccept / KbT) + 2.0;
double tmp;
if (EAccept <= -1.45e-242) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (EAccept <= 3.5e-75) {
tmp = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
} else if (EAccept <= 2.05e+42) {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
} else if (EAccept <= 5.6e+114) {
tmp = t_0 + (NaChar / (t_2 + ((0.5 * (EAccept * EAccept)) / (KbT * KbT))));
} else if (EAccept <= 2.2e+181) {
tmp = t_1 + (NdChar * 0.5);
} else if (EAccept <= 1.35e+216) {
tmp = t_0 + (NaChar / t_2);
} else {
tmp = (NdChar / (1.0 + exp((mu / 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) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_2 = (eaccept / kbt) + 2.0d0
if (eaccept <= (-1.45d-242)) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
else if (eaccept <= 3.5d-75) then
tmp = t_0 + (nachar * (1.0d0 / (((ev / kbt) + ((eaccept / kbt) + ((vef / kbt) + 2.0d0))) - (mu / kbt))))
else if (eaccept <= 2.05d+42) then
tmp = t_1 + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
else if (eaccept <= 5.6d+114) then
tmp = t_0 + (nachar / (t_2 + ((0.5d0 * (eaccept * eaccept)) / (kbt * kbt))))
else if (eaccept <= 2.2d+181) then
tmp = t_1 + (ndchar * 0.5d0)
else if (eaccept <= 1.35d+216) then
tmp = t_0 + (nachar / t_2)
else
tmp = (ndchar / (1.0d0 + exp((mu / 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 t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = (EAccept / KbT) + 2.0;
double tmp;
if (EAccept <= -1.45e-242) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (EAccept <= 3.5e-75) {
tmp = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
} else if (EAccept <= 2.05e+42) {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
} else if (EAccept <= 5.6e+114) {
tmp = t_0 + (NaChar / (t_2 + ((0.5 * (EAccept * EAccept)) / (KbT * KbT))));
} else if (EAccept <= 2.2e+181) {
tmp = t_1 + (NdChar * 0.5);
} else if (EAccept <= 1.35e+216) {
tmp = t_0 + (NaChar / t_2);
} else {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (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))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_2 = (EAccept / KbT) + 2.0 tmp = 0 if EAccept <= -1.45e-242: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif EAccept <= 3.5e-75: tmp = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) elif EAccept <= 2.05e+42: tmp = t_1 + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))) elif EAccept <= 5.6e+114: tmp = t_0 + (NaChar / (t_2 + ((0.5 * (EAccept * EAccept)) / (KbT * KbT)))) elif EAccept <= 2.2e+181: tmp = t_1 + (NdChar * 0.5) elif EAccept <= 1.35e+216: tmp = t_0 + (NaChar / t_2) else: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (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)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_2 = Float64(Float64(EAccept / KbT) + 2.0) tmp = 0.0 if (EAccept <= -1.45e-242) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (EAccept <= 3.5e-75) tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + 2.0))) - Float64(mu / KbT))))); elseif (EAccept <= 2.05e+42) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT))))); elseif (EAccept <= 5.6e+114) tmp = Float64(t_0 + Float64(NaChar / Float64(t_2 + Float64(Float64(0.5 * Float64(EAccept * EAccept)) / Float64(KbT * KbT))))); elseif (EAccept <= 2.2e+181) tmp = Float64(t_1 + Float64(NdChar * 0.5)); elseif (EAccept <= 1.35e+216) tmp = Float64(t_0 + Float64(NaChar / t_2)); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / 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) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_2 = (EAccept / KbT) + 2.0; tmp = 0.0; if (EAccept <= -1.45e-242) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (EAccept <= 3.5e-75) tmp = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))); elseif (EAccept <= 2.05e+42) tmp = t_1 + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))); elseif (EAccept <= 5.6e+114) tmp = t_0 + (NaChar / (t_2 + ((0.5 * (EAccept * EAccept)) / (KbT * KbT)))); elseif (EAccept <= 2.2e+181) tmp = t_1 + (NdChar * 0.5); elseif (EAccept <= 1.35e+216) tmp = t_0 + (NaChar / t_2); else tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (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]}, 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[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]}, If[LessEqual[EAccept, -1.45e-242], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.5e-75], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 2.05e+42], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 5.6e+114], N[(t$95$0 + N[(NaChar / N[(t$95$2 + N[(N[(0.5 * N[(EAccept * EAccept), $MachinePrecision]), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 2.2e+181], N[(t$95$1 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.35e+216], N[(t$95$0 + N[(NaChar / t$95$2), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / 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}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_2 := \frac{EAccept}{KbT} + 2\\
\mathbf{if}\;EAccept \leq -1.45 \cdot 10^{-242}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 3.5 \cdot 10^{-75}:\\
\;\;\;\;t_0 + NaChar \cdot \frac{1}{\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right)\right) - \frac{mu}{KbT}}\\
\mathbf{elif}\;EAccept \leq 2.05 \cdot 10^{+42}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\
\mathbf{elif}\;EAccept \leq 5.6 \cdot 10^{+114}:\\
\;\;\;\;t_0 + \frac{NaChar}{t_2 + \frac{0.5 \cdot \left(EAccept \cdot EAccept\right)}{KbT \cdot KbT}}\\
\mathbf{elif}\;EAccept \leq 2.2 \cdot 10^{+181}:\\
\;\;\;\;t_1 + NdChar \cdot 0.5\\
\mathbf{elif}\;EAccept \leq 1.35 \cdot 10^{+216}:\\
\;\;\;\;t_0 + \frac{NaChar}{t_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -1.45e-242Initial 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 EDonor around inf 71.6%
Taylor expanded in Ev around inf 54.0%
if -1.45e-242 < EAccept < 3.49999999999999985e-75Initial 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 63.0%
if 3.49999999999999985e-75 < EAccept < 2.05e42Initial 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 EDonor around inf 65.8%
Taylor expanded in EDonor around 0 56.0%
if 2.05e42 < EAccept < 5.6000000000000001e114Initial 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 59.6%
Taylor expanded in EAccept around 0 49.7%
associate-+r+49.7%
associate-*r/49.7%
unpow249.7%
unpow249.7%
Simplified49.7%
if 5.6000000000000001e114 < EAccept < 2.2000000000000001e181Initial 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.6%
if 2.2000000000000001e181 < EAccept < 1.3500000000000001e216Initial 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 72.2%
Taylor expanded in EAccept around 0 59.3%
if 1.3500000000000001e216 < 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 84.9%
Taylor expanded in mu around inf 69.6%
Final simplification57.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) 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 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((((Vef + (Ev + 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(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + exp((((vef + (ev + 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(((mu + ((Vef + EDonor) - Ec)) / 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.exp(((mu + ((Vef + EDonor) - Ec)) / 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(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / 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 + exp(((mu + ((Vef + EDonor) - Ec)) / 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[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[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}
\end{array}
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%
Final simplification100.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ Vef (+ mu EDonor)) KbT)))))
(t_1 (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) t_0)))
(if (<= EAccept -6.5e-254)
t_1
(if (<= EAccept 2.4e-142)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(*
NaChar
(/
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ (/ Vef KbT) 2.0)))
(/ mu KbT)))))
(if (<= EAccept 6.4e+189)
t_1
(+ 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(((Vef + (mu + EDonor)) / KbT)));
double t_1 = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0;
double tmp;
if (EAccept <= -6.5e-254) {
tmp = t_1;
} else if (EAccept <= 2.4e-142) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
} else if (EAccept <= 6.4e+189) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((vef + (mu + edonor)) / kbt)))
t_1 = (nachar / (1.0d0 + exp((vef / kbt)))) + t_0
if (eaccept <= (-6.5d-254)) then
tmp = t_1
else if (eaccept <= 2.4d-142) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar * (1.0d0 / (((ev / kbt) + ((eaccept / kbt) + ((vef / kbt) + 2.0d0))) - (mu / kbt))))
else if (eaccept <= 6.4d+189) then
tmp = t_1
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(((Vef + (mu + EDonor)) / KbT)));
double t_1 = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
double tmp;
if (EAccept <= -6.5e-254) {
tmp = t_1;
} else if (EAccept <= 2.4e-142) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
} else if (EAccept <= 6.4e+189) {
tmp = t_1;
} 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(((Vef + (mu + EDonor)) / KbT))) t_1 = (NaChar / (1.0 + math.exp((Vef / KbT)))) + t_0 tmp = 0 if EAccept <= -6.5e-254: tmp = t_1 elif EAccept <= 2.4e-142: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) elif EAccept <= 6.4e+189: tmp = t_1 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(Vef + Float64(mu + EDonor)) / KbT)))) t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0) tmp = 0.0 if (EAccept <= -6.5e-254) tmp = t_1; elseif (EAccept <= 2.4e-142) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar * Float64(1.0 / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + 2.0))) - Float64(mu / KbT))))); elseif (EAccept <= 6.4e+189) tmp = t_1; 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(((Vef + (mu + EDonor)) / KbT))); t_1 = (NaChar / (1.0 + exp((Vef / KbT)))) + t_0; tmp = 0.0; if (EAccept <= -6.5e-254) tmp = t_1; elseif (EAccept <= 2.4e-142) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))); elseif (EAccept <= 6.4e+189) tmp = t_1; 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[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, If[LessEqual[EAccept, -6.5e-254], t$95$1, If[LessEqual[EAccept, 2.4e-142], 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[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 6.4e+189], t$95$1, 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{Vef + \left(mu + EDonor\right)}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + t_0\\
\mathbf{if}\;EAccept \leq -6.5 \cdot 10^{-254}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 2.4 \cdot 10^{-142}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + NaChar \cdot \frac{1}{\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right)\right) - \frac{mu}{KbT}}\\
\mathbf{elif}\;EAccept \leq 6.4 \cdot 10^{+189}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -6.5e-254 or 2.39999999999999988e-142 < EAccept < 6.4000000000000001e189Initial 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 71.1%
Taylor expanded in Ec around 0 67.5%
if -6.5e-254 < EAccept < 2.39999999999999988e-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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 67.0%
if 6.4000000000000001e189 < 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 84.7%
Taylor expanded in Ec around 0 81.4%
Final simplification68.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= Vef -3.4e-23) (not (<= Vef 4.8e+118)))
(+
(/ NaChar (+ 1.0 (exp (/ Vef KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ Vef (+ mu EDonor)) KbT)))))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) 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 tmp;
if ((Vef <= -3.4e-23) || !(Vef <= 4.8e+118)) {
tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT))));
} else {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / 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) :: tmp
if ((vef <= (-3.4d-23)) .or. (.not. (vef <= 4.8d+118))) then
tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp(((vef + (mu + edonor)) / kbt))))
else
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / 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 tmp;
if ((Vef <= -3.4e-23) || !(Vef <= 4.8e+118)) {
tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef + (mu + EDonor)) / KbT))));
} else {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (Vef <= -3.4e-23) or not (Vef <= 4.8e+118): tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp(((Vef + (mu + EDonor)) / KbT)))) else: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((Vef <= -3.4e-23) || !(Vef <= 4.8e+118)) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu + EDonor)) / KbT))))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / 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) tmp = 0.0; if ((Vef <= -3.4e-23) || ~((Vef <= 4.8e+118))) tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))); else tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -3.4e-23], N[Not[LessEqual[Vef, 4.8e+118]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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 / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;Vef \leq -3.4 \cdot 10^{-23} \lor \neg \left(Vef \leq 4.8 \cdot 10^{+118}\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu + EDonor\right)}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\end{array}
\end{array}
if Vef < -3.4000000000000001e-23 or 4.8e118 < Vef 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 Vef around inf 87.5%
Taylor expanded in Ec around 0 84.1%
if -3.4000000000000001e-23 < Vef < 4.8e118Initial 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 EDonor around inf 76.8%
Final simplification80.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_1
(+
t_0
(*
NaChar
(/
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ (/ Vef KbT) 2.0)))
(/ mu KbT)))))))
(if (<= NdChar -1.5e-47)
t_1
(if (<= NdChar 5e-116)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))
(if (<= NdChar 5.8e-42)
t_1
(if (<= NdChar 2.8e-9)
(+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (* NdChar 0.5))
(+ t_0 (* NaChar (/ 1.0 (- (/ Vef KbT) (/ 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(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
double tmp;
if (NdChar <= -1.5e-47) {
tmp = t_1;
} else if (NdChar <= 5e-116) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
} else if (NdChar <= 5.8e-42) {
tmp = t_1;
} else if (NdChar <= 2.8e-9) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5);
} else {
tmp = t_0 + (NaChar * (1.0 / ((Vef / KbT) - (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(((mu + ((vef + edonor) - ec)) / kbt)))
t_1 = t_0 + (nachar * (1.0d0 / (((ev / kbt) + ((eaccept / kbt) + ((vef / kbt) + 2.0d0))) - (mu / kbt))))
if (ndchar <= (-1.5d-47)) then
tmp = t_1
else if (ndchar <= 5d-116) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
else if (ndchar <= 5.8d-42) then
tmp = t_1
else if (ndchar <= 2.8d-9) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar * 0.5d0)
else
tmp = t_0 + (nachar * (1.0d0 / ((vef / kbt) - (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(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT))));
double tmp;
if (NdChar <= -1.5e-47) {
tmp = t_1;
} else if (NdChar <= 5e-116) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
} else if (NdChar <= 5.8e-42) {
tmp = t_1;
} else if (NdChar <= 2.8e-9) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar * 0.5);
} else {
tmp = t_0 + (NaChar * (1.0 / ((Vef / KbT) - (mu / 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))) t_1 = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) tmp = 0 if NdChar <= -1.5e-47: tmp = t_1 elif NdChar <= 5e-116: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))) elif NdChar <= 5.8e-42: tmp = t_1 elif NdChar <= 2.8e-9: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar * 0.5) else: tmp = t_0 + (NaChar * (1.0 / ((Vef / KbT) - (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(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_1 = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + 2.0))) - Float64(mu / KbT))))) tmp = 0.0 if (NdChar <= -1.5e-47) tmp = t_1; elseif (NdChar <= 5e-116) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT))))); elseif (NdChar <= 5.8e-42) tmp = t_1; elseif (NdChar <= 2.8e-9) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar * 0.5)); else tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Vef / KbT) - 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(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_1 = t_0 + (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))); tmp = 0.0; if (NdChar <= -1.5e-47) tmp = t_1; elseif (NdChar <= 5e-116) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))); elseif (NdChar <= 5.8e-42) tmp = t_1; elseif (NdChar <= 2.8e-9) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar * 0.5); else tmp = t_0 + (NaChar * (1.0 / ((Vef / KbT) - (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[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.5e-47], t$95$1, If[LessEqual[NdChar, 5e-116], 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[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 5.8e-42], t$95$1, If[LessEqual[NdChar, 2.8e-9], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(Vef / KbT), $MachinePrecision] - N[(mu / 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}}}\\
t_1 := t_0 + NaChar \cdot \frac{1}{\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right)\right) - \frac{mu}{KbT}}\\
\mathbf{if}\;NdChar \leq -1.5 \cdot 10^{-47}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NdChar \leq 5 \cdot 10^{-116}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\
\mathbf{elif}\;NdChar \leq 5.8 \cdot 10^{-42}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NdChar \leq 2.8 \cdot 10^{-9}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;t_0 + NaChar \cdot \frac{1}{\frac{Vef}{KbT} - \frac{mu}{KbT}}\\
\end{array}
\end{array}
if NdChar < -1.50000000000000008e-47 or 5.0000000000000003e-116 < NdChar < 5.8000000000000006e-42Initial 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 62.3%
if -1.50000000000000008e-47 < NdChar < 5.0000000000000003e-116Initial 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 EDonor around inf 78.6%
Taylor expanded in EDonor around 0 70.9%
if 5.8000000000000006e-42 < NdChar < 2.79999999999999984e-9Initial 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 86.5%
Taylor expanded in mu around inf 86.5%
associate-*r/100.0%
mul-1-neg100.0%
Simplified86.5%
if 2.79999999999999984e-9 < 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 52.9%
Taylor expanded in Vef around inf 57.7%
Final simplification64.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 (<= NdChar -3.1e-47)
(+ t_0 (/ NaChar (+ (/ EAccept KbT) 2.0)))
(if (<= NdChar 3.6e-15)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))
(+ t_0 (* NaChar (/ 1.0 (- (/ Vef KbT) (/ 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(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -3.1e-47) {
tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
} else if (NdChar <= 3.6e-15) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
} else {
tmp = t_0 + (NaChar * (1.0 / ((Vef / KbT) - (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) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ndchar <= (-3.1d-47)) then
tmp = t_0 + (nachar / ((eaccept / kbt) + 2.0d0))
else if (ndchar <= 3.6d-15) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
else
tmp = t_0 + (nachar * (1.0d0 / ((vef / kbt) - (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(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -3.1e-47) {
tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
} else if (NdChar <= 3.6e-15) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
} else {
tmp = t_0 + (NaChar * (1.0 / ((Vef / KbT) - (mu / 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 NdChar <= -3.1e-47: tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0)) elif NdChar <= 3.6e-15: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))) else: tmp = t_0 + (NaChar * (1.0 / ((Vef / KbT) - (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(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (NdChar <= -3.1e-47) tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))); elseif (NdChar <= 3.6e-15) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT))))); else tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Vef / KbT) - 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(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (NdChar <= -3.1e-47) tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0)); elseif (NdChar <= 3.6e-15) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))); else tmp = t_0 + (NaChar * (1.0 / ((Vef / KbT) - (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[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -3.1e-47], N[(t$95$0 + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 3.6e-15], 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[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(Vef / KbT), $MachinePrecision] - N[(mu / 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}\;NdChar \leq -3.1 \cdot 10^{-47}:\\
\;\;\;\;t_0 + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{elif}\;NdChar \leq 3.6 \cdot 10^{-15}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_0 + NaChar \cdot \frac{1}{\frac{Vef}{KbT} - \frac{mu}{KbT}}\\
\end{array}
\end{array}
if NdChar < -3.0999999999999998e-47Initial 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 58.2%
if -3.0999999999999998e-47 < NdChar < 3.6000000000000001e-15Initial 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 EDonor around inf 75.3%
Taylor expanded in EDonor around 0 67.3%
if 3.6000000000000001e-15 < 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 52.9%
Taylor expanded in Vef around inf 57.7%
Final simplification62.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -1.65e-46) (not (<= NdChar 7000000000000.0)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ (/ EAccept KbT) 2.0)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -1.65e-46) || !(NdChar <= 7000000000000.0)) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (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) :: tmp
if ((ndchar <= (-1.65d-46)) .or. (.not. (ndchar <= 7000000000000.0d0))) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
else
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (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 tmp;
if ((NdChar <= -1.65e-46) || !(NdChar <= 7000000000000.0)) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -1.65e-46) or not (NdChar <= 7000000000000.0): tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) else: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -1.65e-46) || !(NdChar <= 7000000000000.0)) 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))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -1.65e-46) || ~((NdChar <= 7000000000000.0))) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)); else tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (EDonor / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.65e-46], N[Not[LessEqual[NdChar, 7000000000000.0]], $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[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $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 / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -1.65 \cdot 10^{-46} \lor \neg \left(NdChar \leq 7000000000000\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\
\end{array}
\end{array}
if NdChar < -1.65000000000000007e-46 or 7e12 < 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 EAccept around inf 67.7%
Taylor expanded in EAccept around 0 58.8%
if -1.65000000000000007e-46 < NdChar < 7e12Initial 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 EDonor around inf 73.9%
Taylor expanded in EDonor around 0 64.8%
Final simplification61.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -4.2e-48) (not (<= NdChar 11000000000000.0)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ (/ EAccept KbT) 2.0)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) 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 <= -4.2e-48) || !(NdChar <= 11000000000000.0)) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - 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 <= (-4.2d-48)) .or. (.not. (ndchar <= 11000000000000.0d0))) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
else
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - 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 <= -4.2e-48) || !(NdChar <= 11000000000000.0)) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -4.2e-48) or not (NdChar <= 11000000000000.0): tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) else: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -4.2e-48) || !(NdChar <= 11000000000000.0)) 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))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - 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 <= -4.2e-48) || ~((NdChar <= 11000000000000.0))) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)); else tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -4.2e-48], N[Not[LessEqual[NdChar, 11000000000000.0]], $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[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $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 * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -4.2 \cdot 10^{-48} \lor \neg \left(NdChar \leq 11000000000000\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NdChar < -4.19999999999999977e-48 or 1.1e13 < 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 EAccept around inf 67.7%
Taylor expanded in EAccept around 0 58.8%
if -4.19999999999999977e-48 < NdChar < 1.1e13Initial 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 58.0%
Final simplification58.4%
(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 (<= KbT -7.6e-63)
(+ t_0 (* NaChar 0.5))
(if (<= KbT 3.45e-127)
(+ t_0 (/ NaChar (/ Vef KbT)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) 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 t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (KbT <= -7.6e-63) {
tmp = t_0 + (NaChar * 0.5);
} else if (KbT <= 3.45e-127) {
tmp = t_0 + (NaChar / (Vef / KbT));
} else {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - 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) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (kbt <= (-7.6d-63)) then
tmp = t_0 + (nachar * 0.5d0)
else if (kbt <= 3.45d-127) then
tmp = t_0 + (nachar / (vef / kbt))
else
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - 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 t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (KbT <= -7.6e-63) {
tmp = t_0 + (NaChar * 0.5);
} else if (KbT <= 3.45e-127) {
tmp = t_0 + (NaChar / (Vef / KbT));
} else {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
}
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 KbT <= -7.6e-63: tmp = t_0 + (NaChar * 0.5) elif KbT <= 3.45e-127: tmp = t_0 + (NaChar / (Vef / KbT)) else: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) 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 (KbT <= -7.6e-63) tmp = Float64(t_0 + Float64(NaChar * 0.5)); elseif (KbT <= 3.45e-127) tmp = Float64(t_0 + Float64(NaChar / Float64(Vef / KbT))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar * 0.5)); 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 (KbT <= -7.6e-63) tmp = t_0 + (NaChar * 0.5); elseif (KbT <= 3.45e-127) tmp = t_0 + (NaChar / (Vef / KbT)); else tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); 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[KbT, -7.6e-63], N[(t$95$0 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.45e-127], N[(t$95$0 + N[(NaChar / N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $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 * 0.5), $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}\;KbT \leq -7.6 \cdot 10^{-63}:\\
\;\;\;\;t_0 + NaChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 3.45 \cdot 10^{-127}:\\
\;\;\;\;t_0 + \frac{NaChar}{\frac{Vef}{KbT}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if KbT < -7.60000000000000034e-63Initial 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 63.3%
*-commutative48.3%
Simplified63.3%
if -7.60000000000000034e-63 < KbT < 3.45000000000000008e-127Initial 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 49.5%
Taylor expanded in Vef around inf 51.4%
associate-/l*54.6%
Simplified54.6%
if 3.45000000000000008e-127 < KbT 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 53.9%
Final simplification56.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ (/ EAccept KbT) 2.0)))))
(if (<= EDonor -4.2e-105)
t_0
(if (<= EDonor -1e-221)
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))
(if (<= EDonor 7.2e+137)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
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 = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
double tmp;
if (EDonor <= -4.2e-105) {
tmp = t_0;
} else if (EDonor <= -1e-221) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
} else if (EDonor <= 7.2e+137) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
} 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) :: tmp
t_0 = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
if (edonor <= (-4.2d-105)) then
tmp = t_0
else if (edonor <= (-1d-221)) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
else if (edonor <= 7.2d+137) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
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 = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
double tmp;
if (EDonor <= -4.2e-105) {
tmp = t_0;
} else if (EDonor <= -1e-221) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
} else if (EDonor <= 7.2e+137) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) tmp = 0 if EDonor <= -4.2e-105: tmp = t_0 elif EDonor <= -1e-221: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) elif EDonor <= 7.2e+137: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) else: tmp = t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))) tmp = 0.0 if (EDonor <= -4.2e-105) tmp = t_0; elseif (EDonor <= -1e-221) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); elseif (EDonor <= 7.2e+137) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); else tmp = t_0; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)); tmp = 0.0; if (EDonor <= -4.2e-105) tmp = t_0; elseif (EDonor <= -1e-221) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); elseif (EDonor <= 7.2e+137) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); 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[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -4.2e-105], t$95$0, If[LessEqual[EDonor, -1e-221], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 7.2e+137], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{if}\;EDonor \leq -4.2 \cdot 10^{-105}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;EDonor \leq -1 \cdot 10^{-221}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{elif}\;EDonor \leq 7.2 \cdot 10^{+137}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if EDonor < -4.2e-105 or 7.1999999999999999e137 < EDonor 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 64.0%
Taylor expanded in EAccept around 0 52.6%
Taylor expanded in EDonor around inf 48.0%
if -4.2e-105 < EDonor < -1.00000000000000002e-221Initial 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.1%
Taylor expanded in Ev around inf 49.8%
if -1.00000000000000002e-221 < EDonor < 7.1999999999999999e137Initial 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 64.6%
Taylor expanded in KbT around inf 37.9%
Final simplification43.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ (/ EAccept KbT) 2.0)))
(t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
(if (<= EDonor -5.4e-104)
(+ t_1 (/ NaChar (- 2.0 (/ mu KbT))))
(if (<= EDonor -4.8e-271)
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))
(if (<= EDonor 1e+138)
(+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) t_0)
(+ t_1 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 t_1 = NdChar / (1.0 + exp((EDonor / KbT)));
double tmp;
if (EDonor <= -5.4e-104) {
tmp = t_1 + (NaChar / (2.0 - (mu / KbT)));
} else if (EDonor <= -4.8e-271) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
} else if (EDonor <= 1e+138) {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + t_0;
} else {
tmp = t_1 + 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 / ((eaccept / kbt) + 2.0d0)
t_1 = ndchar / (1.0d0 + exp((edonor / kbt)))
if (edonor <= (-5.4d-104)) then
tmp = t_1 + (nachar / (2.0d0 - (mu / kbt)))
else if (edonor <= (-4.8d-271)) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
else if (edonor <= 1d+138) then
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + t_0
else
tmp = t_1 + 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 t_1 = NdChar / (1.0 + Math.exp((EDonor / KbT)));
double tmp;
if (EDonor <= -5.4e-104) {
tmp = t_1 + (NaChar / (2.0 - (mu / KbT)));
} else if (EDonor <= -4.8e-271) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
} else if (EDonor <= 1e+138) {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + t_0;
} else {
tmp = t_1 + t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / ((EAccept / KbT) + 2.0) t_1 = NdChar / (1.0 + math.exp((EDonor / KbT))) tmp = 0 if EDonor <= -5.4e-104: tmp = t_1 + (NaChar / (2.0 - (mu / KbT))) elif EDonor <= -4.8e-271: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) elif EDonor <= 1e+138: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + t_0 else: tmp = t_1 + 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)) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) tmp = 0.0 if (EDonor <= -5.4e-104) tmp = Float64(t_1 + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); elseif (EDonor <= -4.8e-271) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); elseif (EDonor <= 1e+138) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + t_0); else tmp = Float64(t_1 + 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); t_1 = NdChar / (1.0 + exp((EDonor / KbT))); tmp = 0.0; if (EDonor <= -5.4e-104) tmp = t_1 + (NaChar / (2.0 - (mu / KbT))); elseif (EDonor <= -4.8e-271) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); elseif (EDonor <= 1e+138) tmp = (NdChar / (1.0 + exp((mu / KbT)))) + t_0; else tmp = t_1 + 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]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -5.4e-104], N[(t$95$1 + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, -4.8e-271], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 1e+138], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], N[(t$95$1 + t$95$0), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
t_1 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{if}\;EDonor \leq -5.4 \cdot 10^{-104}:\\
\;\;\;\;t_1 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\mathbf{elif}\;EDonor \leq -4.8 \cdot 10^{-271}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{elif}\;EDonor \leq 10^{+138}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + t_0\\
\mathbf{else}:\\
\;\;\;\;t_1 + t_0\\
\end{array}
\end{array}
if EDonor < -5.3999999999999997e-104Initial 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 EDonor around inf 73.1%
Taylor expanded in mu around inf 53.9%
associate-*r/53.9%
mul-1-neg53.9%
Simplified53.9%
Taylor expanded in mu around 0 44.5%
mul-1-neg44.5%
unsub-neg44.5%
Simplified44.5%
if -5.3999999999999997e-104 < EDonor < -4.8000000000000005e-271Initial 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.8%
Taylor expanded in Ev around inf 52.6%
if -4.8000000000000005e-271 < EDonor < 1e138Initial 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 64.9%
Taylor expanded in EAccept around 0 49.3%
Taylor expanded in mu around inf 37.5%
if 1e138 < EDonor 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 78.1%
Taylor expanded in EAccept around 0 56.6%
Taylor expanded in EDonor around inf 56.7%
Final simplification44.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -2.1e-191) (not (<= NaChar 9e-26)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))
(+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar (+ (/ EAccept KbT) 2.0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -2.1e-191) || !(NaChar <= 9e-26)) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / ((EAccept / KbT) + 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) :: tmp
if ((nachar <= (-2.1d-191)) .or. (.not. (nachar <= 9d-26))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
else
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / ((eaccept / kbt) + 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 tmp;
if ((NaChar <= -2.1e-191) || !(NaChar <= 9e-26)) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -2.1e-191) or not (NaChar <= 9e-26): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) else: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -2.1e-191) || !(NaChar <= 9e-26)) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar * 0.5)); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -2.1e-191) || ~((NaChar <= 9e-26))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); else tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -2.1e-191], N[Not[LessEqual[NaChar, 9e-26]], $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 * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -2.1 \cdot 10^{-191} \lor \neg \left(NaChar \leq 9 \cdot 10^{-26}\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\end{array}
\end{array}
if NaChar < -2.09999999999999985e-191 or 8.9999999999999998e-26 < 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 KbT around inf 51.0%
if -2.09999999999999985e-191 < NaChar < 8.9999999999999998e-26Initial 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 71.9%
Taylor expanded in EAccept around 0 67.1%
Taylor expanded in mu around inf 50.2%
Final simplification50.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -2.3e+22) (not (<= NdChar 8.5e+16)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(* NaChar 0.5))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) 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 <= -2.3e+22) || !(NdChar <= 8.5e+16)) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - 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 <= (-2.3d+22)) .or. (.not. (ndchar <= 8.5d+16))) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - 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 <= -2.3e+22) || !(NdChar <= 8.5e+16)) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -2.3e+22) or not (NdChar <= 8.5e+16): tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -2.3e+22) || !(NdChar <= 8.5e+16)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - 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 <= -2.3e+22) || ~((NdChar <= 8.5e+16))) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -2.3e+22], N[Not[LessEqual[NdChar, 8.5e+16]], $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 * 0.5), $MachinePrecision]), $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 * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -2.3 \cdot 10^{+22} \lor \neg \left(NdChar \leq 8.5 \cdot 10^{+16}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NdChar < -2.3000000000000002e22 or 8.5e16 < 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 54.6%
*-commutative24.7%
Simplified54.6%
if -2.3000000000000002e22 < NdChar < 8.5e16Initial 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 56.7%
Final simplification55.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
(if (<= EDonor -2.8e-220)
(+ t_0 (/ NaChar (- 2.0 (/ mu KbT))))
(if (<= EDonor 7e+137)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
(+ t_0 (/ NaChar (+ (/ EAccept KbT) 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((EDonor / KbT)));
double tmp;
if (EDonor <= -2.8e-220) {
tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
} else if (EDonor <= 7e+137) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
} else {
tmp = t_0 + (NaChar / ((EAccept / KbT) + 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) :: tmp
t_0 = ndchar / (1.0d0 + exp((edonor / kbt)))
if (edonor <= (-2.8d-220)) then
tmp = t_0 + (nachar / (2.0d0 - (mu / kbt)))
else if (edonor <= 7d+137) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
else
tmp = t_0 + (nachar / ((eaccept / kbt) + 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((EDonor / KbT)));
double tmp;
if (EDonor <= -2.8e-220) {
tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
} else if (EDonor <= 7e+137) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
} else {
tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp((EDonor / KbT))) tmp = 0 if EDonor <= -2.8e-220: tmp = t_0 + (NaChar / (2.0 - (mu / KbT))) elif EDonor <= 7e+137: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) else: tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) tmp = 0.0 if (EDonor <= -2.8e-220) tmp = Float64(t_0 + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); elseif (EDonor <= 7e+137) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); else tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(EAccept / KbT) + 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((EDonor / KbT))); tmp = 0.0; if (EDonor <= -2.8e-220) tmp = t_0 + (NaChar / (2.0 - (mu / KbT))); elseif (EDonor <= 7e+137) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); else tmp = t_0 + (NaChar / ((EAccept / KbT) + 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[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -2.8e-220], N[(t$95$0 + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 7e+137], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{if}\;EDonor \leq -2.8 \cdot 10^{-220}:\\
\;\;\;\;t_0 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\mathbf{elif}\;EDonor \leq 7 \cdot 10^{+137}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\end{array}
\end{array}
if EDonor < -2.7999999999999999e-220Initial 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 EDonor around inf 72.1%
Taylor expanded in mu around inf 53.3%
associate-*r/53.3%
mul-1-neg53.3%
Simplified53.3%
Taylor expanded in mu around 0 45.3%
mul-1-neg45.3%
unsub-neg45.3%
Simplified45.3%
if -2.7999999999999999e-220 < EDonor < 7.0000000000000002e137Initial 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 64.3%
Taylor expanded in KbT around inf 37.8%
if 7.0000000000000002e137 < EDonor 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 78.1%
Taylor expanded in EAccept around 0 56.6%
Taylor expanded in EDonor around inf 56.7%
Final simplification42.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (<= Ev -6.2e+71) (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5)) (+ (/ 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 (Ev <= -6.2e+71) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
} 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 (ev <= (-6.2d+71)) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
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 (Ev <= -6.2e+71) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
} 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 Ev <= -6.2e+71: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) 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 (Ev <= -6.2e+71) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); 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 (Ev <= -6.2e+71) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); 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[Ev, -6.2e+71], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $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}\;Ev \leq -6.2 \cdot 10^{+71}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if Ev < -6.20000000000000036e71Initial 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 39.9%
Taylor expanded in Ev around inf 37.5%
if -6.20000000000000036e71 < Ev 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.0%
Taylor expanded in KbT around inf 38.0%
Final simplification37.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ 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) {
return (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 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 / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 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 / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5
\end{array}
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 65.0%
Taylor expanded in KbT around inf 35.0%
Final simplification35.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= Ev -8.2e+69)
(+ (* NdChar 0.5) (* NaChar 0.5))
(+
(*
NaChar
(/
1.0
(- (+ (/ Ev KbT) (+ (/ EAccept KbT) (+ (/ Vef KbT) 2.0))) (/ mu KbT))))
(/
NdChar
(- (+ (/ mu KbT) (+ 2.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ 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 (Ev <= -8.2e+69) {
tmp = (NdChar * 0.5) + (NaChar * 0.5);
} else {
tmp = (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (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 (ev <= (-8.2d+69)) then
tmp = (ndchar * 0.5d0) + (nachar * 0.5d0)
else
tmp = (nachar * (1.0d0 / (((ev / kbt) + ((eaccept / kbt) + ((vef / kbt) + 2.0d0))) - (mu / kbt)))) + (ndchar / (((mu / kbt) + (2.0d0 + ((vef / kbt) + (edonor / kbt)))) - (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 (Ev <= -8.2e+69) {
tmp = (NdChar * 0.5) + (NaChar * 0.5);
} else {
tmp = (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if Ev <= -8.2e+69: tmp = (NdChar * 0.5) + (NaChar * 0.5) else: tmp = (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (Ev <= -8.2e+69) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar * Float64(1.0 / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + 2.0))) - Float64(mu / KbT)))) + Float64(NdChar / Float64(Float64(Float64(mu / KbT) + Float64(2.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (Ev <= -8.2e+69) tmp = (NdChar * 0.5) + (NaChar * 0.5); else tmp = (NaChar * (1.0 / (((Ev / KbT) + ((EAccept / KbT) + ((Vef / KbT) + 2.0))) - (mu / KbT)))) + (NdChar / (((mu / KbT) + (2.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -8.2e+69], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar * N[(1.0 / N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(N[(mu / KbT), $MachinePrecision] + N[(2.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;Ev \leq -8.2 \cdot 10^{+69}:\\
\;\;\;\;NdChar \cdot 0.5 + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;NaChar \cdot \frac{1}{\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right)\right) - \frac{mu}{KbT}} + \frac{NdChar}{\left(\frac{mu}{KbT} + \left(2 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\
\end{array}
\end{array}
if Ev < -8.1999999999999998e69Initial 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 39.1%
Taylor expanded in KbT around inf 16.0%
*-commutative16.0%
Simplified16.0%
if -8.1999999999999998e69 < Ev 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%
div-inv100.0%
associate--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 57.2%
Taylor expanded in KbT around inf 31.0%
Final simplification28.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (* NdChar 0.5) (/ NaChar (+ (/ EAccept KbT) 2.0))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar * 0.5) + (NaChar / ((EAccept / KbT) + 2.0));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar * 0.5d0) + (nachar / ((eaccept / kbt) + 2.0d0))
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 * 0.5) + (NaChar / ((EAccept / KbT) + 2.0));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar * 0.5) + (NaChar / ((EAccept / KbT) + 2.0))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar * 0.5) + (NaChar / ((EAccept / KbT) + 2.0)); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
NdChar \cdot 0.5 + \frac{NaChar}{\frac{EAccept}{KbT} + 2}
\end{array}
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 65.0%
Taylor expanded in EAccept around 0 51.3%
Taylor expanded in KbT around inf 26.1%
Final simplification26.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (* NdChar 0.5) (* NaChar 0.5)))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar * 0.5) + (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 = (ndchar * 0.5d0) + (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 (NdChar * 0.5) + (NaChar * 0.5);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar * 0.5) + (NaChar * 0.5)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar * 0.5) + Float64(NaChar * 0.5)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar * 0.5) + (NaChar * 0.5); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
NdChar \cdot 0.5 + NaChar \cdot 0.5
\end{array}
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 45.0%
Taylor expanded in KbT around inf 26.6%
*-commutative26.6%
Simplified26.6%
Final simplification26.6%
herbie shell --seed 2023200
(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))))))