
(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 27 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
(let* ((t_0 (pow E (/ (/ (+ (- mu Ec) (+ Vef EDonor)) KbT) 2.0))))
(+
(/ NdChar (+ 1.0 (* t_0 t_0)))
(/ 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) {
double t_0 = pow(((double) M_E), ((((mu - Ec) + (Vef + EDonor)) / KbT) / 2.0));
return (NdChar / (1.0 + (t_0 * t_0))) + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = Math.pow(Math.E, ((((mu - Ec) + (Vef + EDonor)) / KbT) / 2.0));
return (NdChar / (1.0 + (t_0 * t_0))) + (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = math.pow(math.e, ((((mu - Ec) + (Vef + EDonor)) / KbT) / 2.0)) return (NdChar / (1.0 + (t_0 * t_0))) + (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = exp(1) ^ Float64(Float64(Float64(Float64(mu - Ec) + Float64(Vef + EDonor)) / KbT) / 2.0) return Float64(Float64(NdChar / Float64(1.0 + Float64(t_0 * t_0))) + 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) t_0 = 2.71828182845904523536 ^ ((((mu - Ec) + (Vef + EDonor)) / KbT) / 2.0); tmp = (NdChar / (1.0 + (t_0 * t_0))) + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[Power[E, N[(N[(N[(N[(mu - Ec), $MachinePrecision] + N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]}, N[(N[(NdChar / N[(1.0 + N[(t$95$0 * t$95$0), $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}
\\
\begin{array}{l}
t_0 := {e}^{\left(\frac{\frac{\left(mu - Ec\right) + \left(Vef + EDonor\right)}{KbT}}{2}\right)}\\
\frac{NdChar}{1 + t_0 \cdot t_0} + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}
\end{array}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
*-un-lft-identity99.9%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
sqr-pow100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (+ (- mu Ec) (+ Vef EDonor))))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/
NdChar
(+ 1.0 (* (pow E (/ (/ t_0 KbT) 2.0)) (exp (/ t_0 (* KbT 2.0)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (mu - Ec) + (Vef + EDonor);
return (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (pow(((double) M_E), ((t_0 / KbT) / 2.0)) * exp((t_0 / (KbT * 2.0))))));
}
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 = (mu - Ec) + (Vef + EDonor);
return (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (Math.pow(Math.E, ((t_0 / KbT) / 2.0)) * Math.exp((t_0 / (KbT * 2.0))))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (mu - Ec) + (Vef + EDonor) return (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (math.pow(math.e, ((t_0 / KbT) / 2.0)) * math.exp((t_0 / (KbT * 2.0))))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(mu - Ec) + Float64(Vef + EDonor)) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64((exp(1) ^ Float64(Float64(t_0 / KbT) / 2.0)) * exp(Float64(t_0 / Float64(KbT * 2.0))))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (mu - Ec) + (Vef + EDonor); tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + ((2.71828182845904523536 ^ ((t_0 / KbT) / 2.0)) * exp((t_0 / (KbT * 2.0)))))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(mu - Ec), $MachinePrecision] + N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]}, N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(N[Power[E, N[(N[(t$95$0 / KbT), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision] * N[Exp[N[(t$95$0 / N[(KbT * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(mu - Ec\right) + \left(Vef + EDonor\right)\\
\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + {e}^{\left(\frac{\frac{t_0}{KbT}}{2}\right)} \cdot e^{\frac{t_0}{KbT \cdot 2}}}
\end{array}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
*-un-lft-identity99.9%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
sqr-pow100.0%
Applied egg-rr100.0%
pow-to-exp100.0%
e-exp-1100.0%
add-log-exp100.0%
*-un-lft-identity100.0%
associate-/l/100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))) (/ NdChar (+ 1.0 (pow E (/ (+ (- mu Ec) (+ Vef EDonor)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + pow(((double) M_E), (((mu - Ec) + (Vef + EDonor)) / KbT))));
}
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.pow(Math.E, (((mu - Ec) + (Vef + EDonor)) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.pow(math.e, (((mu - Ec) + (Vef + EDonor)) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + (exp(1) ^ Float64(Float64(Float64(mu - Ec) + Float64(Vef + EDonor)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (2.71828182845904523536 ^ (((mu - Ec) + (Vef + EDonor)) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Power[E, N[(N[(N[(mu - Ec), $MachinePrecision] + N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + {e}^{\left(\frac{\left(mu - Ec\right) + \left(Vef + EDonor\right)}{KbT}\right)}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
*-un-lft-identity99.9%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
(if (<= NdChar -2e+135)
(+
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
(if (<= NdChar -2.3e-216)
t_1
(if (<= NdChar 1.8e-187)
(+
t_0
(/ NdChar (+ 1.0 (+ 1.0 (/ (+ (+ mu Vef) (- EDonor Ec)) KbT)))))
(if (<= NdChar 1.4e+183)
t_1
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (- (/ Ev KbT) (/ mu KbT)))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
double tmp;
if (NdChar <= -2e+135) {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
} else if (NdChar <= -2.3e-216) {
tmp = t_1;
} else if (NdChar <= 1.8e-187) {
tmp = t_0 + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
} else if (NdChar <= 1.4e+183) {
tmp = t_1;
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
if (ndchar <= (-2d+135)) then
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
else if (ndchar <= (-2.3d-216)) then
tmp = t_1
else if (ndchar <= 1.8d-187) then
tmp = t_0 + (ndchar / (1.0d0 + (1.0d0 + (((mu + vef) + (edonor - ec)) / kbt))))
else if (ndchar <= 1.4d+183) then
tmp = t_1
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + ((ev / kbt) - (mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
double tmp;
if (NdChar <= -2e+135) {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
} else if (NdChar <= -2.3e-216) {
tmp = t_1;
} else if (NdChar <= 1.8e-187) {
tmp = t_0 + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
} else if (NdChar <= 1.4e+183) {
tmp = t_1;
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
}
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((EDonor / KbT)))) tmp = 0 if NdChar <= -2e+135: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT)))) elif NdChar <= -2.3e-216: tmp = t_1 elif NdChar <= 1.8e-187: tmp = t_0 + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))) elif NdChar <= 1.4e+183: tmp = t_1 else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))) 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(EDonor / KbT))))) tmp = 0.0 if (NdChar <= -2e+135) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))); elseif (NdChar <= -2.3e-216) tmp = t_1; elseif (NdChar <= 1.8e-187) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(mu + Vef) + Float64(EDonor - Ec)) / KbT))))); elseif (NdChar <= 1.4e+183) tmp = t_1; else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Ev / KbT) - Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); tmp = 0.0; if (NdChar <= -2e+135) tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT)))); elseif (NdChar <= -2.3e-216) tmp = t_1; elseif (NdChar <= 1.8e-187) tmp = t_0 + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))); elseif (NdChar <= 1.4e+183) tmp = t_1; else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(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[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -2e+135], 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[NdChar, -2.3e-216], t$95$1, If[LessEqual[NdChar, 1.8e-187], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(1.0 + N[(N[(N[(mu + Vef), $MachinePrecision] + N[(EDonor - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.4e+183], t$95$1, N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(Ev / KbT), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{if}\;NdChar \leq -2 \cdot 10^{+135}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{elif}\;NdChar \leq -2.3 \cdot 10^{-216}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NdChar \leq 1.8 \cdot 10^{-187}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + \left(1 + \frac{\left(mu + Vef\right) + \left(EDonor - Ec\right)}{KbT}\right)}\\
\mathbf{elif}\;NdChar \leq 1.4 \cdot 10^{+183}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(\frac{Ev}{KbT} - \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NdChar < -1.99999999999999992e135Initial 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.7%
Taylor expanded in mu around inf 70.7%
neg-mul-170.7%
distribute-neg-frac70.7%
Simplified70.7%
if -1.99999999999999992e135 < NdChar < -2.29999999999999997e-216 or 1.79999999999999997e-187 < NdChar < 1.40000000000000009e183Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EDonor around inf 76.8%
if -2.29999999999999997e-216 < NdChar < 1.79999999999999997e-187Initial 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%
*-un-lft-identity100.0%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 82.5%
log-E82.5%
*-lft-identity82.5%
associate--l+82.5%
associate--l+82.5%
sub-neg82.5%
+-commutative82.5%
mul-1-neg82.5%
associate-+r+82.5%
mul-1-neg82.5%
+-commutative82.5%
sub-neg82.5%
Simplified82.5%
if 1.40000000000000009e183 < 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 72.9%
flip-+65.8%
Applied egg-rr65.8%
Taylor expanded in Ev around inf 81.8%
Final simplification77.4%
(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 (/ (- Ec) KbT)))))))
(if (<= Ec -3.2e-9)
t_1
(if (<= Ec 2.55e-202)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Ec 1.6e+99)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef 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((-Ec / KbT))));
double tmp;
if (Ec <= -3.2e-9) {
tmp = t_1;
} else if (Ec <= 2.55e-202) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Ec <= 1.6e+99) {
tmp = t_0 + (NdChar / (1.0 + exp((Vef / 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((-ec / kbt))))
if (ec <= (-3.2d-9)) then
tmp = t_1
else if (ec <= 2.55d-202) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (ec <= 1.6d+99) then
tmp = t_0 + (ndchar / (1.0d0 + exp((vef / 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((-Ec / KbT))));
double tmp;
if (Ec <= -3.2e-9) {
tmp = t_1;
} else if (Ec <= 2.55e-202) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Ec <= 1.6e+99) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((Vef / 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((-Ec / KbT)))) tmp = 0 if Ec <= -3.2e-9: tmp = t_1 elif Ec <= 2.55e-202: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Ec <= 1.6e+99: tmp = t_0 + (NdChar / (1.0 + math.exp((Vef / 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(Float64(-Ec) / KbT))))) tmp = 0.0 if (Ec <= -3.2e-9) tmp = t_1; elseif (Ec <= 2.55e-202) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Ec <= 1.6e+99) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / 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((-Ec / KbT)))); tmp = 0.0; if (Ec <= -3.2e-9) tmp = t_1; elseif (Ec <= 2.55e-202) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Ec <= 1.6e+99) tmp = t_0 + (NdChar / (1.0 + exp((Vef / 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[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ec, -3.2e-9], t$95$1, If[LessEqual[Ec, 2.55e-202], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, 1.6e+99], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / 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{-Ec}{KbT}}}\\
\mathbf{if}\;Ec \leq -3.2 \cdot 10^{-9}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Ec \leq 2.55 \cdot 10^{-202}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Ec \leq 1.6 \cdot 10^{+99}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if Ec < -3.20000000000000012e-9 or 1.6e99 < Ec Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in Ec around inf 87.5%
associate-*r/87.5%
mul-1-neg87.5%
Simplified87.5%
if -3.20000000000000012e-9 < Ec < 2.54999999999999998e-202Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EDonor around inf 77.5%
if 2.54999999999999998e-202 < Ec < 1.6e99Initial 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 84.0%
Final simplification83.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))) (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (or (<= Vef -1.6e+161) (not (<= Vef 2e+32)))
(+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if ((Vef <= -1.6e+161) || !(Vef <= 2e+32)) {
tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
} else {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if ((vef <= (-1.6d+161)) .or. (.not. (vef <= 2d+32))) then
tmp = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
else
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if ((Vef <= -1.6e+161) || !(Vef <= 2e+32)) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
} else {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
}
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))) tmp = 0 if (Vef <= -1.6e+161) or not (Vef <= 2e+32): tmp = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT)))) else: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) 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)))) tmp = 0.0 if ((Vef <= -1.6e+161) || !(Vef <= 2e+32)) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))); else tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if ((Vef <= -1.6e+161) || ~((Vef <= 2e+32))) tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT)))); else tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[Vef, -1.6e+161], N[Not[LessEqual[Vef, 2e+32]], $MachinePrecision]], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;Vef \leq -1.6 \cdot 10^{+161} \lor \neg \left(Vef \leq 2 \cdot 10^{+32}\right):\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\end{array}
\end{array}
if Vef < -1.60000000000000001e161 or 2.00000000000000011e32 < Vef Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in Vef around inf 89.8%
if -1.60000000000000001e161 < Vef < 2.00000000000000011e32Initial 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 77.8%
Final simplification82.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (+ 1.0 (/ (+ (+ mu Vef) (- EDonor Ec)) KbT))))))
(t_1
(+
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
(t_2 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= NdChar -3.7e+148)
t_1
(if (<= NdChar -1.6e+119)
(+
t_2
(/
(* KbT NaChar)
(-
(+ Ev (/ (* EAccept EAccept) (- EAccept Vef)))
(+ mu (/ (* Vef Vef) (- EAccept Vef))))))
(if (<= NdChar -4e+33)
t_1
(if (<= NdChar 6.8e-18)
t_0
(if (<= NdChar 0.028)
(+
t_2
(/
NaChar
(+
1.0
(-
(+
1.0
(+
(+ (/ Ev KbT) (/ EAccept KbT))
(+
(/ Vef KbT)
(/
(-
KbT
(+
(/ (* EAccept EAccept) KbT)
(*
(+ (/ EAccept KbT) -1.0)
(* KbT (- -1.0 (/ EAccept KbT))))))
Vef))))
(/ mu KbT)))))
(if (<= NdChar 2.4e+72)
t_0
(+ t_2 (/ NaChar (+ 1.0 (- (/ Ev KbT) (/ mu KbT)))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
double t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
double t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -3.7e+148) {
tmp = t_1;
} else if (NdChar <= -1.6e+119) {
tmp = t_2 + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef)))));
} else if (NdChar <= -4e+33) {
tmp = t_1;
} else if (NdChar <= 6.8e-18) {
tmp = t_0;
} else if (NdChar <= 0.028) {
tmp = t_2 + (NaChar / (1.0 + ((1.0 + (((Ev / KbT) + (EAccept / KbT)) + ((Vef / KbT) + ((KbT - (((EAccept * EAccept) / KbT) + (((EAccept / KbT) + -1.0) * (KbT * (-1.0 - (EAccept / KbT)))))) / Vef)))) - (mu / KbT))));
} else if (NdChar <= 2.4e+72) {
tmp = t_0;
} else {
tmp = t_2 + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (((mu + vef) + (edonor - ec)) / kbt))))
t_1 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
t_2 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ndchar <= (-3.7d+148)) then
tmp = t_1
else if (ndchar <= (-1.6d+119)) then
tmp = t_2 + ((kbt * nachar) / ((ev + ((eaccept * eaccept) / (eaccept - vef))) - (mu + ((vef * vef) / (eaccept - vef)))))
else if (ndchar <= (-4d+33)) then
tmp = t_1
else if (ndchar <= 6.8d-18) then
tmp = t_0
else if (ndchar <= 0.028d0) then
tmp = t_2 + (nachar / (1.0d0 + ((1.0d0 + (((ev / kbt) + (eaccept / kbt)) + ((vef / kbt) + ((kbt - (((eaccept * eaccept) / kbt) + (((eaccept / kbt) + (-1.0d0)) * (kbt * ((-1.0d0) - (eaccept / kbt)))))) / vef)))) - (mu / kbt))))
else if (ndchar <= 2.4d+72) then
tmp = t_0
else
tmp = t_2 + (nachar / (1.0d0 + ((ev / kbt) - (mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
double t_1 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
double t_2 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -3.7e+148) {
tmp = t_1;
} else if (NdChar <= -1.6e+119) {
tmp = t_2 + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef)))));
} else if (NdChar <= -4e+33) {
tmp = t_1;
} else if (NdChar <= 6.8e-18) {
tmp = t_0;
} else if (NdChar <= 0.028) {
tmp = t_2 + (NaChar / (1.0 + ((1.0 + (((Ev / KbT) + (EAccept / KbT)) + ((Vef / KbT) + ((KbT - (((EAccept * EAccept) / KbT) + (((EAccept / KbT) + -1.0) * (KbT * (-1.0 - (EAccept / KbT)))))) / Vef)))) - (mu / KbT))));
} else if (NdChar <= 2.4e+72) {
tmp = t_0;
} else {
tmp = t_2 + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))) t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT)))) t_2 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if NdChar <= -3.7e+148: tmp = t_1 elif NdChar <= -1.6e+119: tmp = t_2 + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef))))) elif NdChar <= -4e+33: tmp = t_1 elif NdChar <= 6.8e-18: tmp = t_0 elif NdChar <= 0.028: tmp = t_2 + (NaChar / (1.0 + ((1.0 + (((Ev / KbT) + (EAccept / KbT)) + ((Vef / KbT) + ((KbT - (((EAccept * EAccept) / KbT) + (((EAccept / KbT) + -1.0) * (KbT * (-1.0 - (EAccept / KbT)))))) / Vef)))) - (mu / KbT)))) elif NdChar <= 2.4e+72: tmp = t_0 else: tmp = t_2 + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(mu + Vef) + Float64(EDonor - Ec)) / KbT))))) t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))) t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (NdChar <= -3.7e+148) tmp = t_1; elseif (NdChar <= -1.6e+119) tmp = Float64(t_2 + Float64(Float64(KbT * NaChar) / Float64(Float64(Ev + Float64(Float64(EAccept * EAccept) / Float64(EAccept - Vef))) - Float64(mu + Float64(Float64(Vef * Vef) / Float64(EAccept - Vef)))))); elseif (NdChar <= -4e+33) tmp = t_1; elseif (NdChar <= 6.8e-18) tmp = t_0; elseif (NdChar <= 0.028) tmp = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(EAccept / KbT)) + Float64(Float64(Vef / KbT) + Float64(Float64(KbT - Float64(Float64(Float64(EAccept * EAccept) / KbT) + Float64(Float64(Float64(EAccept / KbT) + -1.0) * Float64(KbT * Float64(-1.0 - Float64(EAccept / KbT)))))) / Vef)))) - Float64(mu / KbT))))); elseif (NdChar <= 2.4e+72) tmp = t_0; else tmp = Float64(t_2 + Float64(NaChar / Float64(1.0 + Float64(Float64(Ev / KbT) - Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))); t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT)))); t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (NdChar <= -3.7e+148) tmp = t_1; elseif (NdChar <= -1.6e+119) tmp = t_2 + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef))))); elseif (NdChar <= -4e+33) tmp = t_1; elseif (NdChar <= 6.8e-18) tmp = t_0; elseif (NdChar <= 0.028) tmp = t_2 + (NaChar / (1.0 + ((1.0 + (((Ev / KbT) + (EAccept / KbT)) + ((Vef / KbT) + ((KbT - (((EAccept * EAccept) / KbT) + (((EAccept / KbT) + -1.0) * (KbT * (-1.0 - (EAccept / KbT)))))) / Vef)))) - (mu / KbT)))); elseif (NdChar <= 2.4e+72) tmp = t_0; else tmp = t_2 + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(N[(N[(mu + Vef), $MachinePrecision] + N[(EDonor - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -3.7e+148], t$95$1, If[LessEqual[NdChar, -1.6e+119], N[(t$95$2 + N[(N[(KbT * NaChar), $MachinePrecision] / N[(N[(Ev + N[(N[(EAccept * EAccept), $MachinePrecision] / N[(EAccept - Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu + N[(N[(Vef * Vef), $MachinePrecision] / N[(EAccept - Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -4e+33], t$95$1, If[LessEqual[NdChar, 6.8e-18], t$95$0, If[LessEqual[NdChar, 0.028], N[(t$95$2 + N[(NaChar / N[(1.0 + N[(N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(N[(KbT - N[(N[(N[(EAccept * EAccept), $MachinePrecision] / KbT), $MachinePrecision] + N[(N[(N[(EAccept / KbT), $MachinePrecision] + -1.0), $MachinePrecision] * N[(KbT * N[(-1.0 - N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.4e+72], t$95$0, N[(t$95$2 + N[(NaChar / N[(1.0 + N[(N[(Ev / KbT), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{\left(mu + Vef\right) + \left(EDonor - Ec\right)}{KbT}\right)}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;NdChar \leq -3.7 \cdot 10^{+148}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NdChar \leq -1.6 \cdot 10^{+119}:\\
\;\;\;\;t_2 + \frac{KbT \cdot NaChar}{\left(Ev + \frac{EAccept \cdot EAccept}{EAccept - Vef}\right) - \left(mu + \frac{Vef \cdot Vef}{EAccept - Vef}\right)}\\
\mathbf{elif}\;NdChar \leq -4 \cdot 10^{+33}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NdChar \leq 6.8 \cdot 10^{-18}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NdChar \leq 0.028:\\
\;\;\;\;t_2 + \frac{NaChar}{1 + \left(\left(1 + \left(\left(\frac{Ev}{KbT} + \frac{EAccept}{KbT}\right) + \left(\frac{Vef}{KbT} + \frac{KbT - \left(\frac{EAccept \cdot EAccept}{KbT} + \left(\frac{EAccept}{KbT} + -1\right) \cdot \left(KbT \cdot \left(-1 - \frac{EAccept}{KbT}\right)\right)\right)}{Vef}\right)\right)\right) - \frac{mu}{KbT}\right)}\\
\mathbf{elif}\;NdChar \leq 2.4 \cdot 10^{+72}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_2 + \frac{NaChar}{1 + \left(\frac{Ev}{KbT} - \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NdChar < -3.7000000000000002e148 or -1.59999999999999995e119 < NdChar < -3.9999999999999998e33Initial 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 75.8%
Taylor expanded in mu around inf 68.5%
neg-mul-168.5%
distribute-neg-frac68.5%
Simplified68.5%
if -3.7000000000000002e148 < NdChar < -1.59999999999999995e119Initial program 99.5%
neg-sub099.5%
associate--r-99.5%
+-commutative99.5%
neg-sub099.5%
sub-neg99.5%
associate--l-99.5%
unsub-neg99.5%
+-commutative99.5%
associate-+l+99.5%
Simplified99.5%
Taylor expanded in KbT around inf 87.5%
flip-+50.0%
Applied egg-rr50.0%
Taylor expanded in KbT around 0 99.5%
*-commutative99.5%
+-commutative99.5%
unpow299.5%
+-commutative99.5%
unpow299.5%
Simplified99.5%
if -3.9999999999999998e33 < NdChar < 6.80000000000000002e-18 or 0.0280000000000000006 < NdChar < 2.4000000000000001e72Initial 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%
*-un-lft-identity100.0%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 71.2%
log-E71.2%
*-lft-identity71.2%
associate--l+71.2%
associate--l+71.2%
sub-neg71.2%
+-commutative71.2%
mul-1-neg71.2%
associate-+r+71.2%
mul-1-neg71.2%
+-commutative71.2%
sub-neg71.2%
Simplified71.2%
if 6.80000000000000002e-18 < NdChar < 0.0280000000000000006Initial program 99.0%
neg-sub099.0%
associate--r-99.0%
+-commutative99.0%
neg-sub099.0%
sub-neg99.0%
associate--l-99.0%
unsub-neg99.0%
+-commutative99.0%
associate-+l+99.0%
Simplified99.0%
Taylor expanded in KbT around inf 71.6%
flip-+57.3%
Applied egg-rr57.3%
Taylor expanded in Vef around -inf 71.3%
associate-+r+71.3%
mul-1-neg71.3%
unsub-neg71.3%
Simplified71.3%
if 2.4000000000000001e72 < 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 60.9%
flip-+55.1%
Applied egg-rr55.1%
Taylor expanded in Ev around inf 67.5%
Final simplification70.7%
(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 (+ 1.0 (+ 1.0 (/ (+ (+ mu Vef) (- EDonor Ec)) KbT)))))))
(if (<= NdChar -1.3e+153)
t_1
(if (<= NdChar -8.6e+18)
(+
t_0
(/
(* KbT NaChar)
(-
(+ Ev (/ (* EAccept EAccept) (- EAccept Vef)))
(+ mu (/ (* Vef Vef) (- EAccept Vef))))))
(if (<= NdChar 1.65e-17)
t_1
(if (<= NdChar 12.0)
(+
t_0
(/
NaChar
(+
1.0
(-
(+
1.0
(+
(+ (/ Ev KbT) (/ EAccept KbT))
(+
(/ Vef KbT)
(/
(-
KbT
(+
(/ (* EAccept EAccept) KbT)
(*
(+ (/ EAccept KbT) -1.0)
(* KbT (- -1.0 (/ EAccept KbT))))))
Vef))))
(/ mu KbT)))))
(if (<= NdChar 1.75e+74)
t_1
(+ t_0 (/ NaChar (+ 1.0 (- (/ Ev KbT) (/ mu KbT))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
double tmp;
if (NdChar <= -1.3e+153) {
tmp = t_1;
} else if (NdChar <= -8.6e+18) {
tmp = t_0 + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef)))));
} else if (NdChar <= 1.65e-17) {
tmp = t_1;
} else if (NdChar <= 12.0) {
tmp = t_0 + (NaChar / (1.0 + ((1.0 + (((Ev / KbT) + (EAccept / KbT)) + ((Vef / KbT) + ((KbT - (((EAccept * EAccept) / KbT) + (((EAccept / KbT) + -1.0) * (KbT * (-1.0 - (EAccept / KbT)))))) / Vef)))) - (mu / KbT))));
} else if (NdChar <= 1.75e+74) {
tmp = t_1;
} else {
tmp = t_0 + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_1 = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (((mu + vef) + (edonor - ec)) / kbt))))
if (ndchar <= (-1.3d+153)) then
tmp = t_1
else if (ndchar <= (-8.6d+18)) then
tmp = t_0 + ((kbt * nachar) / ((ev + ((eaccept * eaccept) / (eaccept - vef))) - (mu + ((vef * vef) / (eaccept - vef)))))
else if (ndchar <= 1.65d-17) then
tmp = t_1
else if (ndchar <= 12.0d0) then
tmp = t_0 + (nachar / (1.0d0 + ((1.0d0 + (((ev / kbt) + (eaccept / kbt)) + ((vef / kbt) + ((kbt - (((eaccept * eaccept) / kbt) + (((eaccept / kbt) + (-1.0d0)) * (kbt * ((-1.0d0) - (eaccept / kbt)))))) / vef)))) - (mu / kbt))))
else if (ndchar <= 1.75d+74) then
tmp = t_1
else
tmp = t_0 + (nachar / (1.0d0 + ((ev / kbt) - (mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
double tmp;
if (NdChar <= -1.3e+153) {
tmp = t_1;
} else if (NdChar <= -8.6e+18) {
tmp = t_0 + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef)))));
} else if (NdChar <= 1.65e-17) {
tmp = t_1;
} else if (NdChar <= 12.0) {
tmp = t_0 + (NaChar / (1.0 + ((1.0 + (((Ev / KbT) + (EAccept / KbT)) + ((Vef / KbT) + ((KbT - (((EAccept * EAccept) / KbT) + (((EAccept / KbT) + -1.0) * (KbT * (-1.0 - (EAccept / KbT)))))) / Vef)))) - (mu / KbT))));
} else if (NdChar <= 1.75e+74) {
tmp = t_1;
} else {
tmp = t_0 + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_1 = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))) tmp = 0 if NdChar <= -1.3e+153: tmp = t_1 elif NdChar <= -8.6e+18: tmp = t_0 + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef))))) elif NdChar <= 1.65e-17: tmp = t_1 elif NdChar <= 12.0: tmp = t_0 + (NaChar / (1.0 + ((1.0 + (((Ev / KbT) + (EAccept / KbT)) + ((Vef / KbT) + ((KbT - (((EAccept * EAccept) / KbT) + (((EAccept / KbT) + -1.0) * (KbT * (-1.0 - (EAccept / KbT)))))) / Vef)))) - (mu / KbT)))) elif NdChar <= 1.75e+74: tmp = t_1 else: tmp = t_0 + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(mu + Vef) + Float64(EDonor - Ec)) / KbT))))) tmp = 0.0 if (NdChar <= -1.3e+153) tmp = t_1; elseif (NdChar <= -8.6e+18) tmp = Float64(t_0 + Float64(Float64(KbT * NaChar) / Float64(Float64(Ev + Float64(Float64(EAccept * EAccept) / Float64(EAccept - Vef))) - Float64(mu + Float64(Float64(Vef * Vef) / Float64(EAccept - Vef)))))); elseif (NdChar <= 1.65e-17) tmp = t_1; elseif (NdChar <= 12.0) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(EAccept / KbT)) + Float64(Float64(Vef / KbT) + Float64(Float64(KbT - Float64(Float64(Float64(EAccept * EAccept) / KbT) + Float64(Float64(Float64(EAccept / KbT) + -1.0) * Float64(KbT * Float64(-1.0 - Float64(EAccept / KbT)))))) / Vef)))) - Float64(mu / KbT))))); elseif (NdChar <= 1.75e+74) tmp = t_1; else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(Ev / KbT) - Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_1 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))); tmp = 0.0; if (NdChar <= -1.3e+153) tmp = t_1; elseif (NdChar <= -8.6e+18) tmp = t_0 + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef))))); elseif (NdChar <= 1.65e-17) tmp = t_1; elseif (NdChar <= 12.0) tmp = t_0 + (NaChar / (1.0 + ((1.0 + (((Ev / KbT) + (EAccept / KbT)) + ((Vef / KbT) + ((KbT - (((EAccept * EAccept) / KbT) + (((EAccept / KbT) + -1.0) * (KbT * (-1.0 - (EAccept / KbT)))))) / Vef)))) - (mu / KbT)))); elseif (NdChar <= 1.75e+74) tmp = t_1; else tmp = t_0 + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(N[(N[(mu + Vef), $MachinePrecision] + N[(EDonor - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.3e+153], t$95$1, If[LessEqual[NdChar, -8.6e+18], N[(t$95$0 + N[(N[(KbT * NaChar), $MachinePrecision] / N[(N[(Ev + N[(N[(EAccept * EAccept), $MachinePrecision] / N[(EAccept - Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu + N[(N[(Vef * Vef), $MachinePrecision] / N[(EAccept - Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.65e-17], t$95$1, If[LessEqual[NdChar, 12.0], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(N[(KbT - N[(N[(N[(EAccept * EAccept), $MachinePrecision] / KbT), $MachinePrecision] + N[(N[(N[(EAccept / KbT), $MachinePrecision] + -1.0), $MachinePrecision] * N[(KbT * N[(-1.0 - N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.75e+74], t$95$1, N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(Ev / KbT), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{\left(mu + Vef\right) + \left(EDonor - Ec\right)}{KbT}\right)}\\
\mathbf{if}\;NdChar \leq -1.3 \cdot 10^{+153}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NdChar \leq -8.6 \cdot 10^{+18}:\\
\;\;\;\;t_0 + \frac{KbT \cdot NaChar}{\left(Ev + \frac{EAccept \cdot EAccept}{EAccept - Vef}\right) - \left(mu + \frac{Vef \cdot Vef}{EAccept - Vef}\right)}\\
\mathbf{elif}\;NdChar \leq 1.65 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NdChar \leq 12:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(\left(1 + \left(\left(\frac{Ev}{KbT} + \frac{EAccept}{KbT}\right) + \left(\frac{Vef}{KbT} + \frac{KbT - \left(\frac{EAccept \cdot EAccept}{KbT} + \left(\frac{EAccept}{KbT} + -1\right) \cdot \left(KbT \cdot \left(-1 - \frac{EAccept}{KbT}\right)\right)\right)}{Vef}\right)\right)\right) - \frac{mu}{KbT}\right)}\\
\mathbf{elif}\;NdChar \leq 1.75 \cdot 10^{+74}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(\frac{Ev}{KbT} - \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NdChar < -1.2999999999999999e153 or -8.6e18 < NdChar < 1.65e-17 or 12 < NdChar < 1.75000000000000007e74Initial 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%
*-un-lft-identity100.0%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 69.7%
log-E69.7%
*-lft-identity69.7%
associate--l+69.7%
associate--l+69.7%
sub-neg69.7%
+-commutative69.7%
mul-1-neg69.7%
associate-+r+69.7%
mul-1-neg69.7%
+-commutative69.7%
sub-neg69.7%
Simplified69.7%
if -1.2999999999999999e153 < NdChar < -8.6e18Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 65.4%
flip-+47.8%
Applied egg-rr47.8%
Taylor expanded in KbT around 0 65.3%
*-commutative65.3%
+-commutative65.3%
unpow265.3%
+-commutative65.3%
unpow265.3%
Simplified65.3%
if 1.65e-17 < NdChar < 12Initial program 99.0%
neg-sub099.0%
associate--r-99.0%
+-commutative99.0%
neg-sub099.0%
sub-neg99.0%
associate--l-99.0%
unsub-neg99.0%
+-commutative99.0%
associate-+l+99.0%
Simplified99.0%
Taylor expanded in KbT around inf 71.6%
flip-+57.3%
Applied egg-rr57.3%
Taylor expanded in Vef around -inf 71.3%
associate-+r+71.3%
mul-1-neg71.3%
unsub-neg71.3%
Simplified71.3%
if 1.75000000000000007e74 < 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 60.9%
flip-+55.1%
Applied egg-rr55.1%
Taylor expanded in Ev around inf 67.5%
Final simplification68.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -5800.0) (not (<= NaChar 4.2e-75)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (+ 1.0 (/ (+ (+ mu Vef) (- EDonor Ec)) KbT)))))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/
(* KbT NaChar)
(-
(+ Ev (/ (* EAccept EAccept) (- EAccept Vef)))
(+ mu (/ (* Vef Vef) (- EAccept Vef))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -5800.0) || !(NaChar <= 4.2e-75)) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef)))));
}
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 <= (-5800.0d0)) .or. (.not. (nachar <= 4.2d-75))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (((mu + vef) + (edonor - ec)) / kbt))))
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + ((kbt * nachar) / ((ev + ((eaccept * eaccept) / (eaccept - vef))) - (mu + ((vef * vef) / (eaccept - vef)))))
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 <= -5800.0) || !(NaChar <= 4.2e-75)) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef)))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -5800.0) or not (NaChar <= 4.2e-75): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))) else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef))))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -5800.0) || !(NaChar <= 4.2e-75)) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(mu + Vef) + Float64(EDonor - Ec)) / KbT))))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(Float64(KbT * NaChar) / Float64(Float64(Ev + Float64(Float64(EAccept * EAccept) / Float64(EAccept - Vef))) - Float64(mu + Float64(Float64(Vef * Vef) / Float64(EAccept - Vef)))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -5800.0) || ~((NaChar <= 4.2e-75))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))); else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + ((KbT * NaChar) / ((Ev + ((EAccept * EAccept) / (EAccept - Vef))) - (mu + ((Vef * Vef) / (EAccept - Vef))))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -5800.0], N[Not[LessEqual[NaChar, 4.2e-75]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(N[(N[(mu + Vef), $MachinePrecision] + N[(EDonor - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(KbT * NaChar), $MachinePrecision] / N[(N[(Ev + N[(N[(EAccept * EAccept), $MachinePrecision] / N[(EAccept - Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu + N[(N[(Vef * Vef), $MachinePrecision] / N[(EAccept - Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -5800 \lor \neg \left(NaChar \leq 4.2 \cdot 10^{-75}\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{\left(mu + Vef\right) + \left(EDonor - Ec\right)}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{KbT \cdot NaChar}{\left(Ev + \frac{EAccept \cdot EAccept}{EAccept - Vef}\right) - \left(mu + \frac{Vef \cdot Vef}{EAccept - Vef}\right)}\\
\end{array}
\end{array}
if NaChar < -5800 or 4.2000000000000002e-75 < 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%
*-un-lft-identity100.0%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 66.0%
log-E66.0%
*-lft-identity66.0%
associate--l+66.0%
associate--l+66.0%
sub-neg66.0%
+-commutative66.0%
mul-1-neg66.0%
associate-+r+66.0%
mul-1-neg66.0%
+-commutative66.0%
sub-neg66.0%
Simplified66.0%
if -5800 < NaChar < 4.2000000000000002e-75Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 65.0%
flip-+58.3%
Applied egg-rr58.3%
Taylor expanded in KbT around 0 63.7%
*-commutative63.7%
+-commutative63.7%
unpow263.7%
+-commutative63.7%
unpow263.7%
Simplified63.7%
Final simplification65.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= NaChar -3e+163)
(+ t_0 (/ NdChar (+ 2.0 (/ EDonor KbT))))
(if (or (<= NaChar -8.8e+141)
(and (not (<= NaChar -0.52)) (<= NaChar 4.3e-75)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (- (/ Ev KbT) (/ mu KbT)))))
(+ t_0 (/ 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 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -3e+163) {
tmp = t_0 + (NdChar / (2.0 + (EDonor / KbT)));
} else if ((NaChar <= -8.8e+141) || (!(NaChar <= -0.52) && (NaChar <= 4.3e-75))) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
} else {
tmp = t_0 + (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) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-3d+163)) then
tmp = t_0 + (ndchar / (2.0d0 + (edonor / kbt)))
else if ((nachar <= (-8.8d+141)) .or. (.not. (nachar <= (-0.52d0))) .and. (nachar <= 4.3d-75)) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + ((ev / kbt) - (mu / kbt))))
else
tmp = t_0 + (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 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -3e+163) {
tmp = t_0 + (NdChar / (2.0 + (EDonor / KbT)));
} else if ((NaChar <= -8.8e+141) || (!(NaChar <= -0.52) && (NaChar <= 4.3e-75))) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
} else {
tmp = t_0 + (NdChar / (1.0 + (1.0 + (mu / KbT))));
}
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))) tmp = 0 if NaChar <= -3e+163: tmp = t_0 + (NdChar / (2.0 + (EDonor / KbT))) elif (NaChar <= -8.8e+141) or (not (NaChar <= -0.52) and (NaChar <= 4.3e-75)): tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))) else: tmp = t_0 + (NdChar / (1.0 + (1.0 + (mu / KbT)))) 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)))) tmp = 0.0 if (NaChar <= -3e+163) tmp = Float64(t_0 + Float64(NdChar / Float64(2.0 + Float64(EDonor / KbT)))); elseif ((NaChar <= -8.8e+141) || (!(NaChar <= -0.52) && (NaChar <= 4.3e-75))) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Ev / KbT) - Float64(mu / KbT))))); else tmp = Float64(t_0 + 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 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -3e+163) tmp = t_0 + (NdChar / (2.0 + (EDonor / KbT))); elseif ((NaChar <= -8.8e+141) || (~((NaChar <= -0.52)) && (NaChar <= 4.3e-75))) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))); else tmp = t_0 + (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[(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, -3e+163], N[(t$95$0 + N[(NdChar / N[(2.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, -8.8e+141], And[N[Not[LessEqual[NaChar, -0.52]], $MachinePrecision], LessEqual[NaChar, 4.3e-75]]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(Ev / KbT), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + 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{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -3 \cdot 10^{+163}:\\
\;\;\;\;t_0 + \frac{NdChar}{2 + \frac{EDonor}{KbT}}\\
\mathbf{elif}\;NaChar \leq -8.8 \cdot 10^{+141} \lor \neg \left(NaChar \leq -0.52\right) \land NaChar \leq 4.3 \cdot 10^{-75}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(\frac{Ev}{KbT} - \frac{mu}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + \left(1 + \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NaChar < -3.00000000000000013e163Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EDonor around inf 73.2%
Taylor expanded in EDonor around 0 66.8%
if -3.00000000000000013e163 < NaChar < -8.8e141 or -0.52000000000000002 < NaChar < 4.2999999999999999e-75Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 65.6%
flip-+58.4%
Applied egg-rr58.4%
Taylor expanded in Ev around inf 66.4%
if -8.8e141 < NaChar < -0.52000000000000002 or 4.2999999999999999e-75 < 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 70.6%
Taylor expanded in mu around 0 61.5%
Final simplification64.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -0.05) (not (<= NaChar 1.85e-75)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (+ 1.0 (/ (+ (+ mu Vef) (- EDonor Ec)) KbT)))))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (- (/ Ev KbT) (/ mu KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -0.05) || !(NaChar <= 1.85e-75)) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((nachar <= (-0.05d0)) .or. (.not. (nachar <= 1.85d-75))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (((mu + vef) + (edonor - ec)) / kbt))))
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + ((ev / kbt) - (mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -0.05) || !(NaChar <= 1.85e-75)) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT))));
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -0.05) or not (NaChar <= 1.85e-75): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))) else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -0.05) || !(NaChar <= 1.85e-75)) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(mu + Vef) + Float64(EDonor - Ec)) / KbT))))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Ev / KbT) - Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -0.05) || ~((NaChar <= 1.85e-75))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (1.0 + (((mu + Vef) + (EDonor - Ec)) / KbT)))); else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + ((Ev / KbT) - (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -0.05], N[Not[LessEqual[NaChar, 1.85e-75]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(N[(N[(mu + Vef), $MachinePrecision] + N[(EDonor - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(Ev / KbT), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -0.05 \lor \neg \left(NaChar \leq 1.85 \cdot 10^{-75}\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{\left(mu + Vef\right) + \left(EDonor - Ec\right)}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(\frac{Ev}{KbT} - \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NaChar < -0.050000000000000003 or 1.85000000000000012e-75 < 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%
*-un-lft-identity100.0%
exp-prod100.0%
exp-1-e100.0%
associate--r-100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 65.8%
log-E65.8%
*-lft-identity65.8%
associate--l+65.8%
associate--l+65.8%
sub-neg65.8%
+-commutative65.8%
mul-1-neg65.8%
associate-+r+65.8%
mul-1-neg65.8%
+-commutative65.8%
sub-neg65.8%
Simplified65.8%
if -0.050000000000000003 < NaChar < 1.85000000000000012e-75Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 66.1%
flip-+58.4%
Applied egg-rr58.4%
Taylor expanded in Ev around inf 66.0%
Final simplification65.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_2 (+ t_1 (* NaChar 0.5))))
(if (<= KbT -4.5e+156)
t_2
(if (<= KbT -7.8e+78)
(+ t_0 (* -0.25 (/ Vef (/ KbT NdChar))))
(if (<= KbT -2.1e-111)
(+ t_0 (* NdChar 0.5))
(if (<= KbT 4.8e-182)
(+ t_1 (/ NaChar (/ Vef KbT)))
(if (<= KbT 8.6e-8) (+ t_1 (* KbT (/ NaChar EAccept))) t_2)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_2 = t_1 + (NaChar * 0.5);
double tmp;
if (KbT <= -4.5e+156) {
tmp = t_2;
} else if (KbT <= -7.8e+78) {
tmp = t_0 + (-0.25 * (Vef / (KbT / NdChar)));
} else if (KbT <= -2.1e-111) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= 4.8e-182) {
tmp = t_1 + (NaChar / (Vef / KbT));
} else if (KbT <= 8.6e-8) {
tmp = t_1 + (KbT * (NaChar / EAccept));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_2 = t_1 + (nachar * 0.5d0)
if (kbt <= (-4.5d+156)) then
tmp = t_2
else if (kbt <= (-7.8d+78)) then
tmp = t_0 + ((-0.25d0) * (vef / (kbt / ndchar)))
else if (kbt <= (-2.1d-111)) then
tmp = t_0 + (ndchar * 0.5d0)
else if (kbt <= 4.8d-182) then
tmp = t_1 + (nachar / (vef / kbt))
else if (kbt <= 8.6d-8) then
tmp = t_1 + (kbt * (nachar / eaccept))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_2 = t_1 + (NaChar * 0.5);
double tmp;
if (KbT <= -4.5e+156) {
tmp = t_2;
} else if (KbT <= -7.8e+78) {
tmp = t_0 + (-0.25 * (Vef / (KbT / NdChar)));
} else if (KbT <= -2.1e-111) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= 4.8e-182) {
tmp = t_1 + (NaChar / (Vef / KbT));
} else if (KbT <= 8.6e-8) {
tmp = t_1 + (KbT * (NaChar / EAccept));
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_2 = t_1 + (NaChar * 0.5) tmp = 0 if KbT <= -4.5e+156: tmp = t_2 elif KbT <= -7.8e+78: tmp = t_0 + (-0.25 * (Vef / (KbT / NdChar))) elif KbT <= -2.1e-111: tmp = t_0 + (NdChar * 0.5) elif KbT <= 4.8e-182: tmp = t_1 + (NaChar / (Vef / KbT)) elif KbT <= 8.6e-8: tmp = t_1 + (KbT * (NaChar / EAccept)) else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_2 = Float64(t_1 + Float64(NaChar * 0.5)) tmp = 0.0 if (KbT <= -4.5e+156) tmp = t_2; elseif (KbT <= -7.8e+78) tmp = Float64(t_0 + Float64(-0.25 * Float64(Vef / Float64(KbT / NdChar)))); elseif (KbT <= -2.1e-111) tmp = Float64(t_0 + Float64(NdChar * 0.5)); elseif (KbT <= 4.8e-182) tmp = Float64(t_1 + Float64(NaChar / Float64(Vef / KbT))); elseif (KbT <= 8.6e-8) tmp = Float64(t_1 + Float64(KbT * Float64(NaChar / EAccept))); else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_2 = t_1 + (NaChar * 0.5); tmp = 0.0; if (KbT <= -4.5e+156) tmp = t_2; elseif (KbT <= -7.8e+78) tmp = t_0 + (-0.25 * (Vef / (KbT / NdChar))); elseif (KbT <= -2.1e-111) tmp = t_0 + (NdChar * 0.5); elseif (KbT <= 4.8e-182) tmp = t_1 + (NaChar / (Vef / KbT)); elseif (KbT <= 8.6e-8) tmp = t_1 + (KbT * (NaChar / EAccept)); else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -4.5e+156], t$95$2, If[LessEqual[KbT, -7.8e+78], N[(t$95$0 + N[(-0.25 * N[(Vef / N[(KbT / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2.1e-111], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4.8e-182], N[(t$95$1 + N[(NaChar / N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 8.6e-8], N[(t$95$1 + N[(KbT * N[(NaChar / EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_2 := t_1 + NaChar \cdot 0.5\\
\mathbf{if}\;KbT \leq -4.5 \cdot 10^{+156}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;KbT \leq -7.8 \cdot 10^{+78}:\\
\;\;\;\;t_0 + -0.25 \cdot \frac{Vef}{\frac{KbT}{NdChar}}\\
\mathbf{elif}\;KbT \leq -2.1 \cdot 10^{-111}:\\
\;\;\;\;t_0 + NdChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 4.8 \cdot 10^{-182}:\\
\;\;\;\;t_1 + \frac{NaChar}{\frac{Vef}{KbT}}\\
\mathbf{elif}\;KbT \leq 8.6 \cdot 10^{-8}:\\
\;\;\;\;t_1 + KbT \cdot \frac{NaChar}{EAccept}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if KbT < -4.50000000000000031e156 or 8.6000000000000002e-8 < KbT Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in KbT around inf 65.7%
Taylor expanded in KbT around inf 65.7%
if -4.50000000000000031e156 < KbT < -7.8000000000000008e78Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 33.4%
Taylor expanded in Vef around inf 37.8%
associate-/l*54.0%
Simplified54.0%
if -7.8000000000000008e78 < KbT < -2.0999999999999999e-111Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 42.8%
*-commutative8.1%
Simplified42.8%
if -2.0999999999999999e-111 < KbT < 4.7999999999999997e-182Initial 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.3%
Taylor expanded in Vef around inf 52.9%
associate-/l*59.1%
Simplified59.1%
if 4.7999999999999997e-182 < KbT < 8.6000000000000002e-8Initial 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 44.7%
Taylor expanded in EAccept around inf 40.2%
associate-/l*40.0%
Simplified40.0%
associate-/r/40.1%
Applied egg-rr40.1%
Final simplification55.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_2 (+ t_1 (* NaChar 0.5))))
(if (<= KbT -2.5e+157)
t_2
(if (<= KbT -1.28e+79)
(+ t_0 (* -0.25 (/ (* NdChar mu) KbT)))
(if (<= KbT -3.2e-111)
(+ t_0 (* NdChar 0.5))
(if (<= KbT 2.8e-180)
(+ t_1 (/ NaChar (/ Vef KbT)))
(if (<= KbT 2.4e-5) (+ t_1 (* KbT (/ NaChar EAccept))) t_2)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_2 = t_1 + (NaChar * 0.5);
double tmp;
if (KbT <= -2.5e+157) {
tmp = t_2;
} else if (KbT <= -1.28e+79) {
tmp = t_0 + (-0.25 * ((NdChar * mu) / KbT));
} else if (KbT <= -3.2e-111) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= 2.8e-180) {
tmp = t_1 + (NaChar / (Vef / KbT));
} else if (KbT <= 2.4e-5) {
tmp = t_1 + (KbT * (NaChar / EAccept));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_2 = t_1 + (nachar * 0.5d0)
if (kbt <= (-2.5d+157)) then
tmp = t_2
else if (kbt <= (-1.28d+79)) then
tmp = t_0 + ((-0.25d0) * ((ndchar * mu) / kbt))
else if (kbt <= (-3.2d-111)) then
tmp = t_0 + (ndchar * 0.5d0)
else if (kbt <= 2.8d-180) then
tmp = t_1 + (nachar / (vef / kbt))
else if (kbt <= 2.4d-5) then
tmp = t_1 + (kbt * (nachar / eaccept))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_2 = t_1 + (NaChar * 0.5);
double tmp;
if (KbT <= -2.5e+157) {
tmp = t_2;
} else if (KbT <= -1.28e+79) {
tmp = t_0 + (-0.25 * ((NdChar * mu) / KbT));
} else if (KbT <= -3.2e-111) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= 2.8e-180) {
tmp = t_1 + (NaChar / (Vef / KbT));
} else if (KbT <= 2.4e-5) {
tmp = t_1 + (KbT * (NaChar / EAccept));
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_2 = t_1 + (NaChar * 0.5) tmp = 0 if KbT <= -2.5e+157: tmp = t_2 elif KbT <= -1.28e+79: tmp = t_0 + (-0.25 * ((NdChar * mu) / KbT)) elif KbT <= -3.2e-111: tmp = t_0 + (NdChar * 0.5) elif KbT <= 2.8e-180: tmp = t_1 + (NaChar / (Vef / KbT)) elif KbT <= 2.4e-5: tmp = t_1 + (KbT * (NaChar / EAccept)) else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_2 = Float64(t_1 + Float64(NaChar * 0.5)) tmp = 0.0 if (KbT <= -2.5e+157) tmp = t_2; elseif (KbT <= -1.28e+79) tmp = Float64(t_0 + Float64(-0.25 * Float64(Float64(NdChar * mu) / KbT))); elseif (KbT <= -3.2e-111) tmp = Float64(t_0 + Float64(NdChar * 0.5)); elseif (KbT <= 2.8e-180) tmp = Float64(t_1 + Float64(NaChar / Float64(Vef / KbT))); elseif (KbT <= 2.4e-5) tmp = Float64(t_1 + Float64(KbT * Float64(NaChar / EAccept))); else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_2 = t_1 + (NaChar * 0.5); tmp = 0.0; if (KbT <= -2.5e+157) tmp = t_2; elseif (KbT <= -1.28e+79) tmp = t_0 + (-0.25 * ((NdChar * mu) / KbT)); elseif (KbT <= -3.2e-111) tmp = t_0 + (NdChar * 0.5); elseif (KbT <= 2.8e-180) tmp = t_1 + (NaChar / (Vef / KbT)); elseif (KbT <= 2.4e-5) tmp = t_1 + (KbT * (NaChar / EAccept)); else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.5e+157], t$95$2, If[LessEqual[KbT, -1.28e+79], N[(t$95$0 + N[(-0.25 * N[(N[(NdChar * mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -3.2e-111], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.8e-180], N[(t$95$1 + N[(NaChar / N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.4e-5], N[(t$95$1 + N[(KbT * N[(NaChar / EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_2 := t_1 + NaChar \cdot 0.5\\
\mathbf{if}\;KbT \leq -2.5 \cdot 10^{+157}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;KbT \leq -1.28 \cdot 10^{+79}:\\
\;\;\;\;t_0 + -0.25 \cdot \frac{NdChar \cdot mu}{KbT}\\
\mathbf{elif}\;KbT \leq -3.2 \cdot 10^{-111}:\\
\;\;\;\;t_0 + NdChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 2.8 \cdot 10^{-180}:\\
\;\;\;\;t_1 + \frac{NaChar}{\frac{Vef}{KbT}}\\
\mathbf{elif}\;KbT \leq 2.4 \cdot 10^{-5}:\\
\;\;\;\;t_1 + KbT \cdot \frac{NaChar}{EAccept}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if KbT < -2.49999999999999988e157 or 2.4000000000000001e-5 < KbT Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in KbT around inf 65.7%
Taylor expanded in KbT around inf 65.7%
if -2.49999999999999988e157 < KbT < -1.27999999999999998e79Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 33.4%
Taylor expanded in mu around inf 55.7%
if -1.27999999999999998e79 < KbT < -3.1999999999999998e-111Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 42.8%
*-commutative8.1%
Simplified42.8%
if -3.1999999999999998e-111 < KbT < 2.79999999999999997e-180Initial 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.3%
Taylor expanded in Vef around inf 52.9%
associate-/l*59.1%
Simplified59.1%
if 2.79999999999999997e-180 < KbT < 2.4000000000000001e-5Initial 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 44.7%
Taylor expanded in EAccept around inf 40.2%
associate-/l*40.0%
Simplified40.0%
associate-/r/40.1%
Applied egg-rr40.1%
Final simplification55.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_2 (+ t_1 (* NaChar 0.5))))
(if (<= KbT -4.8e+151)
t_2
(if (<= KbT -6.4e-9)
(+ t_0 (* 0.25 (/ NdChar (/ KbT Ec))))
(if (<= KbT -1.5e-111)
(+ t_0 (* NdChar 0.5))
(if (<= KbT 4.7e-182)
(+ t_1 (/ NaChar (/ Vef KbT)))
(if (<= KbT 0.00048) (+ t_1 (* KbT (/ NaChar EAccept))) t_2)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_2 = t_1 + (NaChar * 0.5);
double tmp;
if (KbT <= -4.8e+151) {
tmp = t_2;
} else if (KbT <= -6.4e-9) {
tmp = t_0 + (0.25 * (NdChar / (KbT / Ec)));
} else if (KbT <= -1.5e-111) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= 4.7e-182) {
tmp = t_1 + (NaChar / (Vef / KbT));
} else if (KbT <= 0.00048) {
tmp = t_1 + (KbT * (NaChar / EAccept));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_2 = t_1 + (nachar * 0.5d0)
if (kbt <= (-4.8d+151)) then
tmp = t_2
else if (kbt <= (-6.4d-9)) then
tmp = t_0 + (0.25d0 * (ndchar / (kbt / ec)))
else if (kbt <= (-1.5d-111)) then
tmp = t_0 + (ndchar * 0.5d0)
else if (kbt <= 4.7d-182) then
tmp = t_1 + (nachar / (vef / kbt))
else if (kbt <= 0.00048d0) then
tmp = t_1 + (kbt * (nachar / eaccept))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_2 = t_1 + (NaChar * 0.5);
double tmp;
if (KbT <= -4.8e+151) {
tmp = t_2;
} else if (KbT <= -6.4e-9) {
tmp = t_0 + (0.25 * (NdChar / (KbT / Ec)));
} else if (KbT <= -1.5e-111) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= 4.7e-182) {
tmp = t_1 + (NaChar / (Vef / KbT));
} else if (KbT <= 0.00048) {
tmp = t_1 + (KbT * (NaChar / EAccept));
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_2 = t_1 + (NaChar * 0.5) tmp = 0 if KbT <= -4.8e+151: tmp = t_2 elif KbT <= -6.4e-9: tmp = t_0 + (0.25 * (NdChar / (KbT / Ec))) elif KbT <= -1.5e-111: tmp = t_0 + (NdChar * 0.5) elif KbT <= 4.7e-182: tmp = t_1 + (NaChar / (Vef / KbT)) elif KbT <= 0.00048: tmp = t_1 + (KbT * (NaChar / EAccept)) else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_2 = Float64(t_1 + Float64(NaChar * 0.5)) tmp = 0.0 if (KbT <= -4.8e+151) tmp = t_2; elseif (KbT <= -6.4e-9) tmp = Float64(t_0 + Float64(0.25 * Float64(NdChar / Float64(KbT / Ec)))); elseif (KbT <= -1.5e-111) tmp = Float64(t_0 + Float64(NdChar * 0.5)); elseif (KbT <= 4.7e-182) tmp = Float64(t_1 + Float64(NaChar / Float64(Vef / KbT))); elseif (KbT <= 0.00048) tmp = Float64(t_1 + Float64(KbT * Float64(NaChar / EAccept))); else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_2 = t_1 + (NaChar * 0.5); tmp = 0.0; if (KbT <= -4.8e+151) tmp = t_2; elseif (KbT <= -6.4e-9) tmp = t_0 + (0.25 * (NdChar / (KbT / Ec))); elseif (KbT <= -1.5e-111) tmp = t_0 + (NdChar * 0.5); elseif (KbT <= 4.7e-182) tmp = t_1 + (NaChar / (Vef / KbT)); elseif (KbT <= 0.00048) tmp = t_1 + (KbT * (NaChar / EAccept)); else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -4.8e+151], t$95$2, If[LessEqual[KbT, -6.4e-9], N[(t$95$0 + N[(0.25 * N[(NdChar / N[(KbT / Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -1.5e-111], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4.7e-182], N[(t$95$1 + N[(NaChar / N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 0.00048], N[(t$95$1 + N[(KbT * N[(NaChar / EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_2 := t_1 + NaChar \cdot 0.5\\
\mathbf{if}\;KbT \leq -4.8 \cdot 10^{+151}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;KbT \leq -6.4 \cdot 10^{-9}:\\
\;\;\;\;t_0 + 0.25 \cdot \frac{NdChar}{\frac{KbT}{Ec}}\\
\mathbf{elif}\;KbT \leq -1.5 \cdot 10^{-111}:\\
\;\;\;\;t_0 + NdChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 4.7 \cdot 10^{-182}:\\
\;\;\;\;t_1 + \frac{NaChar}{\frac{Vef}{KbT}}\\
\mathbf{elif}\;KbT \leq 0.00048:\\
\;\;\;\;t_1 + KbT \cdot \frac{NaChar}{EAccept}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if KbT < -4.8000000000000002e151 or 4.80000000000000012e-4 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 66.4%
Taylor expanded in KbT around inf 66.4%
if -4.8000000000000002e151 < KbT < -6.40000000000000023e-9Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 29.6%
Taylor expanded in Ec around inf 50.2%
associate-/l*50.2%
Simplified50.2%
if -6.40000000000000023e-9 < KbT < -1.50000000000000004e-111Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 47.2%
*-commutative6.6%
Simplified47.2%
if -1.50000000000000004e-111 < KbT < 4.7e-182Initial 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.3%
Taylor expanded in Vef around inf 52.9%
associate-/l*59.1%
Simplified59.1%
if 4.7e-182 < KbT < 4.80000000000000012e-4Initial 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 44.7%
Taylor expanded in EAccept around inf 40.2%
associate-/l*40.0%
Simplified40.0%
associate-/r/40.1%
Applied egg-rr40.1%
Final simplification56.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 (<= NdChar -6.6e+133)
(+ t_0 (* NaChar 0.5))
(if (<= NdChar -1750000000.0)
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(if (<= NdChar 8.2e+182)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 2.0 (/ EDonor KbT))))
(- t_0 (/ NaChar (/ mu KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -6.6e+133) {
tmp = t_0 + (NaChar * 0.5);
} else if (NdChar <= -1750000000.0) {
tmp = NdChar / (1.0 + exp((EDonor / KbT)));
} else if (NdChar <= 8.2e+182) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (2.0 + (EDonor / KbT)));
} else {
tmp = t_0 - (NaChar / (mu / KbT));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ndchar <= (-6.6d+133)) then
tmp = t_0 + (nachar * 0.5d0)
else if (ndchar <= (-1750000000.0d0)) then
tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
else if (ndchar <= 8.2d+182) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (2.0d0 + (edonor / kbt)))
else
tmp = t_0 - (nachar / (mu / kbt))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -6.6e+133) {
tmp = t_0 + (NaChar * 0.5);
} else if (NdChar <= -1750000000.0) {
tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
} else if (NdChar <= 8.2e+182) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (2.0 + (EDonor / KbT)));
} else {
tmp = t_0 - (NaChar / (mu / KbT));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if NdChar <= -6.6e+133: tmp = t_0 + (NaChar * 0.5) elif NdChar <= -1750000000.0: tmp = NdChar / (1.0 + math.exp((EDonor / KbT))) elif NdChar <= 8.2e+182: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (2.0 + (EDonor / KbT))) else: tmp = t_0 - (NaChar / (mu / KbT)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (NdChar <= -6.6e+133) tmp = Float64(t_0 + Float64(NaChar * 0.5)); elseif (NdChar <= -1750000000.0) tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))); elseif (NdChar <= 8.2e+182) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(EDonor / KbT)))); else tmp = Float64(t_0 - Float64(NaChar / Float64(mu / KbT))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (NdChar <= -6.6e+133) tmp = t_0 + (NaChar * 0.5); elseif (NdChar <= -1750000000.0) tmp = NdChar / (1.0 + exp((EDonor / KbT))); elseif (NdChar <= 8.2e+182) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (2.0 + (EDonor / KbT))); else tmp = t_0 - (NaChar / (mu / KbT)); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -6.6e+133], N[(t$95$0 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -1750000000.0], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 8.2e+182], 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[(2.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 - N[(NaChar / N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;NdChar \leq -6.6 \cdot 10^{+133}:\\
\;\;\;\;t_0 + NaChar \cdot 0.5\\
\mathbf{elif}\;NdChar \leq -1750000000:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;NdChar \leq 8.2 \cdot 10^{+182}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{2 + \frac{EDonor}{KbT}}\\
\mathbf{else}:\\
\;\;\;\;t_0 - \frac{NaChar}{\frac{mu}{KbT}}\\
\end{array}
\end{array}
if NdChar < -6.6e133Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 56.3%
Taylor expanded in KbT around inf 62.9%
if -6.6e133 < NdChar < -1.75e9Initial 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.0%
Taylor expanded in EAccept around inf 49.8%
associate-/l*49.0%
Simplified49.0%
Taylor expanded in EDonor around inf 37.7%
Taylor expanded in NdChar around inf 61.7%
if -1.75e9 < NdChar < 8.20000000000000006e182Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EDonor around inf 73.6%
Taylor expanded in EDonor around 0 57.9%
if 8.20000000000000006e182 < 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 72.9%
Taylor expanded in mu around inf 56.5%
mul-1-neg56.5%
associate-/l*63.2%
distribute-neg-frac63.2%
Simplified63.2%
Final simplification59.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 (+ t_0 (* NaChar 0.5)))
(t_2
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))))
(if (<= NaChar -400.0)
t_2
(if (<= NaChar -2.9e-244)
t_1
(if (<= NaChar 2.6e-305)
(+ t_0 (* KbT (/ NaChar EAccept)))
(if (<= NaChar 2.7e-52) 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 * 0.5);
double t_2 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
double tmp;
if (NaChar <= -400.0) {
tmp = t_2;
} else if (NaChar <= -2.9e-244) {
tmp = t_1;
} else if (NaChar <= 2.6e-305) {
tmp = t_0 + (KbT * (NaChar / EAccept));
} else if (NaChar <= 2.7e-52) {
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 * 0.5d0)
t_2 = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
if (nachar <= (-400.0d0)) then
tmp = t_2
else if (nachar <= (-2.9d-244)) then
tmp = t_1
else if (nachar <= 2.6d-305) then
tmp = t_0 + (kbt * (nachar / eaccept))
else if (nachar <= 2.7d-52) 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 * 0.5);
double t_2 = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
double tmp;
if (NaChar <= -400.0) {
tmp = t_2;
} else if (NaChar <= -2.9e-244) {
tmp = t_1;
} else if (NaChar <= 2.6e-305) {
tmp = t_0 + (KbT * (NaChar / EAccept));
} else if (NaChar <= 2.7e-52) {
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 * 0.5) t_2 = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) tmp = 0 if NaChar <= -400.0: tmp = t_2 elif NaChar <= -2.9e-244: tmp = t_1 elif NaChar <= 2.6e-305: tmp = t_0 + (KbT * (NaChar / EAccept)) elif NaChar <= 2.7e-52: 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 * 0.5)) 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 <= -400.0) tmp = t_2; elseif (NaChar <= -2.9e-244) tmp = t_1; elseif (NaChar <= 2.6e-305) tmp = Float64(t_0 + Float64(KbT * Float64(NaChar / EAccept))); elseif (NaChar <= 2.7e-52) 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 * 0.5); t_2 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); tmp = 0.0; if (NaChar <= -400.0) tmp = t_2; elseif (NaChar <= -2.9e-244) tmp = t_1; elseif (NaChar <= 2.6e-305) tmp = t_0 + (KbT * (NaChar / EAccept)); elseif (NaChar <= 2.7e-52) 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 * 0.5), $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, -400.0], t$95$2, If[LessEqual[NaChar, -2.9e-244], t$95$1, If[LessEqual[NaChar, 2.6e-305], N[(t$95$0 + N[(KbT * N[(NaChar / EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.7e-52], 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 + NaChar \cdot 0.5\\
t_2 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{if}\;NaChar \leq -400:\\
\;\;\;\;t_2\\
\mathbf{elif}\;NaChar \leq -2.9 \cdot 10^{-244}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NaChar \leq 2.6 \cdot 10^{-305}:\\
\;\;\;\;t_0 + KbT \cdot \frac{NaChar}{EAccept}\\
\mathbf{elif}\;NaChar \leq 2.7 \cdot 10^{-52}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if NaChar < -400 or 2.70000000000000009e-52 < 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.1%
*-commutative7.7%
Simplified52.1%
if -400 < NaChar < -2.89999999999999996e-244 or 2.6000000000000002e-305 < NaChar < 2.70000000000000009e-52Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 65.1%
Taylor expanded in KbT around inf 58.6%
if -2.89999999999999996e-244 < NaChar < 2.6000000000000002e-305Initial 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 76.4%
Taylor expanded in EAccept around inf 86.0%
associate-/l*76.9%
Simplified76.9%
associate-/r/100.0%
Applied egg-rr100.0%
Final simplification56.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 (<= KbT -4.9e-111)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))
(if (<= KbT 8.6e-181)
(+ t_0 (/ NaChar (/ Vef KbT)))
(if (<= KbT 0.00014)
(+ t_0 (* KbT (/ NaChar EAccept)))
(+ t_0 (* NaChar 0.5)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (KbT <= -4.9e-111) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else if (KbT <= 8.6e-181) {
tmp = t_0 + (NaChar / (Vef / KbT));
} else if (KbT <= 0.00014) {
tmp = t_0 + (KbT * (NaChar / EAccept));
} else {
tmp = t_0 + (NaChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (kbt <= (-4.9d-111)) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
else if (kbt <= 8.6d-181) then
tmp = t_0 + (nachar / (vef / kbt))
else if (kbt <= 0.00014d0) then
tmp = t_0 + (kbt * (nachar / eaccept))
else
tmp = t_0 + (nachar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (KbT <= -4.9e-111) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else if (KbT <= 8.6e-181) {
tmp = t_0 + (NaChar / (Vef / KbT));
} else if (KbT <= 0.00014) {
tmp = t_0 + (KbT * (NaChar / EAccept));
} else {
tmp = t_0 + (NaChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if KbT <= -4.9e-111: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) elif KbT <= 8.6e-181: tmp = t_0 + (NaChar / (Vef / KbT)) elif KbT <= 0.00014: tmp = t_0 + (KbT * (NaChar / EAccept)) else: tmp = t_0 + (NaChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (KbT <= -4.9e-111) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar * 0.5)); elseif (KbT <= 8.6e-181) tmp = Float64(t_0 + Float64(NaChar / Float64(Vef / KbT))); elseif (KbT <= 0.00014) tmp = Float64(t_0 + Float64(KbT * Float64(NaChar / EAccept))); else tmp = Float64(t_0 + Float64(NaChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (KbT <= -4.9e-111) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); elseif (KbT <= 8.6e-181) tmp = t_0 + (NaChar / (Vef / KbT)); elseif (KbT <= 0.00014) tmp = t_0 + (KbT * (NaChar / EAccept)); else tmp = t_0 + (NaChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -4.9e-111], 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[KbT, 8.6e-181], N[(t$95$0 + N[(NaChar / N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 0.00014], N[(t$95$0 + N[(KbT * N[(NaChar / EAccept), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;KbT \leq -4.9 \cdot 10^{-111}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 8.6 \cdot 10^{-181}:\\
\;\;\;\;t_0 + \frac{NaChar}{\frac{Vef}{KbT}}\\
\mathbf{elif}\;KbT \leq 0.00014:\\
\;\;\;\;t_0 + KbT \cdot \frac{NaChar}{EAccept}\\
\mathbf{else}:\\
\;\;\;\;t_0 + NaChar \cdot 0.5\\
\end{array}
\end{array}
if KbT < -4.90000000000000019e-111Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 53.3%
*-commutative13.8%
Simplified53.3%
if -4.90000000000000019e-111 < KbT < 8.6e-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 KbT around inf 43.3%
Taylor expanded in Vef around inf 52.9%
associate-/l*59.1%
Simplified59.1%
if 8.6e-181 < KbT < 1.3999999999999999e-4Initial 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 44.7%
Taylor expanded in EAccept around inf 40.2%
associate-/l*40.0%
Simplified40.0%
associate-/r/40.1%
Applied egg-rr40.1%
if 1.3999999999999999e-4 < KbT Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in KbT around inf 58.1%
Taylor expanded in KbT around inf 57.7%
Final simplification53.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (- -1.0 (/ Vef KbT)))
(t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(t_2 (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))
(if (<= KbT -9.8e+42)
t_2
(if (<= KbT -2.5e-37)
t_1
(if (<= KbT -2.5e-98)
t_2
(if (<= KbT 3.85e-168)
t_1
(if (<= KbT 2.1e-63)
(+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= KbT 2.1e+219)
t_1
(+
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ EDonor KbT) (/ Vef KbT))))
(/ Ec KbT))))
(/
NaChar
(+
1.0
(-
(+
(/ Ev KbT)
(/
(+
(* (/ EAccept KbT) (/ EAccept KbT))
(* (+ 1.0 (/ Vef KbT)) t_0))
(+ (/ EAccept KbT) t_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 = -1.0 - (Vef / KbT);
double t_1 = NdChar / (1.0 + exp((EDonor / KbT)));
double t_2 = (NdChar * 0.5) + (NaChar / (1.0 + exp((EAccept / KbT))));
double tmp;
if (KbT <= -9.8e+42) {
tmp = t_2;
} else if (KbT <= -2.5e-37) {
tmp = t_1;
} else if (KbT <= -2.5e-98) {
tmp = t_2;
} else if (KbT <= 3.85e-168) {
tmp = t_1;
} else if (KbT <= 2.1e-63) {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (KbT <= 2.1e+219) {
tmp = t_1;
} else {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_0)) / ((EAccept / KbT) + t_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) :: t_2
real(8) :: tmp
t_0 = (-1.0d0) - (vef / kbt)
t_1 = ndchar / (1.0d0 + exp((edonor / kbt)))
t_2 = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
if (kbt <= (-9.8d+42)) then
tmp = t_2
else if (kbt <= (-2.5d-37)) then
tmp = t_1
else if (kbt <= (-2.5d-98)) then
tmp = t_2
else if (kbt <= 3.85d-168) then
tmp = t_1
else if (kbt <= 2.1d-63) then
tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((ev / kbt))))
else if (kbt <= 2.1d+219) then
tmp = t_1
else
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((edonor / kbt) + (vef / kbt)))) - (ec / kbt)))) + (nachar / (1.0d0 + (((ev / kbt) + ((((eaccept / kbt) * (eaccept / kbt)) + ((1.0d0 + (vef / kbt)) * t_0)) / ((eaccept / kbt) + t_0))) - (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 = -1.0 - (Vef / KbT);
double t_1 = NdChar / (1.0 + Math.exp((EDonor / KbT)));
double t_2 = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
double tmp;
if (KbT <= -9.8e+42) {
tmp = t_2;
} else if (KbT <= -2.5e-37) {
tmp = t_1;
} else if (KbT <= -2.5e-98) {
tmp = t_2;
} else if (KbT <= 3.85e-168) {
tmp = t_1;
} else if (KbT <= 2.1e-63) {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (KbT <= 2.1e+219) {
tmp = t_1;
} else {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_0)) / ((EAccept / KbT) + t_0))) - (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = -1.0 - (Vef / KbT) t_1 = NdChar / (1.0 + math.exp((EDonor / KbT))) t_2 = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) tmp = 0 if KbT <= -9.8e+42: tmp = t_2 elif KbT <= -2.5e-37: tmp = t_1 elif KbT <= -2.5e-98: tmp = t_2 elif KbT <= 3.85e-168: tmp = t_1 elif KbT <= 2.1e-63: tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif KbT <= 2.1e+219: tmp = t_1 else: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_0)) / ((EAccept / KbT) + t_0))) - (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(-1.0 - Float64(Vef / KbT)) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) t_2 = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))) tmp = 0.0 if (KbT <= -9.8e+42) tmp = t_2; elseif (KbT <= -2.5e-37) tmp = t_1; elseif (KbT <= -2.5e-98) tmp = t_2; elseif (KbT <= 3.85e-168) tmp = t_1; elseif (KbT <= 2.1e-63) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (KbT <= 2.1e+219) tmp = t_1; else tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(Float64(Float64(EAccept / KbT) * Float64(EAccept / KbT)) + Float64(Float64(1.0 + Float64(Vef / KbT)) * t_0)) / Float64(Float64(EAccept / KbT) + t_0))) - Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = -1.0 - (Vef / KbT); t_1 = NdChar / (1.0 + exp((EDonor / KbT))); t_2 = (NdChar * 0.5) + (NaChar / (1.0 + exp((EAccept / KbT)))); tmp = 0.0; if (KbT <= -9.8e+42) tmp = t_2; elseif (KbT <= -2.5e-37) tmp = t_1; elseif (KbT <= -2.5e-98) tmp = t_2; elseif (KbT <= 3.85e-168) tmp = t_1; elseif (KbT <= 2.1e-63) tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (KbT <= 2.1e+219) tmp = t_1; else tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_0)) / ((EAccept / KbT) + t_0))) - (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(-1.0 - N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -9.8e+42], t$95$2, If[LessEqual[KbT, -2.5e-37], t$95$1, If[LessEqual[KbT, -2.5e-98], t$95$2, If[LessEqual[KbT, 3.85e-168], t$95$1, If[LessEqual[KbT, 2.1e-63], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.1e+219], t$95$1, N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(N[(N[(EAccept / KbT), $MachinePrecision] * N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision] / N[(N[(EAccept / KbT), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := -1 - \frac{Vef}{KbT}\\
t_1 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
t_2 := NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{if}\;KbT \leq -9.8 \cdot 10^{+42}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;KbT \leq -2.5 \cdot 10^{-37}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;KbT \leq -2.5 \cdot 10^{-98}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;KbT \leq 3.85 \cdot 10^{-168}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;KbT \leq 2.1 \cdot 10^{-63}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;KbT \leq 2.1 \cdot 10^{+219}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{EDonor}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \frac{\frac{EAccept}{KbT} \cdot \frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right) \cdot t_0}{\frac{EAccept}{KbT} + t_0}\right) - \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if KbT < -9.8000000000000004e42 or -2.4999999999999999e-37 < KbT < -2.50000000000000009e-98Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 60.6%
*-commutative16.4%
Simplified60.6%
Taylor expanded in EAccept around inf 48.9%
if -9.8000000000000004e42 < KbT < -2.4999999999999999e-37 or -2.50000000000000009e-98 < KbT < 3.84999999999999985e-168 or 2.1e-63 < KbT < 2.09999999999999988e219Initial 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.8%
Taylor expanded in EAccept around inf 35.3%
associate-/l*35.2%
Simplified35.2%
Taylor expanded in EDonor around inf 21.5%
Taylor expanded in NdChar around inf 43.5%
if 3.84999999999999985e-168 < KbT < 2.1e-63Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 34.2%
*-commutative5.7%
Simplified34.2%
Taylor expanded in Ev around inf 21.7%
if 2.09999999999999988e219 < KbT Initial program 99.5%
neg-sub099.5%
associate--r-99.5%
+-commutative99.5%
neg-sub099.5%
sub-neg99.5%
associate--l-99.5%
unsub-neg99.5%
+-commutative99.5%
associate-+l+99.5%
Simplified99.5%
Taylor expanded in KbT around inf 96.2%
flip-+96.2%
Applied egg-rr96.2%
Taylor expanded in KbT around inf 85.5%
Final simplification46.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -30000.0) (not (<= NaChar 6e-76)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -30000.0) || !(NaChar <= 6e-76)) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = NdChar / (1.0 + exp((EDonor / KbT)));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((nachar <= (-30000.0d0)) .or. (.not. (nachar <= 6d-76))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar * 0.5d0)
else
tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -30000.0) || !(NaChar <= 6e-76)) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5);
} else {
tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -30000.0) or not (NaChar <= 6e-76): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5) else: tmp = NdChar / (1.0 + math.exp((EDonor / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -30000.0) || !(NaChar <= 6e-76)) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar * 0.5)); else tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -30000.0) || ~((NaChar <= 6e-76))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar * 0.5); else tmp = NdChar / (1.0 + exp((EDonor / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -30000.0], N[Not[LessEqual[NaChar, 6e-76]], $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[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -30000 \lor \neg \left(NaChar \leq 6 \cdot 10^{-76}\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{EDonor}{KbT}}}\\
\end{array}
\end{array}
if NaChar < -3e4 or 6.00000000000000048e-76 < 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.1%
*-commutative8.4%
Simplified53.1%
if -3e4 < NaChar < 6.00000000000000048e-76Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 65.0%
Taylor expanded in EAccept around inf 45.1%
associate-/l*42.0%
Simplified42.0%
Taylor expanded in EDonor around inf 28.6%
Taylor expanded in NdChar around inf 51.4%
Final simplification52.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -21.0) (not (<= NaChar 1.6e-51)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(* NdChar 0.5))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(* NaChar 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 <= -21.0) || !(NaChar <= 1.6e-51)) {
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 * 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 <= (-21.0d0)) .or. (.not. (nachar <= 1.6d-51))) 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 * 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 <= -21.0) || !(NaChar <= 1.6e-51)) {
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 * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -21.0) or not (NaChar <= 1.6e-51): 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 * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -21.0) || !(NaChar <= 1.6e-51)) 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 * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -21.0) || ~((NaChar <= 1.6e-51))) 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 * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -21.0], N[Not[LessEqual[NaChar, 1.6e-51]], $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 * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -21 \lor \neg \left(NaChar \leq 1.6 \cdot 10^{-51}\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}}} + NaChar \cdot 0.5\\
\end{array}
\end{array}
if NaChar < -21 or 1.6e-51 < 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.1%
*-commutative7.7%
Simplified52.1%
if -21 < NaChar < 1.6e-51Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 66.2%
Taylor expanded in KbT around inf 58.6%
Final simplification55.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= EDonor -5e+248)
(+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(if (or (<= EDonor -3.2e-146) (not (<= EDonor 5e-10)))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (EDonor <= -5e+248) {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((EAccept / KbT))));
} else if ((EDonor <= -3.2e-146) || !(EDonor <= 5e-10)) {
tmp = NdChar / (1.0 + exp((EDonor / KbT)));
} else {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Vef / 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 (edonor <= (-5d+248)) then
tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
else if ((edonor <= (-3.2d-146)) .or. (.not. (edonor <= 5d-10))) then
tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
else
tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((vef / 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 (EDonor <= -5e+248) {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else if ((EDonor <= -3.2e-146) || !(EDonor <= 5e-10)) {
tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
} else {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((Vef / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if EDonor <= -5e+248: tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) elif (EDonor <= -3.2e-146) or not (EDonor <= 5e-10): tmp = NdChar / (1.0 + math.exp((EDonor / KbT))) else: tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((Vef / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (EDonor <= -5e+248) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); elseif ((EDonor <= -3.2e-146) || !(EDonor <= 5e-10)) tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))); else tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (EDonor <= -5e+248) tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((EAccept / KbT)))); elseif ((EDonor <= -3.2e-146) || ~((EDonor <= 5e-10))) tmp = NdChar / (1.0 + exp((EDonor / KbT))); else tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((Vef / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EDonor, -5e+248], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EDonor, -3.2e-146], N[Not[LessEqual[EDonor, 5e-10]], $MachinePrecision]], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;EDonor \leq -5 \cdot 10^{+248}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{elif}\;EDonor \leq -3.2 \cdot 10^{-146} \lor \neg \left(EDonor \leq 5 \cdot 10^{-10}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\end{array}
\end{array}
if EDonor < -4.9999999999999996e248Initial 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%
*-commutative5.2%
Simplified62.9%
Taylor expanded in EAccept around inf 47.9%
if -4.9999999999999996e248 < EDonor < -3.1999999999999999e-146 or 5.00000000000000031e-10 < EDonor Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 52.6%
Taylor expanded in EAccept around inf 29.8%
associate-/l*29.7%
Simplified29.7%
Taylor expanded in EDonor around inf 21.5%
Taylor expanded in NdChar around inf 48.5%
if -3.1999999999999999e-146 < EDonor < 5.00000000000000031e-10Initial 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 47.3%
*-commutative13.9%
Simplified47.3%
Taylor expanded in Vef around inf 37.8%
Final simplification44.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= EDonor -6e+248)
(+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(if (or (<= EDonor -1.35e-110) (not (<= EDonor 7.5e-9)))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(+ (/ NdChar (+ 1.0 (exp (/ mu 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 (EDonor <= -6e+248) {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((EAccept / KbT))));
} else if ((EDonor <= -1.35e-110) || !(EDonor <= 7.5e-9)) {
tmp = NdChar / (1.0 + exp((EDonor / KbT)));
} else {
tmp = (NdChar / (1.0 + exp((mu / 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 (edonor <= (-6d+248)) then
tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
else if ((edonor <= (-1.35d-110)) .or. (.not. (edonor <= 7.5d-9))) then
tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
else
tmp = (ndchar / (1.0d0 + exp((mu / 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 (EDonor <= -6e+248) {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else if ((EDonor <= -1.35e-110) || !(EDonor <= 7.5e-9)) {
tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
} else {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if EDonor <= -6e+248: tmp = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) elif (EDonor <= -1.35e-110) or not (EDonor <= 7.5e-9): tmp = NdChar / (1.0 + math.exp((EDonor / KbT))) else: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (EDonor <= -6e+248) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); elseif ((EDonor <= -1.35e-110) || !(EDonor <= 7.5e-9)) tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / 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 (EDonor <= -6e+248) tmp = (NdChar * 0.5) + (NaChar / (1.0 + exp((EAccept / KbT)))); elseif ((EDonor <= -1.35e-110) || ~((EDonor <= 7.5e-9))) tmp = NdChar / (1.0 + exp((EDonor / KbT))); else tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EDonor, -6e+248], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EDonor, -1.35e-110], N[Not[LessEqual[EDonor, 7.5e-9]], $MachinePrecision]], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;EDonor \leq -6 \cdot 10^{+248}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{elif}\;EDonor \leq -1.35 \cdot 10^{-110} \lor \neg \left(EDonor \leq 7.5 \cdot 10^{-9}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\
\end{array}
\end{array}
if EDonor < -6e248Initial 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%
*-commutative5.2%
Simplified62.9%
Taylor expanded in EAccept around inf 47.9%
if -6e248 < EDonor < -1.3499999999999999e-110 or 7.49999999999999933e-9 < EDonor Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 52.2%
Taylor expanded in EAccept around inf 29.7%
associate-/l*29.5%
Simplified29.5%
Taylor expanded in EDonor around inf 21.8%
Taylor expanded in NdChar around inf 49.2%
if -1.3499999999999999e-110 < EDonor < 7.49999999999999933e-9Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 70.1%
Taylor expanded in KbT around inf 38.9%
Final simplification45.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(t_1 (+ (* NdChar 0.5) (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(t_2 (- -1.0 (/ Vef KbT))))
(if (<= KbT -1.65e+38)
t_1
(if (<= KbT -2.85e-37)
t_0
(if (<= KbT -1.45e-98)
t_1
(if (<= KbT 5.8e+219)
t_0
(+
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ EDonor KbT) (/ Vef KbT))))
(/ Ec KbT))))
(/
NaChar
(+
1.0
(-
(+
(/ Ev KbT)
(/
(+
(* (/ EAccept KbT) (/ EAccept KbT))
(* (+ 1.0 (/ Vef KbT)) t_2))
(+ (/ EAccept KbT) t_2)))
(/ 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((EDonor / KbT)));
double t_1 = (NdChar * 0.5) + (NaChar / (1.0 + exp((EAccept / KbT))));
double t_2 = -1.0 - (Vef / KbT);
double tmp;
if (KbT <= -1.65e+38) {
tmp = t_1;
} else if (KbT <= -2.85e-37) {
tmp = t_0;
} else if (KbT <= -1.45e-98) {
tmp = t_1;
} else if (KbT <= 5.8e+219) {
tmp = t_0;
} else {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_2)) / ((EAccept / KbT) + t_2))) - (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp((edonor / kbt)))
t_1 = (ndchar * 0.5d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
t_2 = (-1.0d0) - (vef / kbt)
if (kbt <= (-1.65d+38)) then
tmp = t_1
else if (kbt <= (-2.85d-37)) then
tmp = t_0
else if (kbt <= (-1.45d-98)) then
tmp = t_1
else if (kbt <= 5.8d+219) then
tmp = t_0
else
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((edonor / kbt) + (vef / kbt)))) - (ec / kbt)))) + (nachar / (1.0d0 + (((ev / kbt) + ((((eaccept / kbt) * (eaccept / kbt)) + ((1.0d0 + (vef / kbt)) * t_2)) / ((eaccept / kbt) + t_2))) - (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((EDonor / KbT)));
double t_1 = (NdChar * 0.5) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
double t_2 = -1.0 - (Vef / KbT);
double tmp;
if (KbT <= -1.65e+38) {
tmp = t_1;
} else if (KbT <= -2.85e-37) {
tmp = t_0;
} else if (KbT <= -1.45e-98) {
tmp = t_1;
} else if (KbT <= 5.8e+219) {
tmp = t_0;
} else {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_2)) / ((EAccept / KbT) + t_2))) - (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp((EDonor / KbT))) t_1 = (NdChar * 0.5) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) t_2 = -1.0 - (Vef / KbT) tmp = 0 if KbT <= -1.65e+38: tmp = t_1 elif KbT <= -2.85e-37: tmp = t_0 elif KbT <= -1.45e-98: tmp = t_1 elif KbT <= 5.8e+219: tmp = t_0 else: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_2)) / ((EAccept / KbT) + t_2))) - (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) t_1 = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))) t_2 = Float64(-1.0 - Float64(Vef / KbT)) tmp = 0.0 if (KbT <= -1.65e+38) tmp = t_1; elseif (KbT <= -2.85e-37) tmp = t_0; elseif (KbT <= -1.45e-98) tmp = t_1; elseif (KbT <= 5.8e+219) tmp = t_0; else tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(Float64(Float64(EAccept / KbT) * Float64(EAccept / KbT)) + Float64(Float64(1.0 + Float64(Vef / KbT)) * t_2)) / Float64(Float64(EAccept / KbT) + t_2))) - 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((EDonor / KbT))); t_1 = (NdChar * 0.5) + (NaChar / (1.0 + exp((EAccept / KbT)))); t_2 = -1.0 - (Vef / KbT); tmp = 0.0; if (KbT <= -1.65e+38) tmp = t_1; elseif (KbT <= -2.85e-37) tmp = t_0; elseif (KbT <= -1.45e-98) tmp = t_1; elseif (KbT <= 5.8e+219) tmp = t_0; else tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_2)) / ((EAccept / KbT) + t_2))) - (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[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(-1.0 - N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.65e+38], t$95$1, If[LessEqual[KbT, -2.85e-37], t$95$0, If[LessEqual[KbT, -1.45e-98], t$95$1, If[LessEqual[KbT, 5.8e+219], t$95$0, N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(N[(N[(EAccept / KbT), $MachinePrecision] * N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision] / N[(N[(EAccept / KbT), $MachinePrecision] + t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
t_1 := NdChar \cdot 0.5 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
t_2 := -1 - \frac{Vef}{KbT}\\
\mathbf{if}\;KbT \leq -1.65 \cdot 10^{+38}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;KbT \leq -2.85 \cdot 10^{-37}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;KbT \leq -1.45 \cdot 10^{-98}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;KbT \leq 5.8 \cdot 10^{+219}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{EDonor}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \frac{\frac{EAccept}{KbT} \cdot \frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right) \cdot t_2}{\frac{EAccept}{KbT} + t_2}\right) - \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if KbT < -1.65e38 or -2.84999999999999987e-37 < KbT < -1.45e-98Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 60.6%
*-commutative16.4%
Simplified60.6%
Taylor expanded in EAccept around inf 48.9%
if -1.65e38 < KbT < -2.84999999999999987e-37 or -1.45e-98 < KbT < 5.79999999999999958e219Initial 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 44.2%
Taylor expanded in EAccept around inf 34.2%
associate-/l*34.1%
Simplified34.1%
Taylor expanded in EDonor around inf 19.3%
Taylor expanded in NdChar around inf 39.1%
if 5.79999999999999958e219 < KbT Initial program 99.5%
neg-sub099.5%
associate--r-99.5%
+-commutative99.5%
neg-sub099.5%
sub-neg99.5%
associate--l-99.5%
unsub-neg99.5%
+-commutative99.5%
associate-+l+99.5%
Simplified99.5%
Taylor expanded in KbT around inf 96.2%
flip-+96.2%
Applied egg-rr96.2%
Taylor expanded in KbT around inf 85.5%
Final simplification44.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (- -1.0 (/ Vef KbT))))
(if (<= KbT -6e+163)
(+ (* NdChar 0.5) (/ NaChar 2.0))
(if (<= KbT 5.8e+219)
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(+
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ EDonor KbT) (/ Vef KbT))))
(/ Ec KbT))))
(/
NaChar
(+
1.0
(-
(+
(/ Ev KbT)
(/
(+
(* (/ EAccept KbT) (/ EAccept KbT))
(* (+ 1.0 (/ Vef KbT)) t_0))
(+ (/ EAccept KbT) t_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 = -1.0 - (Vef / KbT);
double tmp;
if (KbT <= -6e+163) {
tmp = (NdChar * 0.5) + (NaChar / 2.0);
} else if (KbT <= 5.8e+219) {
tmp = NdChar / (1.0 + exp((EDonor / KbT)));
} else {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_0)) / ((EAccept / KbT) + t_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) :: tmp
t_0 = (-1.0d0) - (vef / kbt)
if (kbt <= (-6d+163)) then
tmp = (ndchar * 0.5d0) + (nachar / 2.0d0)
else if (kbt <= 5.8d+219) then
tmp = ndchar / (1.0d0 + exp((edonor / kbt)))
else
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((edonor / kbt) + (vef / kbt)))) - (ec / kbt)))) + (nachar / (1.0d0 + (((ev / kbt) + ((((eaccept / kbt) * (eaccept / kbt)) + ((1.0d0 + (vef / kbt)) * t_0)) / ((eaccept / kbt) + t_0))) - (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 = -1.0 - (Vef / KbT);
double tmp;
if (KbT <= -6e+163) {
tmp = (NdChar * 0.5) + (NaChar / 2.0);
} else if (KbT <= 5.8e+219) {
tmp = NdChar / (1.0 + Math.exp((EDonor / KbT)));
} else {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_0)) / ((EAccept / KbT) + t_0))) - (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = -1.0 - (Vef / KbT) tmp = 0 if KbT <= -6e+163: tmp = (NdChar * 0.5) + (NaChar / 2.0) elif KbT <= 5.8e+219: tmp = NdChar / (1.0 + math.exp((EDonor / KbT))) else: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_0)) / ((EAccept / KbT) + t_0))) - (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(-1.0 - Float64(Vef / KbT)) tmp = 0.0 if (KbT <= -6e+163) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / 2.0)); elseif (KbT <= 5.8e+219) tmp = Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))); else tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(EDonor / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(Float64(Float64(EAccept / KbT) * Float64(EAccept / KbT)) + Float64(Float64(1.0 + Float64(Vef / KbT)) * t_0)) / Float64(Float64(EAccept / KbT) + t_0))) - Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = -1.0 - (Vef / KbT); tmp = 0.0; if (KbT <= -6e+163) tmp = (NdChar * 0.5) + (NaChar / 2.0); elseif (KbT <= 5.8e+219) tmp = NdChar / (1.0 + exp((EDonor / KbT))); else tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((EDonor / KbT) + (Vef / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((((EAccept / KbT) * (EAccept / KbT)) + ((1.0 + (Vef / KbT)) * t_0)) / ((EAccept / KbT) + t_0))) - (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(-1.0 - N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -6e+163], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 5.8e+219], N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(N[(N[(EAccept / KbT), $MachinePrecision] * N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision] / N[(N[(EAccept / KbT), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := -1 - \frac{Vef}{KbT}\\
\mathbf{if}\;KbT \leq -6 \cdot 10^{+163}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\
\mathbf{elif}\;KbT \leq 5.8 \cdot 10^{+219}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{EDonor}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \frac{\frac{EAccept}{KbT} \cdot \frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right) \cdot t_0}{\frac{EAccept}{KbT} + t_0}\right) - \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if KbT < -6.00000000000000027e163Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 78.9%
*-commutative27.0%
Simplified78.9%
Taylor expanded in KbT around inf 70.1%
if -6.00000000000000027e163 < KbT < 5.79999999999999958e219Initial 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 42.8%
Taylor expanded in EAccept around inf 31.7%
associate-/l*31.7%
Simplified31.7%
Taylor expanded in EDonor around inf 17.9%
Taylor expanded in NdChar around inf 35.7%
if 5.79999999999999958e219 < KbT Initial program 99.5%
neg-sub099.5%
associate--r-99.5%
+-commutative99.5%
neg-sub099.5%
sub-neg99.5%
associate--l-99.5%
unsub-neg99.5%
+-commutative99.5%
associate-+l+99.5%
Simplified99.5%
Taylor expanded in KbT around inf 96.2%
flip-+96.2%
Applied egg-rr96.2%
Taylor expanded in KbT around inf 85.5%
Final simplification42.8%
(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 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 44.2%
*-commutative11.9%
Simplified44.2%
Taylor expanded in KbT around inf 26.5%
Final simplification26.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (/ (* KbT NaChar) EAccept))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (KbT * NaChar) / EAccept;
}
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 = (kbt * nachar) / eaccept
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 (KbT * NaChar) / EAccept;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (KbT * NaChar) / EAccept
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(KbT * NaChar) / EAccept) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (KbT * NaChar) / EAccept; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(KbT * NaChar), $MachinePrecision] / EAccept), $MachinePrecision]
\begin{array}{l}
\\
\frac{KbT \cdot NaChar}{EAccept}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 50.4%
Taylor expanded in EAccept around inf 30.7%
associate-/l*30.5%
Simplified30.5%
Taylor expanded in KbT around inf 11.9%
*-commutative11.9%
Simplified11.9%
Taylor expanded in NdChar around 0 7.0%
Final simplification7.0%
herbie shell --seed 2023217
(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))))))