
(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 23 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 (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 (/ mu KbT))))
(/ NaChar (+ 1.0 (exp (- (/ mu KbT)))))))
(t_1
(+
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ Vef (+ mu EDonor)) KbT)))))))
(if (<= mu -2.9e+81)
t_0
(if (<= mu -7.5e-112)
t_1
(if (<= mu -3.3e-181)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ (/ EDonor KbT) 2.0)))
(if (<= mu -1.6e-266)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/
NaChar
(+
(+ (/ EAccept KbT) 2.0)
(* 0.5 (/ (* EAccept EAccept) (* KbT KbT))))))
(if (<= mu 1.7e+143) 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 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
double t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT))));
double tmp;
if (mu <= -2.9e+81) {
tmp = t_0;
} else if (mu <= -7.5e-112) {
tmp = t_1;
} else if (mu <= -3.3e-181) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
} else if (mu <= -1.6e-266) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (((EAccept / KbT) + 2.0) + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (mu <= 1.7e+143) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp(-(mu / kbt))))
t_1 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp(((vef + (mu + edonor)) / kbt))))
if (mu <= (-2.9d+81)) then
tmp = t_0
else if (mu <= (-7.5d-112)) then
tmp = t_1
else if (mu <= (-3.3d-181)) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
else if (mu <= (-1.6d-266)) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (((eaccept / kbt) + 2.0d0) + (0.5d0 * ((eaccept * eaccept) / (kbt * kbt)))))
else if (mu <= 1.7d+143) then
tmp = t_1
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((mu / KbT)))) + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
double t_1 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef + (mu + EDonor)) / KbT))));
double tmp;
if (mu <= -2.9e+81) {
tmp = t_0;
} else if (mu <= -7.5e-112) {
tmp = t_1;
} else if (mu <= -3.3e-181) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
} else if (mu <= -1.6e-266) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (((EAccept / KbT) + 2.0) + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (mu <= 1.7e+143) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp(-(mu / KbT)))) t_1 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp(((Vef + (mu + EDonor)) / KbT)))) tmp = 0 if mu <= -2.9e+81: tmp = t_0 elif mu <= -7.5e-112: tmp = t_1 elif mu <= -3.3e-181: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0)) elif mu <= -1.6e-266: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (((EAccept / KbT) + 2.0) + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))) elif mu <= 1.7e+143: tmp = t_1 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(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT)))))) t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu + EDonor)) / KbT))))) tmp = 0.0 if (mu <= -2.9e+81) tmp = t_0; elseif (mu <= -7.5e-112) tmp = t_1; elseif (mu <= -3.3e-181) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0))); elseif (mu <= -1.6e-266) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(Float64(Float64(EAccept / KbT) + 2.0) + Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT)))))); elseif (mu <= 1.7e+143) tmp = t_1; 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((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT)))); t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))); tmp = 0.0; if (mu <= -2.9e+81) tmp = t_0; elseif (mu <= -7.5e-112) tmp = t_1; elseif (mu <= -3.3e-181) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0)); elseif (mu <= -1.6e-266) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (((EAccept / KbT) + 2.0) + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))); elseif (mu <= 1.7e+143) tmp = t_1; 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[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.9e+81], t$95$0, If[LessEqual[mu, -7.5e-112], t$95$1, If[LessEqual[mu, -3.3e-181], 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[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -1.6e-266], 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[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision] + N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.7e+143], t$95$1, t$95$0]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu + EDonor\right)}{KbT}}}\\
\mathbf{if}\;mu \leq -2.9 \cdot 10^{+81}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;mu \leq -7.5 \cdot 10^{-112}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;mu \leq -3.3 \cdot 10^{-181}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\
\mathbf{elif}\;mu \leq -1.6 \cdot 10^{-266}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{\left(\frac{EAccept}{KbT} + 2\right) + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}}\\
\mathbf{elif}\;mu \leq 1.7 \cdot 10^{+143}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if mu < -2.9e81 or 1.69999999999999991e143 < mu 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 mu around inf 88.9%
Taylor expanded in mu around inf 83.2%
neg-mul-183.2%
distribute-neg-frac83.2%
Simplified83.2%
if -2.9e81 < mu < -7.5000000000000002e-112 or -1.6e-266 < mu < 1.69999999999999991e143Initial 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.5%
Taylor expanded in Ec around 0 66.9%
if -7.5000000000000002e-112 < mu < -3.30000000000000009e-181Initial 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 100.0%
Taylor expanded in EDonor around 0 79.2%
if -3.30000000000000009e-181 < mu < -1.6e-266Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 55.4%
Taylor expanded in EAccept around 0 60.0%
associate-+r+60.0%
+-commutative60.0%
unpow260.0%
unpow260.0%
Simplified60.0%
Final simplification72.3%
(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)))))))
(if (<= mu -1.45e+93)
t_1
(if (<= mu 1.6e-295)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= mu 3.2e-177)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ (/ EAccept KbT) 2.0)))
(if (<= mu 9.2e-20)
(+
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ Vef (+ mu EDonor)) KbT)))))
t_1))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
double tmp;
if (mu <= -1.45e+93) {
tmp = t_1;
} else if (mu <= 1.6e-295) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (mu <= 3.2e-177) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else if (mu <= 9.2e-20) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT))));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
if (mu <= (-1.45d+93)) then
tmp = t_1
else if (mu <= 1.6d-295) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (mu <= 3.2d-177) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
else if (mu <= 9.2d-20) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp(((vef + (mu + edonor)) / kbt))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
double tmp;
if (mu <= -1.45e+93) {
tmp = t_1;
} else if (mu <= 1.6e-295) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (mu <= 3.2e-177) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else if (mu <= 9.2e-20) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef + (mu + EDonor)) / KbT))));
} else {
tmp = t_1;
}
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)))) tmp = 0 if mu <= -1.45e+93: tmp = t_1 elif mu <= 1.6e-295: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif mu <= 3.2e-177: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) elif mu <= 9.2e-20: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp(((Vef + (mu + EDonor)) / KbT)))) else: tmp = t_1 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))))) tmp = 0.0 if (mu <= -1.45e+93) tmp = t_1; elseif (mu <= 1.6e-295) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (mu <= 3.2e-177) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))); elseif (mu <= 9.2e-20) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu + EDonor)) / KbT))))); else tmp = t_1; 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)))); tmp = 0.0; if (mu <= -1.45e+93) tmp = t_1; elseif (mu <= 1.6e-295) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (mu <= 3.2e-177) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)); elseif (mu <= 9.2e-20) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))); else tmp = t_1; 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]}, If[LessEqual[mu, -1.45e+93], t$95$1, If[LessEqual[mu, 1.6e-295], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3.2e-177], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 9.2e-20], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / 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], t$95$1]]]]]]
\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}}}\\
\mathbf{if}\;mu \leq -1.45 \cdot 10^{+93}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;mu \leq 1.6 \cdot 10^{-295}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;mu \leq 3.2 \cdot 10^{-177}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{elif}\;mu \leq 9.2 \cdot 10^{-20}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu + EDonor\right)}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if mu < -1.4499999999999999e93 or 9.1999999999999997e-20 < mu 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 mu around inf 85.5%
if -1.4499999999999999e93 < mu < 1.6e-295Initial 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%
if 1.6e-295 < mu < 3.1999999999999998e-177Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 70.5%
Taylor expanded in EAccept around 0 62.8%
if 3.1999999999999998e-177 < mu < 9.1999999999999997e-20Initial 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.5%
Taylor expanded in Ec around 0 68.9%
Final simplification78.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_2 (+ t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
(if (<= mu -1.55e+75)
t_2
(if (<= mu -5.5e-81)
t_0
(if (<= mu 1.4e-297)
(+ t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= mu 5.2e-20) t_0 t_2))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / (1.0 + exp((mu / KbT))));
double tmp;
if (mu <= -1.55e+75) {
tmp = t_2;
} else if (mu <= -5.5e-81) {
tmp = t_0;
} else if (mu <= 1.4e-297) {
tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (mu <= 5.2e-20) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_2 = t_1 + (ndchar / (1.0d0 + exp((mu / kbt))))
if (mu <= (-1.55d+75)) then
tmp = t_2
else if (mu <= (-5.5d-81)) then
tmp = t_0
else if (mu <= 1.4d-297) then
tmp = t_1 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (mu <= 5.2d-20) then
tmp = t_0
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / (1.0 + Math.exp((mu / KbT))));
double tmp;
if (mu <= -1.55e+75) {
tmp = t_2;
} else if (mu <= -5.5e-81) {
tmp = t_0;
} else if (mu <= 1.4e-297) {
tmp = t_1 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (mu <= 5.2e-20) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_2 = t_1 + (NdChar / (1.0 + math.exp((mu / KbT)))) tmp = 0 if mu <= -1.55e+75: tmp = t_2 elif mu <= -5.5e-81: tmp = t_0 elif mu <= 1.4e-297: tmp = t_1 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif mu <= 5.2e-20: tmp = t_0 else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_2 = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))) tmp = 0.0 if (mu <= -1.55e+75) tmp = t_2; elseif (mu <= -5.5e-81) tmp = t_0; elseif (mu <= 1.4e-297) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (mu <= 5.2e-20) tmp = t_0; else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT)))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_2 = t_1 + (NdChar / (1.0 + exp((mu / KbT)))); tmp = 0.0; if (mu <= -1.55e+75) tmp = t_2; elseif (mu <= -5.5e-81) tmp = t_0; elseif (mu <= 1.4e-297) tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (mu <= 5.2e-20) tmp = t_0; else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.55e+75], t$95$2, If[LessEqual[mu, -5.5e-81], t$95$0, If[LessEqual[mu, 1.4e-297], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 5.2e-20], t$95$0, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_2 := t_1 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{if}\;mu \leq -1.55 \cdot 10^{+75}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;mu \leq -5.5 \cdot 10^{-81}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;mu \leq 1.4 \cdot 10^{-297}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;mu \leq 5.2 \cdot 10^{-20}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if mu < -1.5500000000000001e75 or 5.1999999999999999e-20 < mu 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 mu around inf 85.1%
if -1.5500000000000001e75 < mu < -5.50000000000000026e-81 or 1.39999999999999992e-297 < mu < 5.1999999999999999e-20Initial 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 70.7%
if -5.50000000000000026e-81 < mu < 1.39999999999999992e-297Initial 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 82.9%
Final simplification80.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(/ NaChar (+ 1.0 (exp (- (/ mu KbT))))))))
(if (<= mu -1.2e+95)
t_0
(if (<= mu 1.6e-295)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= mu 1.8e-177)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ (/ EAccept KbT) 2.0)))
(if (<= mu 8.2e+133)
(+
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ Vef (+ mu EDonor)) KbT)))))
t_0))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT))));
double tmp;
if (mu <= -1.2e+95) {
tmp = t_0;
} else if (mu <= 1.6e-295) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (mu <= 1.8e-177) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else if (mu <= 8.2e+133) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp(-(mu / kbt))))
if (mu <= (-1.2d+95)) then
tmp = t_0
else if (mu <= 1.6d-295) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (mu <= 1.8d-177) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / ((eaccept / kbt) + 2.0d0))
else if (mu <= 8.2d+133) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp(((vef + (mu + edonor)) / kbt))))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
double tmp;
if (mu <= -1.2e+95) {
tmp = t_0;
} else if (mu <= 1.6e-295) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (mu <= 1.8e-177) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
} else if (mu <= 8.2e+133) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp(((Vef + (mu + EDonor)) / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp(-(mu / KbT)))) tmp = 0 if mu <= -1.2e+95: tmp = t_0 elif mu <= 1.6e-295: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif mu <= 1.8e-177: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) elif mu <= 8.2e+133: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp(((Vef + (mu + EDonor)) / KbT)))) 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(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT)))))) tmp = 0.0 if (mu <= -1.2e+95) tmp = t_0; elseif (mu <= 1.6e-295) 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))))); elseif (mu <= 1.8e-177) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))); elseif (mu <= 8.2e+133) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(mu + EDonor)) / KbT))))); 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((mu / KbT)))) + (NaChar / (1.0 + exp(-(mu / KbT)))); tmp = 0.0; if (mu <= -1.2e+95) tmp = t_0; elseif (mu <= 1.6e-295) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (mu <= 1.8e-177) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)); elseif (mu <= 8.2e+133) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))); else tmp = t_0; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.2e+95], t$95$0, If[LessEqual[mu, 1.6e-295], 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], If[LessEqual[mu, 1.8e-177], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 8.2e+133], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / 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], t$95$0]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\
\mathbf{if}\;mu \leq -1.2 \cdot 10^{+95}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;mu \leq 1.6 \cdot 10^{-295}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;mu \leq 1.8 \cdot 10^{-177}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{elif}\;mu \leq 8.2 \cdot 10^{+133}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef + \left(mu + EDonor\right)}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if mu < -1.2e95 or 8.20000000000000008e133 < mu 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 mu around inf 87.8%
Taylor expanded in mu around inf 80.8%
neg-mul-180.8%
distribute-neg-frac80.8%
Simplified80.8%
if -1.2e95 < mu < 1.6e-295Initial 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%
if 1.6e-295 < mu < 1.79999999999999991e-177Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 70.5%
Taylor expanded in EAccept around 0 62.8%
if 1.79999999999999991e-177 < mu < 8.20000000000000008e133Initial 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 76.1%
Taylor expanded in Ec around 0 75.8%
Final simplification76.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= EAccept 1.18e-116)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= EAccept 3.5e-20)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
(if (<= EAccept 9e+117)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= 1.18e-116) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (EAccept <= 3.5e-20) {
tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
} else if (EAccept <= 9e+117) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (eaccept <= 1.18d-116) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (eaccept <= 3.5d-20) then
tmp = t_0 + (nachar / (1.0d0 + exp((vef / kbt))))
else if (eaccept <= 9d+117) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= 1.18e-116) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (EAccept <= 3.5e-20) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
} else if (EAccept <= 9e+117) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if EAccept <= 1.18e-116: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif EAccept <= 3.5e-20: tmp = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT)))) elif EAccept <= 9e+117: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (EAccept <= 1.18e-116) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (EAccept <= 3.5e-20) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))); elseif (EAccept <= 9e+117) tmp = 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))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (EAccept <= 1.18e-116) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (EAccept <= 3.5e-20) tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT)))); elseif (EAccept <= 9e+117) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, 1.18e-116], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 3.5e-20], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 9e+117], 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], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;EAccept \leq 1.18 \cdot 10^{-116}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 3.5 \cdot 10^{-20}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 9 \cdot 10^{+117}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < 1.1800000000000001e-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 Ev around inf 78.7%
if 1.1800000000000001e-116 < EAccept < 3.50000000000000003e-20Initial 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 79.2%
if 3.50000000000000003e-20 < EAccept < 9e117Initial 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 67.0%
if 9e117 < 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 87.3%
Final simplification78.6%
(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 (<= Ev -1.6e+72)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= Ev -1.46e-251)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (Ev <= -1.6e+72) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (Ev <= -1.46e-251) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ev <= (-1.6d+72)) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (ev <= (-1.46d-251)) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (Ev <= -1.6e+72) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (Ev <= -1.46e-251) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if Ev <= -1.6e+72: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif Ev <= -1.46e-251: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (Ev <= -1.6e+72) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (Ev <= -1.46e-251) tmp = 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))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (Ev <= -1.6e+72) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (Ev <= -1.46e-251) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -1.6e+72], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -1.46e-251], 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], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;Ev \leq -1.6 \cdot 10^{+72}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;Ev \leq -1.46 \cdot 10^{-251}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if Ev < -1.6000000000000001e72Initial 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 Ev around inf 86.5%
if -1.6000000000000001e72 < Ev < -1.45999999999999997e-251Initial 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 69.5%
if -1.45999999999999997e-251 < 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 65.8%
Final simplification70.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -1.95e-17)
(and (not (<= NaChar 7.5e-104))
(or (<= NaChar 6.5e-72) (not (<= NaChar 5.8e+64)))))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ (/ EDonor KbT) 2.0)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) 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 <= -1.95e-17) || (!(NaChar <= 7.5e-104) && ((NaChar <= 6.5e-72) || !(NaChar <= 5.8e+64)))) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / 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 <= (-1.95d-17)) .or. (.not. (nachar <= 7.5d-104)) .and. (nachar <= 6.5d-72) .or. (.not. (nachar <= 5.8d+64))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / 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 <= -1.95e-17) || (!(NaChar <= 7.5e-104) && ((NaChar <= 6.5e-72) || !(NaChar <= 5.8e+64)))) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -1.95e-17) or (not (NaChar <= 7.5e-104) and ((NaChar <= 6.5e-72) or not (NaChar <= 5.8e+64))): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0)) else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -1.95e-17) || (!(NaChar <= 7.5e-104) && ((NaChar <= 6.5e-72) || !(NaChar <= 5.8e+64)))) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0))); else 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))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -1.95e-17) || (~((NaChar <= 7.5e-104)) && ((NaChar <= 6.5e-72) || ~((NaChar <= 5.8e+64))))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0)); else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / 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, -1.95e-17], And[N[Not[LessEqual[NaChar, 7.5e-104]], $MachinePrecision], Or[LessEqual[NaChar, 6.5e-72], N[Not[LessEqual[NaChar, 5.8e+64]], $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[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -1.95 \cdot 10^{-17} \lor \neg \left(NaChar \leq 7.5 \cdot 10^{-104}\right) \land \left(NaChar \leq 6.5 \cdot 10^{-72} \lor \neg \left(NaChar \leq 5.8 \cdot 10^{+64}\right)\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\end{array}
\end{array}
if NaChar < -1.94999999999999995e-17 or 7.5e-104 < NaChar < 6.4999999999999997e-72 or 5.79999999999999986e64 < 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 EDonor around inf 72.5%
Taylor expanded in EDonor around 0 66.0%
if -1.94999999999999995e-17 < NaChar < 7.5e-104 or 6.4999999999999997e-72 < NaChar < 5.79999999999999986e64Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 74.7%
Taylor expanded in EAccept around 0 67.6%
Final simplification66.8%
(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))))))
(if (<= NaChar -1.95e-17)
(+ t_1 (/ NdChar (+ (/ EDonor KbT) 2.0)))
(if (<= NaChar 2.45e-207)
(+ t_0 (/ NaChar (+ (/ EAccept KbT) 2.0)))
(if (<= NaChar 7e+73)
(+ t_0 (/ NaChar (- 1.0 (/ mu KbT))))
(+ t_1 (/ NdChar (+ 1.0 (+ 1.0 (/ 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 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -1.95e-17) {
tmp = t_1 + (NdChar / ((EDonor / KbT) + 2.0));
} else if (NaChar <= 2.45e-207) {
tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
} else if (NaChar <= 7e+73) {
tmp = t_0 + (NaChar / (1.0 - (mu / KbT)));
} else {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (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 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-1.95d-17)) then
tmp = t_1 + (ndchar / ((edonor / kbt) + 2.0d0))
else if (nachar <= 2.45d-207) then
tmp = t_0 + (nachar / ((eaccept / kbt) + 2.0d0))
else if (nachar <= 7d+73) then
tmp = t_0 + (nachar / (1.0d0 - (mu / kbt)))
else
tmp = t_1 + (ndchar / (1.0d0 + (1.0d0 + (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 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -1.95e-17) {
tmp = t_1 + (NdChar / ((EDonor / KbT) + 2.0));
} else if (NaChar <= 2.45e-207) {
tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
} else if (NaChar <= 7e+73) {
tmp = t_0 + (NaChar / (1.0 - (mu / KbT)));
} else {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (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 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if NaChar <= -1.95e-17: tmp = t_1 + (NdChar / ((EDonor / KbT) + 2.0)) elif NaChar <= 2.45e-207: tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0)) elif NaChar <= 7e+73: tmp = t_0 + (NaChar / (1.0 - (mu / KbT))) else: tmp = t_1 + (NdChar / (1.0 + (1.0 + (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(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (NaChar <= -1.95e-17) tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0))); elseif (NaChar <= 2.45e-207) tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))); elseif (NaChar <= 7e+73) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 - Float64(mu / KbT)))); else tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(1.0 + 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 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -1.95e-17) tmp = t_1 + (NdChar / ((EDonor / KbT) + 2.0)); elseif (NaChar <= 2.45e-207) tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0)); elseif (NaChar <= 7e+73) tmp = t_0 + (NaChar / (1.0 - (mu / KbT))); else tmp = t_1 + (NdChar / (1.0 + (1.0 + (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[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.95e-17], N[(t$95$1 + N[(NdChar / N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.45e-207], N[(t$95$0 + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 7e+73], N[(t$95$0 + N[(NaChar / N[(1.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(1.0 + 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 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -1.95 \cdot 10^{-17}:\\
\;\;\;\;t_1 + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\
\mathbf{elif}\;NaChar \leq 2.45 \cdot 10^{-207}:\\
\;\;\;\;t_0 + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{elif}\;NaChar \leq 7 \cdot 10^{+73}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 - \frac{mu}{KbT}}\\
\mathbf{else}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \left(1 + \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NaChar < -1.94999999999999995e-17Initial 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.2%
Taylor expanded in EDonor around 0 71.8%
if -1.94999999999999995e-17 < NaChar < 2.45e-207Initial 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.0%
Taylor expanded in EAccept around 0 74.7%
if 2.45e-207 < NaChar < 7.00000000000000004e73Initial 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 52.7%
Taylor expanded in mu around inf 61.1%
neg-mul-161.1%
distribute-neg-frac61.1%
Simplified61.1%
if 7.00000000000000004e73 < 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 mu around inf 76.5%
Taylor expanded in mu around 0 62.5%
Final simplification68.3%
(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))))
(/ NdChar (+ (/ EDonor KbT) 2.0)))))
(if (<= NaChar -4.8e-17)
t_1
(if (<= NaChar 1.15e-207)
(+ t_0 (/ NaChar (+ (/ EAccept KbT) 2.0)))
(if (<= NaChar 1.5e+75) (+ t_0 (/ NaChar (- 1.0 (/ mu KbT)))) t_1)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
double tmp;
if (NaChar <= -4.8e-17) {
tmp = t_1;
} else if (NaChar <= 1.15e-207) {
tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
} else if (NaChar <= 1.5e+75) {
tmp = t_0 + (NaChar / (1.0 - (mu / KbT)));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_1 = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / ((edonor / kbt) + 2.0d0))
if (nachar <= (-4.8d-17)) then
tmp = t_1
else if (nachar <= 1.15d-207) then
tmp = t_0 + (nachar / ((eaccept / kbt) + 2.0d0))
else if (nachar <= 1.5d+75) then
tmp = t_0 + (nachar / (1.0d0 - (mu / kbt)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((EDonor / KbT) + 2.0));
double tmp;
if (NaChar <= -4.8e-17) {
tmp = t_1;
} else if (NaChar <= 1.15e-207) {
tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0));
} else if (NaChar <= 1.5e+75) {
tmp = t_0 + (NaChar / (1.0 - (mu / KbT)));
} else {
tmp = t_1;
}
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)))) + (NdChar / ((EDonor / KbT) + 2.0)) tmp = 0 if NaChar <= -4.8e-17: tmp = t_1 elif NaChar <= 1.15e-207: tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0)) elif NaChar <= 1.5e+75: tmp = t_0 + (NaChar / (1.0 - (mu / KbT))) else: tmp = t_1 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(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(Float64(EDonor / KbT) + 2.0))) tmp = 0.0 if (NaChar <= -4.8e-17) tmp = t_1; elseif (NaChar <= 1.15e-207) tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(EAccept / KbT) + 2.0))); elseif (NaChar <= 1.5e+75) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 - Float64(mu / KbT)))); else tmp = t_1; 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)))) + (NdChar / ((EDonor / KbT) + 2.0)); tmp = 0.0; if (NaChar <= -4.8e-17) tmp = t_1; elseif (NaChar <= 1.15e-207) tmp = t_0 + (NaChar / ((EAccept / KbT) + 2.0)); elseif (NaChar <= 1.5e+75) tmp = t_0 + (NaChar / (1.0 - (mu / KbT))); else tmp = t_1; 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[(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[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -4.8e-17], t$95$1, If[LessEqual[NaChar, 1.15e-207], N[(t$95$0 + N[(NaChar / N[(N[(EAccept / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.5e+75], N[(t$95$0 + N[(NaChar / N[(1.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\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}}} + \frac{NdChar}{\frac{EDonor}{KbT} + 2}\\
\mathbf{if}\;NaChar \leq -4.8 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NaChar \leq 1.15 \cdot 10^{-207}:\\
\;\;\;\;t_0 + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\mathbf{elif}\;NaChar \leq 1.5 \cdot 10^{+75}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 - \frac{mu}{KbT}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if NaChar < -4.79999999999999973e-17 or 1.5e75 < 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 EDonor around inf 72.5%
Taylor expanded in EDonor around 0 66.1%
if -4.79999999999999973e-17 < NaChar < 1.15e-207Initial 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.0%
Taylor expanded in EAccept around 0 74.7%
if 1.15e-207 < NaChar < 1.5e75Initial 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 52.7%
Taylor expanded in mu around inf 61.1%
neg-mul-161.1%
distribute-neg-frac61.1%
Simplified61.1%
Final simplification67.5%
(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 2.0)))
(t_2
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))))
(if (<= NaChar -3.8e-17)
t_2
(if (<= NaChar -2.9e-303)
t_1
(if (<= NaChar 3.3e-186)
(+ t_0 (/ (* KbT NaChar) EAccept))
(if (<= NaChar 4.6e+62) 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 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = t_0 + (NaChar / 2.0);
double t_2 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
double tmp;
if (NaChar <= -3.8e-17) {
tmp = t_2;
} else if (NaChar <= -2.9e-303) {
tmp = t_1;
} else if (NaChar <= 3.3e-186) {
tmp = t_0 + ((KbT * NaChar) / EAccept);
} else if (NaChar <= 4.6e+62) {
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 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_1 = t_0 + (nachar / 2.0d0)
t_2 = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
if (nachar <= (-3.8d-17)) then
tmp = t_2
else if (nachar <= (-2.9d-303)) then
tmp = t_1
else if (nachar <= 3.3d-186) then
tmp = t_0 + ((kbt * nachar) / eaccept)
else if (nachar <= 4.6d+62) 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 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = t_0 + (NaChar / 2.0);
double t_2 = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
double tmp;
if (NaChar <= -3.8e-17) {
tmp = t_2;
} else if (NaChar <= -2.9e-303) {
tmp = t_1;
} else if (NaChar <= 3.3e-186) {
tmp = t_0 + ((KbT * NaChar) / EAccept);
} else if (NaChar <= 4.6e+62) {
tmp = t_1;
} else {
tmp = t_2;
}
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 / 2.0) t_2 = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) tmp = 0 if NaChar <= -3.8e-17: tmp = t_2 elif NaChar <= -2.9e-303: tmp = t_1 elif NaChar <= 3.3e-186: tmp = t_0 + ((KbT * NaChar) / EAccept) elif NaChar <= 4.6e+62: tmp = t_1 else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_1 = Float64(t_0 + Float64(NaChar / 2.0)) t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar * 0.5)) tmp = 0.0 if (NaChar <= -3.8e-17) tmp = t_2; elseif (NaChar <= -2.9e-303) tmp = t_1; elseif (NaChar <= 3.3e-186) tmp = Float64(t_0 + Float64(Float64(KbT * NaChar) / EAccept)); elseif (NaChar <= 4.6e+62) 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 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_1 = t_0 + (NaChar / 2.0); t_2 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); tmp = 0.0; if (NaChar <= -3.8e-17) tmp = t_2; elseif (NaChar <= -2.9e-303) tmp = t_1; elseif (NaChar <= 3.3e-186) tmp = t_0 + ((KbT * NaChar) / EAccept); elseif (NaChar <= 4.6e+62) 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[(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 / 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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]}, If[LessEqual[NaChar, -3.8e-17], t$95$2, If[LessEqual[NaChar, -2.9e-303], t$95$1, If[LessEqual[NaChar, 3.3e-186], N[(t$95$0 + N[(N[(KbT * NaChar), $MachinePrecision] / EAccept), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 4.6e+62], t$95$1, t$95$2]]]]]]]
\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 + \frac{NaChar}{2}\\
t_2 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{if}\;NaChar \leq -3.8 \cdot 10^{-17}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;NaChar \leq -2.9 \cdot 10^{-303}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NaChar \leq 3.3 \cdot 10^{-186}:\\
\;\;\;\;t_0 + \frac{KbT \cdot NaChar}{EAccept}\\
\mathbf{elif}\;NaChar \leq 4.6 \cdot 10^{+62}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if NaChar < -3.8000000000000001e-17 or 4.59999999999999968e62 < 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 56.7%
if -3.8000000000000001e-17 < NaChar < -2.90000000000000014e-303 or 3.29999999999999999e-186 < NaChar < 4.59999999999999968e62Initial 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 62.9%
if -2.90000000000000014e-303 < NaChar < 3.29999999999999999e-186Initial 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.8%
Taylor expanded in EAccept around inf 66.9%
Final simplification60.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -5.3e-17) (not (<= NaChar 3.5e+61)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) 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 <= -5.3e-17) || !(NaChar <= 3.5e+61)) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / 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 <= (-5.3d-17)) .or. (.not. (nachar <= 3.5d+61))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / 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 <= -5.3e-17) || !(NaChar <= 3.5e+61)) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -5.3e-17) or not (NaChar <= 3.5e+61): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / ((EAccept / KbT) + 2.0)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -5.3e-17) || !(NaChar <= 3.5e+61)) 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(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / 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 <= -5.3e-17) || ~((NaChar <= 3.5e+61))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / 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, -5.3e-17], N[Not[LessEqual[NaChar, 3.5e+61]], $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[(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]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -5.3 \cdot 10^{-17} \lor \neg \left(NaChar \leq 3.5 \cdot 10^{+61}\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 + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{\frac{EAccept}{KbT} + 2}\\
\end{array}
\end{array}
if NaChar < -5.2999999999999998e-17 or 3.50000000000000018e61 < 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 56.7%
if -5.2999999999999998e-17 < NaChar < 3.50000000000000018e61Initial 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 73.0%
Taylor expanded in EAccept around 0 64.9%
Final simplification60.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(* NdChar 0.5)
(/ NaChar (+ 1.0 (exp (/ (- (+ Ev EAccept) mu) KbT)))))))
(if (<= NaChar -9.5e-10)
t_0
(if (<= NaChar -3.4e-177)
(+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
(if (<= NaChar 5.2e-61)
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ (/ Ev KbT) 2.0)))
t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar * 0.5) + (NaChar / (1.0 + exp((((Ev + EAccept) - mu) / KbT))));
double tmp;
if (NaChar <= -9.5e-10) {
tmp = t_0;
} else if (NaChar <= -3.4e-177) {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT))));
} else if (NaChar <= 5.2e-61) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
} 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 * 0.5d0) + (nachar / (1.0d0 + exp((((ev + eaccept) - mu) / kbt))))
if (nachar <= (-9.5d-10)) then
tmp = t_0
else if (nachar <= (-3.4d-177)) then
tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + exp((-ec / kbt))))
else if (nachar <= 5.2d-61) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / ((ev / kbt) + 2.0d0))
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 * 0.5) + (NaChar / (1.0 + Math.exp((((Ev + EAccept) - mu) / KbT))));
double tmp;
if (NaChar <= -9.5e-10) {
tmp = t_0;
} else if (NaChar <= -3.4e-177) {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
} else if (NaChar <= 5.2e-61) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((((Ev + EAccept) - mu) / KbT)))) tmp = 0 if NaChar <= -9.5e-10: tmp = t_0 elif NaChar <= -3.4e-177: tmp = (NaChar / 2.0) + (NdChar / (1.0 + math.exp((-Ec / KbT)))) elif NaChar <= 5.2e-61: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / ((Ev / KbT) + 2.0)) else: tmp = t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Ev + EAccept) - mu) / KbT))))) tmp = 0.0 if (NaChar <= -9.5e-10) tmp = t_0; elseif (NaChar <= -3.4e-177) tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))); elseif (NaChar <= 5.2e-61) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0))); else tmp = t_0; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar * 0.5) + (NaChar / (1.0 + exp((((Ev + EAccept) - mu) / KbT)))); tmp = 0.0; if (NaChar <= -9.5e-10) tmp = t_0; elseif (NaChar <= -3.4e-177) tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT)))); elseif (NaChar <= 5.2e-61) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((Ev / KbT) + 2.0)); 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 * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -9.5e-10], t$95$0, If[LessEqual[NaChar, -3.4e-177], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 5.2e-61], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{\left(Ev + EAccept\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -9.5 \cdot 10^{-10}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq -3.4 \cdot 10^{-177}:\\
\;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
\mathbf{elif}\;NaChar \leq 5.2 \cdot 10^{-61}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if NaChar < -9.50000000000000028e-10 or 5.20000000000000021e-61 < 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 53.9%
Taylor expanded in Vef around 0 51.8%
if -9.50000000000000028e-10 < NaChar < -3.4000000000000001e-177Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 69.5%
Taylor expanded in Ec around inf 58.4%
associate-*r/58.4%
mul-1-neg58.4%
Simplified58.4%
if -3.4000000000000001e-177 < NaChar < 5.20000000000000021e-61Initial 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.9%
Taylor expanded in Ev around inf 52.3%
Taylor expanded in Ev around 0 44.0%
Final simplification50.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -1.95e-17) (not (<= NaChar 1.65e+65)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))
(+ (/ NdChar (+ 1.0 (exp (/ (+ Vef (+ mu EDonor)) KbT)))) (/ NaChar 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 <= -1.95e-17) || !(NaChar <= 1.65e+65)) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))) + (NaChar / 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 <= (-1.95d-17)) .or. (.not. (nachar <= 1.65d+65))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
else
tmp = (ndchar / (1.0d0 + exp(((vef + (mu + edonor)) / kbt)))) + (nachar / 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 <= -1.95e-17) || !(NaChar <= 1.65e+65)) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + Math.exp(((Vef + (mu + EDonor)) / KbT)))) + (NaChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -1.95e-17) or not (NaChar <= 1.65e+65): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) else: tmp = (NdChar / (1.0 + math.exp(((Vef + (mu + EDonor)) / KbT)))) + (NaChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -1.95e-17) || !(NaChar <= 1.65e+65)) 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(Float64(Vef + Float64(mu + EDonor)) / KbT)))) + Float64(NaChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -1.95e-17) || ~((NaChar <= 1.65e+65))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); else tmp = (NdChar / (1.0 + exp(((Vef + (mu + EDonor)) / KbT)))) + (NaChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.95e-17], N[Not[LessEqual[NaChar, 1.65e+65]], $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[(N[(Vef + N[(mu + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -1.95 \cdot 10^{-17} \lor \neg \left(NaChar \leq 1.65 \cdot 10^{+65}\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{Vef + \left(mu + EDonor\right)}{KbT}}} + \frac{NaChar}{2}\\
\end{array}
\end{array}
if NaChar < -1.94999999999999995e-17 or 1.65000000000000012e65 < 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 56.7%
if -1.94999999999999995e-17 < NaChar < 1.65000000000000012e65Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.3%
Taylor expanded in Ec around 0 54.8%
Final simplification55.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -3e-17) (not (<= NaChar 2.6e+62)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar 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 <= -3e-17) || !(NaChar <= 2.6e+62)) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 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 <= (-3d-17)) .or. (.not. (nachar <= 2.6d+62))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / 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 <= -3e-17) || !(NaChar <= 2.6e+62)) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -3e-17) or not (NaChar <= 2.6e+62): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -3e-17) || !(NaChar <= 2.6e+62)) 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(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -3e-17) || ~((NaChar <= 2.6e+62))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -3e-17], N[Not[LessEqual[NaChar, 2.6e+62]], $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[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -3 \cdot 10^{-17} \lor \neg \left(NaChar \leq 2.6 \cdot 10^{+62}\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 + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{2}\\
\end{array}
\end{array}
if NaChar < -3.00000000000000006e-17 or 2.59999999999999984e62 < 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 56.7%
if -3.00000000000000006e-17 < NaChar < 2.59999999999999984e62Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.3%
Final simplification58.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NdChar 3.2e+164)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))
(+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar (+ (/ Ev 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 (NdChar <= 3.2e+164) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((Ev / 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 (ndchar <= 3.2d+164) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
else
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / ((ev / 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 (NdChar <= 3.2e+164) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NdChar <= 3.2e+164: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) else: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / ((Ev / KbT) + 2.0)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NdChar <= 3.2e+164) 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(EDonor / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NdChar <= 3.2e+164) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); else tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / ((Ev / KbT) + 2.0)); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, 3.2e+164], 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[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq 3.2 \cdot 10^{+164}:\\
\;\;\;\;\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{EDonor}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\
\end{array}
\end{array}
if NdChar < 3.1999999999999998e164Initial 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 48.2%
if 3.1999999999999998e164 < 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 EDonor around inf 53.2%
Taylor expanded in Ev around inf 51.2%
Taylor expanded in Ev around 0 45.9%
Final simplification47.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (<= NdChar 2.1e+75) (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ (- (+ Ev EAccept) mu) KbT))))) (+ (/ NaChar 2.0) (/ 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 tmp;
if (NdChar <= 2.1e+75) {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((((Ev + EAccept) - mu) / KbT))));
} else {
tmp = (NaChar / 2.0) + (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) :: tmp
if (ndchar <= 2.1d+75) then
tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((((ev + eaccept) - mu) / kbt))))
else
tmp = (nachar / 2.0d0) + (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 tmp;
if (NdChar <= 2.1e+75) {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((((Ev + EAccept) - mu) / KbT))));
} else {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NdChar <= 2.1e+75: tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((((Ev + EAccept) - mu) / KbT)))) else: tmp = (NaChar / 2.0) + (NdChar / (1.0 + math.exp((-Ec / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NdChar <= 2.1e+75) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Ev + EAccept) - mu) / KbT))))); else tmp = Float64(Float64(NaChar / 2.0) + 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) tmp = 0.0; if (NdChar <= 2.1e+75) tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((((Ev + EAccept) - mu) / KbT)))); else tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, 2.1e+75], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq 2.1 \cdot 10^{+75}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{\left(Ev + EAccept\right) - mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
\end{array}
\end{array}
if NdChar < 2.09999999999999999e75Initial 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 48.9%
Taylor expanded in Vef around 0 46.6%
if 2.09999999999999999e75 < 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 61.6%
Taylor expanded in Ec around inf 43.7%
associate-*r/43.7%
mul-1-neg43.7%
Simplified43.7%
Final simplification45.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NaChar -1.9e+18)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
(if (<= NaChar 2.95e-33)
(+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -1.9e+18) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
} else if (NaChar <= 2.95e-33) {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT))));
} else {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (nachar <= (-1.9d+18)) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
else if (nachar <= 2.95d-33) then
tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + exp((-ec / kbt))))
else
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -1.9e+18) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
} else if (NaChar <= 2.95e-33) {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NaChar <= -1.9e+18: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) elif NaChar <= 2.95e-33: tmp = (NaChar / 2.0) + (NdChar / (1.0 + math.exp((-Ec / KbT)))) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NaChar <= -1.9e+18) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); elseif (NaChar <= 2.95e-33) tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NaChar <= -1.9e+18) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); elseif (NaChar <= 2.95e-33) tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT)))); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -1.9e+18], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.95e-33], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -1.9 \cdot 10^{+18}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{elif}\;NaChar \leq 2.95 \cdot 10^{-33}:\\
\;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NaChar < -1.9e18Initial 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.6%
Taylor expanded in EAccept around inf 39.1%
if -1.9e18 < NaChar < 2.94999999999999993e-33Initial 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 59.9%
Taylor expanded in Ec around inf 41.9%
associate-*r/41.9%
mul-1-neg41.9%
Simplified41.9%
if 2.94999999999999993e-33 < 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.7%
Taylor expanded in Ev around inf 44.4%
Final simplification41.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NaChar -2.6e+17)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
(if (<= NaChar 7e-33)
(+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar 2.0))
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -2.6e+17) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
} else if (NaChar <= 7e-33) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
} else {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (nachar <= (-2.6d+17)) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
else if (nachar <= 7d-33) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / 2.0d0)
else
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -2.6e+17) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
} else if (NaChar <= 7e-33) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / 2.0);
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NaChar <= -2.6e+17: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) elif NaChar <= 7e-33: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / 2.0) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NaChar <= -2.6e+17) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); elseif (NaChar <= 7e-33) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / 2.0)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NaChar <= -2.6e+17) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); elseif (NaChar <= 7e-33) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -2.6e+17], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 7e-33], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -2.6 \cdot 10^{+17}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{elif}\;NaChar \leq 7 \cdot 10^{-33}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NaChar < -2.6e17Initial 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.6%
Taylor expanded in EAccept around inf 39.1%
if -2.6e17 < NaChar < 6.9999999999999997e-33Initial 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 64.1%
Taylor expanded in KbT around inf 38.1%
if 6.9999999999999997e-33 < 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 52.4%
Taylor expanded in Ev around inf 45.0%
Final simplification40.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NaChar -9.2e+17)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
(if (<= NaChar 1.06e-15)
(+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0))
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -9.2e+17) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
} else if (NaChar <= 1.06e-15) {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
} else {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (nachar <= (-9.2d+17)) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
else if (nachar <= 1.06d-15) then
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / 2.0d0)
else
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -9.2e+17) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
} else if (NaChar <= 1.06e-15) {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 2.0);
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NaChar <= -9.2e+17: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) elif NaChar <= 1.06e-15: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 2.0) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NaChar <= -9.2e+17) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); elseif (NaChar <= 1.06e-15) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / 2.0)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NaChar <= -9.2e+17) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); elseif (NaChar <= 1.06e-15) tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -9.2e+17], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.06e-15], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -9.2 \cdot 10^{+17}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{elif}\;NaChar \leq 1.06 \cdot 10^{-15}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NaChar < -9.2e17Initial 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.6%
Taylor expanded in EAccept around inf 39.1%
if -9.2e17 < NaChar < 1.06000000000000007e-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 mu around inf 65.8%
Taylor expanded in KbT around inf 40.3%
if 1.06000000000000007e-15 < 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 54.2%
Taylor expanded in Ev around inf 46.5%
Final simplification41.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (<= KbT 1.15e-219) (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5)) (+ (/ NaChar (+ 1.0 (exp (/ Ev 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 (KbT <= 1.15e-219) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((Ev / 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 (kbt <= 1.15d-219) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((ev / 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 (KbT <= 1.15e-219) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= 1.15e-219: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= 1.15e-219) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / 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 (KbT <= 1.15e-219) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, 1.15e-219], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq 1.15 \cdot 10^{-219}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if KbT < 1.14999999999999994e-219Initial 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 43.0%
Taylor expanded in EAccept around inf 31.5%
if 1.14999999999999994e-219 < 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 50.0%
Taylor expanded in Ev around inf 42.9%
Final simplification36.5%
(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 KbT around inf 46.0%
Taylor expanded in EAccept around inf 32.7%
Final simplification32.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (* NdChar 0.5) (/ NaChar 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 / 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 / 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 / 2.0);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar * 0.5) + (NaChar / 2.0)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar * 0.5) + Float64(NaChar / 2.0)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar * 0.5) + (NaChar / 2.0); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
NdChar \cdot 0.5 + \frac{NaChar}{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 KbT around inf 46.0%
Taylor expanded in KbT around inf 26.9%
Final simplification26.9%
herbie shell --seed 2023192
(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))))))