
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 26 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}}
\end{array}
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(+
(/
NdChar
(+
1.0
(pow
(cbrt (pow (pow (exp (/ (+ (+ Vef EDonor) (- mu Ec)) KbT)) 3.0) 3.0))
0.3333333333333333)))
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + pow(cbrt(pow(pow(exp((((Vef + EDonor) + (mu - Ec)) / KbT)), 3.0), 3.0)), 0.3333333333333333))) + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.pow(Math.cbrt(Math.pow(Math.pow(Math.exp((((Vef + EDonor) + (mu - Ec)) / KbT)), 3.0), 3.0)), 0.3333333333333333))) + (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + (cbrt(((exp(Float64(Float64(Float64(Vef + EDonor) + Float64(mu - Ec)) / KbT)) ^ 3.0) ^ 3.0)) ^ 0.3333333333333333))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))) end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Power[N[Power[N[Power[N[Power[N[Exp[N[(N[(N[(Vef + EDonor), $MachinePrecision] + N[(mu - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision], 3.0], $MachinePrecision], 3.0], $MachinePrecision], 1/3], $MachinePrecision], 0.3333333333333333], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + {\left(\sqrt[3]{{\left({\left(e^{\frac{\left(Vef + EDonor\right) + \left(mu - Ec\right)}{KbT}}\right)}^{3}\right)}^{3}}\right)}^{0.3333333333333333}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
add-cbrt-cube99.9%
pow1/399.9%
pow399.9%
associate--r-99.9%
Applied egg-rr99.9%
add-cbrt-cube99.9%
Applied egg-rr99.9%
associate-*l*99.9%
cube-unmult99.9%
+-commutative99.9%
Simplified99.9%
Final simplification99.9%
(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
(exp (* 3.0 (/ (+ (+ Vef EDonor) (- mu Ec)) KbT)))
0.3333333333333333)))))
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(exp((3.0 * (((Vef + EDonor) + (mu - Ec)) / KbT))), 0.3333333333333333)));
}
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((3.0d0 * (((vef + edonor) + (mu - ec)) / kbt))) ** 0.3333333333333333d0)))
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.pow(Math.exp((3.0 * (((Vef + EDonor) + (mu - Ec)) / KbT))), 0.3333333333333333)));
}
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.exp((3.0 * (((Vef + EDonor) + (mu - Ec)) / KbT))), 0.3333333333333333)))
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(3.0 * Float64(Float64(Float64(Vef + EDonor) + Float64(mu - Ec)) / KbT))) ^ 0.3333333333333333)))) 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((3.0 * (((Vef + EDonor) + (mu - Ec)) / KbT))) ^ 0.3333333333333333))); 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[N[Exp[N[(3.0 * N[(N[(N[(Vef + EDonor), $MachinePrecision] + N[(mu - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 0.3333333333333333], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + {\left(e^{3 \cdot \frac{\left(Vef + EDonor\right) + \left(mu - Ec\right)}{KbT}}\right)}^{0.3333333333333333}}
\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%
add-cbrt-cube99.9%
pow1/399.9%
pow399.9%
associate--r-99.9%
Applied egg-rr99.9%
pow-exp99.9%
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))) (/ NaChar (+ 1.0 (pow E (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + pow(((double) M_E), ((Vef + ((Ev + EAccept) - mu)) / KbT))));
}
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + Math.pow(Math.E, ((Vef + ((Ev + EAccept) - mu)) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + math.pow(math.e, ((Vef + ((Ev + EAccept) - mu)) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + (exp(1) ^ Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (2.71828182845904523536 ^ ((Vef + ((Ev + EAccept) - mu)) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Power[E, N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + {e}^{\left(\frac{Vef + \left(\left(Ev + EAccept\right) - mu\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-prod99.9%
exp-1-e99.9%
associate--l+99.9%
Applied egg-rr99.9%
Final simplification99.9%
(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 (/ (+ EDonor (+ mu (- Vef 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 + pow(((double) M_E), ((EDonor + (mu + (Vef - Ec))) / 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, ((EDonor + (mu + (Vef - 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.pow(math.e, ((EDonor + (mu + (Vef - 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(1) ^ Float64(Float64(EDonor + Float64(mu + Float64(Vef - 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 + (2.71828182845904523536 ^ ((EDonor + (mu + (Vef - 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[Power[E, N[(N[(EDonor + N[(mu + N[(Vef - Ec), $MachinePrecision]), $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{EDonor + \left(mu + \left(Vef - Ec\right)\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-prod99.9%
exp-1-e99.9%
associate--r-99.9%
Applied egg-rr99.9%
associate-+r+99.9%
associate-+l-99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef mu) Ec) KbT))))
(/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= NaChar -9.5e+99)
(+ t_1 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= NaChar -2.55e-250)
t_0
(if (<= NaChar 1.6e-144)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ (- (+ Ev (+ Vef EAccept)) mu) KbT)))))
(if (<= NaChar 4.9e-36) t_0 (+ NdChar t_1)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + exp((((Vef + mu) - Ec) / KbT)))) + (NaChar / (1.0 + exp((Vef / KbT))));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -9.5e+99) {
tmp = t_1 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= -2.55e-250) {
tmp = t_0;
} else if (NaChar <= 1.6e-144) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT))));
} else if (NaChar <= 4.9e-36) {
tmp = t_0;
} else {
tmp = NdChar + t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp((((vef + mu) - ec) / kbt)))) + (nachar / (1.0d0 + exp((vef / kbt))))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-9.5d+99)) then
tmp = t_1 + (ndchar / (1.0d0 + (mu / kbt)))
else if (nachar <= (-2.55d-250)) then
tmp = t_0
else if (nachar <= 1.6d-144) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (((ev + (vef + eaccept)) - mu) / kbt))))
else if (nachar <= 4.9d-36) then
tmp = t_0
else
tmp = ndchar + t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + Math.exp((((Vef + mu) - Ec) / KbT)))) + (NaChar / (1.0 + Math.exp((Vef / KbT))));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -9.5e+99) {
tmp = t_1 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= -2.55e-250) {
tmp = t_0;
} else if (NaChar <= 1.6e-144) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT))));
} else if (NaChar <= 4.9e-36) {
tmp = t_0;
} else {
tmp = NdChar + t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp((((Vef + mu) - Ec) / KbT)))) + (NaChar / (1.0 + math.exp((Vef / KbT)))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if NaChar <= -9.5e+99: tmp = t_1 + (NdChar / (1.0 + (mu / KbT))) elif NaChar <= -2.55e-250: tmp = t_0 elif NaChar <= 1.6e-144: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT)))) elif NaChar <= 4.9e-36: tmp = t_0 else: tmp = NdChar + t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + mu) - Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (NaChar <= -9.5e+99) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (NaChar <= -2.55e-250) tmp = t_0; elseif (NaChar <= 1.6e-144) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(Ev + Float64(Vef + EAccept)) - mu) / KbT))))); elseif (NaChar <= 4.9e-36) tmp = t_0; else tmp = Float64(NdChar + t_1); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp((((Vef + mu) - Ec) / KbT)))) + (NaChar / (1.0 + exp((Vef / KbT)))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -9.5e+99) tmp = t_1 + (NdChar / (1.0 + (mu / KbT))); elseif (NaChar <= -2.55e-250) tmp = t_0; elseif (NaChar <= 1.6e-144) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT)))); elseif (NaChar <= 4.9e-36) tmp = t_0; else tmp = NdChar + t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + mu), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -9.5e+99], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -2.55e-250], t$95$0, If[LessEqual[NaChar, 1.6e-144], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(N[(N[(Ev + N[(Vef + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 4.9e-36], t$95$0, N[(NdChar + t$95$1), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{\left(Vef + mu\right) - Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -9.5 \cdot 10^{+99}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;NaChar \leq -2.55 \cdot 10^{-250}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq 1.6 \cdot 10^{-144}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{\left(Ev + \left(Vef + EAccept\right)\right) - mu}{KbT}\right)}\\
\mathbf{elif}\;NaChar \leq 4.9 \cdot 10^{-36}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;NdChar + t_1\\
\end{array}
\end{array}
if NaChar < -9.49999999999999908e99Initial 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 72.1%
flip--49.6%
Applied egg-rr49.6%
Taylor expanded in mu around inf 78.2%
if -9.49999999999999908e99 < NaChar < -2.5500000000000001e-250 or 1.59999999999999986e-144 < NaChar < 4.8999999999999997e-36Initial 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 Vef around inf 81.5%
Taylor expanded in EDonor around 0 78.4%
+-commutative78.4%
Simplified78.4%
if -2.5500000000000001e-250 < NaChar < 1.59999999999999986e-144Initial 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--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 79.9%
+-commutative79.9%
log-E79.9%
associate-/l*79.9%
/-rgt-identity79.9%
+-commutative79.9%
associate-+r+79.9%
+-commutative79.9%
associate-+r+79.9%
Simplified79.9%
if 4.8999999999999997e-36 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 54.2%
Taylor expanded in Ec around inf 60.2%
neg-mul-160.2%
distribute-neg-frac60.2%
Simplified60.2%
Taylor expanded in Ec around 0 75.3%
Final simplification77.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))))))
(if (<= NaChar -3.6e+133)
(+ t_1 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= NaChar 4e-239)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(if (<= NaChar 4e-145)
(+
t_0
(/ NaChar (+ 1.0 (+ 1.0 (/ (- (+ Ev (+ Vef EAccept)) mu) KbT)))))
(if (<= NaChar 2.5e-35)
(+
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef mu) Ec) KbT))))
(/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
(+ NdChar t_1)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -3.6e+133) {
tmp = t_1 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= 4e-239) {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
} else if (NaChar <= 4e-145) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT))));
} else if (NaChar <= 2.5e-35) {
tmp = (NdChar / (1.0 + exp((((Vef + mu) - Ec) / KbT)))) + (NaChar / (1.0 + exp((Vef / KbT))));
} else {
tmp = NdChar + t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-3.6d+133)) then
tmp = t_1 + (ndchar / (1.0d0 + (mu / kbt)))
else if (nachar <= 4d-239) then
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
else if (nachar <= 4d-145) then
tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (((ev + (vef + eaccept)) - mu) / kbt))))
else if (nachar <= 2.5d-35) then
tmp = (ndchar / (1.0d0 + exp((((vef + mu) - ec) / kbt)))) + (nachar / (1.0d0 + exp((vef / kbt))))
else
tmp = ndchar + t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -3.6e+133) {
tmp = t_1 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= 4e-239) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else if (NaChar <= 4e-145) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT))));
} else if (NaChar <= 2.5e-35) {
tmp = (NdChar / (1.0 + Math.exp((((Vef + mu) - Ec) / KbT)))) + (NaChar / (1.0 + Math.exp((Vef / KbT))));
} else {
tmp = NdChar + t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if NaChar <= -3.6e+133: tmp = t_1 + (NdChar / (1.0 + (mu / KbT))) elif NaChar <= 4e-239: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) elif NaChar <= 4e-145: tmp = t_0 + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT)))) elif NaChar <= 2.5e-35: tmp = (NdChar / (1.0 + math.exp((((Vef + mu) - Ec) / KbT)))) + (NaChar / (1.0 + math.exp((Vef / KbT)))) else: tmp = NdChar + t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (NaChar <= -3.6e+133) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (NaChar <= 4e-239) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); elseif (NaChar <= 4e-145) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(Ev + Float64(Vef + EAccept)) - mu) / KbT))))); elseif (NaChar <= 2.5e-35) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + mu) - Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))); else tmp = Float64(NdChar + t_1); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -3.6e+133) tmp = t_1 + (NdChar / (1.0 + (mu / KbT))); elseif (NaChar <= 4e-239) tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); elseif (NaChar <= 4e-145) tmp = t_0 + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT)))); elseif (NaChar <= 2.5e-35) tmp = (NdChar / (1.0 + exp((((Vef + mu) - Ec) / KbT)))) + (NaChar / (1.0 + exp((Vef / KbT)))); else tmp = NdChar + t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(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, -3.6e+133], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 4e-239], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 4e-145], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(N[(N[(Ev + N[(Vef + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.5e-35], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + mu), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar + t$95$1), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -3.6 \cdot 10^{+133}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;NaChar \leq 4 \cdot 10^{-239}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{elif}\;NaChar \leq 4 \cdot 10^{-145}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{\left(Ev + \left(Vef + EAccept\right)\right) - mu}{KbT}\right)}\\
\mathbf{elif}\;NaChar \leq 2.5 \cdot 10^{-35}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + mu\right) - Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;NdChar + t_1\\
\end{array}
\end{array}
if NaChar < -3.59999999999999978e133Initial 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 69.5%
flip--51.6%
Applied egg-rr51.6%
Taylor expanded in mu around inf 78.5%
if -3.59999999999999978e133 < NaChar < 4.0000000000000003e-239Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 86.7%
if 4.0000000000000003e-239 < NaChar < 3.99999999999999966e-145Initial 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--l+100.0%
Applied egg-rr100.0%
Taylor expanded in KbT around inf 79.1%
+-commutative79.1%
log-E79.1%
associate-/l*79.1%
/-rgt-identity79.1%
+-commutative79.1%
associate-+r+79.1%
+-commutative79.1%
associate-+r+79.1%
Simplified79.1%
if 3.99999999999999966e-145 < NaChar < 2.49999999999999982e-35Initial 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 79.0%
Taylor expanded in EDonor around 0 79.0%
+-commutative79.0%
Simplified79.0%
if 2.49999999999999982e-35 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 54.2%
Taylor expanded in Ec around inf 60.2%
neg-mul-160.2%
distribute-neg-frac60.2%
Simplified60.2%
Taylor expanded in Ec around 0 75.3%
Final simplification80.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))) (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= Ev -53000000.0)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= Ev 2.9e-112)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (Ev <= -53000000.0) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (Ev <= 2.9e-112) {
tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ev <= (-53000000.0d0)) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (ev <= 2.9d-112) then
tmp = t_0 + (nachar / (1.0d0 + exp((-mu / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (Ev <= -53000000.0) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (Ev <= 2.9e-112) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if Ev <= -53000000.0: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif Ev <= 2.9e-112: tmp = t_0 + (NaChar / (1.0 + math.exp((-mu / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (Ev <= -53000000.0) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (Ev <= 2.9e-112) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (Ev <= -53000000.0) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (Ev <= 2.9e-112) tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -53000000.0], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 2.9e-112], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;Ev \leq -53000000:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;Ev \leq 2.9 \cdot 10^{-112}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if Ev < -5.3e7Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 82.2%
if -5.3e7 < Ev < 2.89999999999999992e-112Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 82.5%
neg-mul-139.7%
distribute-neg-frac39.7%
Simplified82.5%
if 2.89999999999999992e-112 < Ev Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 77.6%
Final simplification80.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= Ev -860000.0)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (Ev <= -860000.0) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ev <= (-860000.0d0)) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (Ev <= -860000.0) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if Ev <= -860000.0: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (Ev <= -860000.0) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (Ev <= -860000.0) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -860000.0], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;Ev \leq -860000:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if Ev < -8.6e5Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 82.2%
if -8.6e5 < Ev Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 79.9%
Final simplification80.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ (- (+ Ev (+ Vef EAccept)) mu) KbT))))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= NaChar -3.55e+115)
(+ t_1 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= NaChar -1.46e-39)
t_0
(if (<= NaChar -2.7e-88)
(+ t_1 (/ NdChar (- (+ (/ mu KbT) (+ (/ Vef KbT) 2.0)) (/ Ec KbT))))
(if (<= NaChar 6.5e-73) t_0 (+ NdChar t_1)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT))));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -3.55e+115) {
tmp = t_1 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= -1.46e-39) {
tmp = t_0;
} else if (NaChar <= -2.7e-88) {
tmp = t_1 + (NdChar / (((mu / KbT) + ((Vef / KbT) + 2.0)) - (Ec / KbT)));
} else if (NaChar <= 6.5e-73) {
tmp = t_0;
} else {
tmp = NdChar + t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (((ev + (vef + eaccept)) - mu) / kbt))))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-3.55d+115)) then
tmp = t_1 + (ndchar / (1.0d0 + (mu / kbt)))
else if (nachar <= (-1.46d-39)) then
tmp = t_0
else if (nachar <= (-2.7d-88)) then
tmp = t_1 + (ndchar / (((mu / kbt) + ((vef / kbt) + 2.0d0)) - (ec / kbt)))
else if (nachar <= 6.5d-73) then
tmp = t_0
else
tmp = ndchar + t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT))));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -3.55e+115) {
tmp = t_1 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= -1.46e-39) {
tmp = t_0;
} else if (NaChar <= -2.7e-88) {
tmp = t_1 + (NdChar / (((mu / KbT) + ((Vef / KbT) + 2.0)) - (Ec / KbT)));
} else if (NaChar <= 6.5e-73) {
tmp = t_0;
} else {
tmp = NdChar + t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT)))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if NaChar <= -3.55e+115: tmp = t_1 + (NdChar / (1.0 + (mu / KbT))) elif NaChar <= -1.46e-39: tmp = t_0 elif NaChar <= -2.7e-88: tmp = t_1 + (NdChar / (((mu / KbT) + ((Vef / KbT) + 2.0)) - (Ec / KbT))) elif NaChar <= 6.5e-73: tmp = t_0 else: tmp = NdChar + t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(Ev + Float64(Vef + EAccept)) - mu) / KbT))))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (NaChar <= -3.55e+115) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (NaChar <= -1.46e-39) tmp = t_0; elseif (NaChar <= -2.7e-88) tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(Float64(mu / KbT) + Float64(Float64(Vef / KbT) + 2.0)) - Float64(Ec / KbT)))); elseif (NaChar <= 6.5e-73) tmp = t_0; else tmp = Float64(NdChar + t_1); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT)))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -3.55e+115) tmp = t_1 + (NdChar / (1.0 + (mu / KbT))); elseif (NaChar <= -1.46e-39) tmp = t_0; elseif (NaChar <= -2.7e-88) tmp = t_1 + (NdChar / (((mu / KbT) + ((Vef / KbT) + 2.0)) - (Ec / KbT))); elseif (NaChar <= 6.5e-73) tmp = t_0; else tmp = NdChar + t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(N[(N[(Ev + N[(Vef + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -3.55e+115], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, -1.46e-39], t$95$0, If[LessEqual[NaChar, -2.7e-88], N[(t$95$1 + N[(NdChar / N[(N[(N[(mu / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 6.5e-73], t$95$0, N[(NdChar + t$95$1), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{\left(Ev + \left(Vef + EAccept\right)\right) - mu}{KbT}\right)}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -3.55 \cdot 10^{+115}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;NaChar \leq -1.46 \cdot 10^{-39}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq -2.7 \cdot 10^{-88}:\\
\;\;\;\;t_1 + \frac{NdChar}{\left(\frac{mu}{KbT} + \left(\frac{Vef}{KbT} + 2\right)\right) - \frac{Ec}{KbT}}\\
\mathbf{elif}\;NaChar \leq 6.5 \cdot 10^{-73}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;NdChar + t_1\\
\end{array}
\end{array}
if NaChar < -3.5499999999999998e115Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 71.3%
flip--50.5%
Applied egg-rr50.5%
Taylor expanded in mu around inf 79.8%
if -3.5499999999999998e115 < NaChar < -1.46000000000000001e-39 or -2.69999999999999995e-88 < NaChar < 6.4999999999999999e-73Initial 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-prod99.9%
exp-1-e99.9%
associate--l+99.9%
Applied egg-rr99.9%
Taylor expanded in KbT around inf 74.3%
+-commutative74.3%
log-E74.3%
associate-/l*74.3%
/-rgt-identity74.3%
+-commutative74.3%
associate-+r+74.3%
+-commutative74.3%
associate-+r+74.3%
Simplified74.3%
if -1.46000000000000001e-39 < NaChar < -2.69999999999999995e-88Initial 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 100.0%
Taylor expanded in EDonor around 0 100.0%
if 6.4999999999999999e-73 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 54.7%
Taylor expanded in Ec around inf 60.4%
neg-mul-160.4%
distribute-neg-frac60.4%
Simplified60.4%
Taylor expanded in Ec around 0 74.5%
Final simplification76.1%
(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 -7.8e+115)
(+ t_0 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= NaChar 7.2e-66)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ (- (+ Ev (+ Vef EAccept)) mu) KbT)))))
(+ NdChar t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -7.8e+115) {
tmp = t_0 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= 7.2e-66) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT))));
} else {
tmp = NdChar + t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-7.8d+115)) then
tmp = t_0 + (ndchar / (1.0d0 + (mu / kbt)))
else if (nachar <= 7.2d-66) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (((ev + (vef + eaccept)) - mu) / kbt))))
else
tmp = ndchar + t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -7.8e+115) {
tmp = t_0 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= 7.2e-66) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT))));
} else {
tmp = NdChar + t_0;
}
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 <= -7.8e+115: tmp = t_0 + (NdChar / (1.0 + (mu / KbT))) elif NaChar <= 7.2e-66: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT)))) else: tmp = NdChar + t_0 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 <= -7.8e+115) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (NaChar <= 7.2e-66) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Float64(Float64(Ev + Float64(Vef + EAccept)) - mu) / KbT))))); else tmp = Float64(NdChar + t_0); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -7.8e+115) tmp = t_0 + (NdChar / (1.0 + (mu / KbT))); elseif (NaChar <= 7.2e-66) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (((Ev + (Vef + EAccept)) - mu) / KbT)))); else tmp = NdChar + t_0; 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, -7.8e+115], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 7.2e-66], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(N[(N[(Ev + N[(Vef + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar + t$95$0), $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 -7.8 \cdot 10^{+115}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;NaChar \leq 7.2 \cdot 10^{-66}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{\left(Ev + \left(Vef + EAccept\right)\right) - mu}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;NdChar + t_0\\
\end{array}
\end{array}
if NaChar < -7.80000000000000012e115Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 71.3%
flip--50.5%
Applied egg-rr50.5%
Taylor expanded in mu around inf 79.8%
if -7.80000000000000012e115 < NaChar < 7.20000000000000025e-66Initial 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-prod99.9%
exp-1-e99.9%
associate--l+99.9%
Applied egg-rr99.9%
Taylor expanded in KbT around inf 72.5%
+-commutative72.5%
log-E72.5%
associate-/l*72.5%
/-rgt-identity72.5%
+-commutative72.5%
associate-+r+72.5%
+-commutative72.5%
associate-+r+72.5%
Simplified72.5%
if 7.20000000000000025e-66 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 54.7%
Taylor expanded in Ec around inf 60.4%
neg-mul-160.4%
distribute-neg-frac60.4%
Simplified60.4%
Taylor expanded in Ec around 0 74.5%
Final simplification74.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -1.35e+65)
(not
(or (<= NdChar 9.2e-13)
(and (not (<= NdChar 2.6e+64)) (<= NdChar 8.2e+136)))))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ Vef KbT)))))
(+ NdChar (/ 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 tmp;
if ((NdChar <= -1.35e+65) || !((NdChar <= 9.2e-13) || (!(NdChar <= 2.6e+64) && (NdChar <= 8.2e+136)))) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
} else {
tmp = NdChar + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - 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 ((ndchar <= (-1.35d+65)) .or. (.not. (ndchar <= 9.2d-13) .or. (.not. (ndchar <= 2.6d+64)) .and. (ndchar <= 8.2d+136))) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (vef / kbt))))
else
tmp = ndchar + (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - 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 ((NdChar <= -1.35e+65) || !((NdChar <= 9.2e-13) || (!(NdChar <= 2.6e+64) && (NdChar <= 8.2e+136)))) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
} else {
tmp = NdChar + (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -1.35e+65) or not ((NdChar <= 9.2e-13) or (not (NdChar <= 2.6e+64) and (NdChar <= 8.2e+136))): tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (Vef / KbT)))) else: tmp = NdChar + (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -1.35e+65) || !((NdChar <= 9.2e-13) || (!(NdChar <= 2.6e+64) && (NdChar <= 8.2e+136)))) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / KbT))))); else tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -1.35e+65) || ~(((NdChar <= 9.2e-13) || (~((NdChar <= 2.6e+64)) && (NdChar <= 8.2e+136))))) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (Vef / KbT)))); else tmp = NdChar + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.35e+65], N[Not[Or[LessEqual[NdChar, 9.2e-13], And[N[Not[LessEqual[NdChar, 2.6e+64]], $MachinePrecision], LessEqual[NdChar, 8.2e+136]]]], $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[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar + 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}
\mathbf{if}\;NdChar \leq -1.35 \cdot 10^{+65} \lor \neg \left(NdChar \leq 9.2 \cdot 10^{-13} \lor \neg \left(NdChar \leq 2.6 \cdot 10^{+64}\right) \land NdChar \leq 8.2 \cdot 10^{+136}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\end{array}
\end{array}
if NdChar < -1.35000000000000009e65 or 9.19999999999999917e-13 < NdChar < 2.59999999999999997e64 or 8.1999999999999995e136 < 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 Vef around inf 77.1%
Taylor expanded in Vef around 0 69.8%
if -1.35000000000000009e65 < NdChar < 9.19999999999999917e-13 or 2.59999999999999997e64 < NdChar < 8.1999999999999995e136Initial 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 64.8%
Taylor expanded in Ec around inf 66.5%
neg-mul-166.5%
distribute-neg-frac66.5%
Simplified66.5%
Taylor expanded in Ec around 0 75.4%
Final simplification72.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (+ NdChar t_0))
(t_2
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ Vef KbT)))))))
(if (<= NdChar -1.55e+65)
t_2
(if (<= NdChar 1.45e-151)
t_1
(if (<= NdChar 1.65e+62)
(+ t_0 (/ NdChar (+ 1.0 (- (/ EDonor KbT) (/ Ec KbT)))))
(if (<= NdChar 4.3e+134) t_1 t_2))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar + t_0;
double t_2 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
double tmp;
if (NdChar <= -1.55e+65) {
tmp = t_2;
} else if (NdChar <= 1.45e-151) {
tmp = t_1;
} else if (NdChar <= 1.65e+62) {
tmp = t_0 + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
} else if (NdChar <= 4.3e+134) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar + t_0
t_2 = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (vef / kbt))))
if (ndchar <= (-1.55d+65)) then
tmp = t_2
else if (ndchar <= 1.45d-151) then
tmp = t_1
else if (ndchar <= 1.65d+62) then
tmp = t_0 + (ndchar / (1.0d0 + ((edonor / kbt) - (ec / kbt))))
else if (ndchar <= 4.3d+134) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar + t_0;
double t_2 = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (Vef / KbT))));
double tmp;
if (NdChar <= -1.55e+65) {
tmp = t_2;
} else if (NdChar <= 1.45e-151) {
tmp = t_1;
} else if (NdChar <= 1.65e+62) {
tmp = t_0 + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT))));
} else if (NdChar <= 4.3e+134) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar + t_0 t_2 = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (Vef / KbT)))) tmp = 0 if NdChar <= -1.55e+65: tmp = t_2 elif NdChar <= 1.45e-151: tmp = t_1 elif NdChar <= 1.65e+62: tmp = t_0 + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT)))) elif NdChar <= 4.3e+134: tmp = t_1 else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar + t_0) t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Vef / KbT))))) tmp = 0.0 if (NdChar <= -1.55e+65) tmp = t_2; elseif (NdChar <= 1.45e-151) tmp = t_1; elseif (NdChar <= 1.65e+62) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(Float64(EDonor / KbT) - Float64(Ec / KbT))))); elseif (NdChar <= 4.3e+134) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar + t_0; t_2 = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (1.0 + (Vef / KbT)))); tmp = 0.0; if (NdChar <= -1.55e+65) tmp = t_2; elseif (NdChar <= 1.45e-151) tmp = t_1; elseif (NdChar <= 1.65e+62) tmp = t_0 + (NdChar / (1.0 + ((EDonor / KbT) - (Ec / KbT)))); elseif (NdChar <= 4.3e+134) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar + t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.55e+65], t$95$2, If[LessEqual[NdChar, 1.45e-151], t$95$1, If[LessEqual[NdChar, 1.65e+62], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(N[(EDonor / KbT), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 4.3e+134], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := NdChar + t_0\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\
\mathbf{if}\;NdChar \leq -1.55 \cdot 10^{+65}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;NdChar \leq 1.45 \cdot 10^{-151}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NdChar \leq 1.65 \cdot 10^{+62}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + \left(\frac{EDonor}{KbT} - \frac{Ec}{KbT}\right)}\\
\mathbf{elif}\;NdChar \leq 4.3 \cdot 10^{+134}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if NdChar < -1.54999999999999995e65 or 4.3e134 < 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 Vef around inf 78.9%
Taylor expanded in Vef around 0 71.7%
if -1.54999999999999995e65 < NdChar < 1.45000000000000006e-151 or 1.65e62 < NdChar < 4.3e134Initial 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 62.2%
Taylor expanded in Ec around inf 65.0%
neg-mul-165.0%
distribute-neg-frac65.0%
Simplified65.0%
Taylor expanded in Ec around 0 77.0%
if 1.45000000000000006e-151 < NdChar < 1.65e62Initial 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 65.3%
Taylor expanded in EDonor around inf 65.9%
Final simplification73.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 (or (<= KbT -3.5e+93) (and (not (<= KbT 7.5e+123)) (<= KbT 9.5e+272)))
(+ t_0 (* NdChar 0.5))
(+ NdChar t_0))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if ((KbT <= -3.5e+93) || (!(KbT <= 7.5e+123) && (KbT <= 9.5e+272))) {
tmp = t_0 + (NdChar * 0.5);
} else {
tmp = NdChar + t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if ((kbt <= (-3.5d+93)) .or. (.not. (kbt <= 7.5d+123)) .and. (kbt <= 9.5d+272)) then
tmp = t_0 + (ndchar * 0.5d0)
else
tmp = ndchar + t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if ((KbT <= -3.5e+93) || (!(KbT <= 7.5e+123) && (KbT <= 9.5e+272))) {
tmp = t_0 + (NdChar * 0.5);
} else {
tmp = NdChar + t_0;
}
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 (KbT <= -3.5e+93) or (not (KbT <= 7.5e+123) and (KbT <= 9.5e+272)): tmp = t_0 + (NdChar * 0.5) else: tmp = NdChar + t_0 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 ((KbT <= -3.5e+93) || (!(KbT <= 7.5e+123) && (KbT <= 9.5e+272))) tmp = Float64(t_0 + Float64(NdChar * 0.5)); else tmp = Float64(NdChar + t_0); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if ((KbT <= -3.5e+93) || (~((KbT <= 7.5e+123)) && (KbT <= 9.5e+272))) tmp = t_0 + (NdChar * 0.5); else tmp = NdChar + t_0; 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[KbT, -3.5e+93], And[N[Not[LessEqual[KbT, 7.5e+123]], $MachinePrecision], LessEqual[KbT, 9.5e+272]]], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(NdChar + t$95$0), $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}\;KbT \leq -3.5 \cdot 10^{+93} \lor \neg \left(KbT \leq 7.5 \cdot 10^{+123}\right) \land KbT \leq 9.5 \cdot 10^{+272}:\\
\;\;\;\;t_0 + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;NdChar + t_0\\
\end{array}
\end{array}
if KbT < -3.49999999999999998e93 or 7.4999999999999999e123 < KbT < 9.5e272Initial 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 71.9%
if -3.49999999999999998e93 < KbT < 7.4999999999999999e123 or 9.5e272 < KbT Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 46.2%
Taylor expanded in Ec around inf 55.2%
neg-mul-155.2%
distribute-neg-frac55.2%
Simplified55.2%
Taylor expanded in Ec around 0 67.6%
Final simplification68.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= NaChar -6.2e+41)
(+ t_0 (/ NdChar (+ 1.0 (/ EDonor KbT))))
(if (<= NaChar 3.5e-102)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar 2.0))
(+ NdChar t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -6.2e+41) {
tmp = t_0 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (NaChar <= 3.5e-102) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
} else {
tmp = NdChar + t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-6.2d+41)) then
tmp = t_0 + (ndchar / (1.0d0 + (edonor / kbt)))
else if (nachar <= 3.5d-102) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / 2.0d0)
else
tmp = ndchar + t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -6.2e+41) {
tmp = t_0 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (NaChar <= 3.5e-102) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
} else {
tmp = NdChar + t_0;
}
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 <= -6.2e+41: tmp = t_0 + (NdChar / (1.0 + (EDonor / KbT))) elif NaChar <= 3.5e-102: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0) else: tmp = NdChar + t_0 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 <= -6.2e+41) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT)))); elseif (NaChar <= 3.5e-102) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / 2.0)); else tmp = Float64(NdChar + t_0); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -6.2e+41) tmp = t_0 + (NdChar / (1.0 + (EDonor / KbT))); elseif (NaChar <= 3.5e-102) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0); else tmp = NdChar + t_0; 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, -6.2e+41], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 3.5e-102], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NdChar + t$95$0), $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 -6.2 \cdot 10^{+41}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\
\mathbf{elif}\;NaChar \leq 3.5 \cdot 10^{-102}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;NdChar + t_0\\
\end{array}
\end{array}
if NaChar < -6.2e41Initial 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 70.0%
flip--49.0%
Applied egg-rr49.0%
Taylor expanded in EDonor around inf 73.8%
if -6.2e41 < NaChar < 3.49999999999999986e-102Initial 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.2%
if 3.49999999999999986e-102 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 51.0%
Taylor expanded in Ec around inf 57.2%
neg-mul-157.2%
distribute-neg-frac57.2%
Simplified57.2%
Taylor expanded in Ec around 0 72.3%
Final simplification69.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))))))
(if (<= NaChar -1.3e+91)
(+ t_0 (/ NdChar (+ 1.0 (/ mu KbT))))
(if (<= NaChar 8.5e-100)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar 2.0))
(+ NdChar t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -1.3e+91) {
tmp = t_0 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= 8.5e-100) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
} else {
tmp = NdChar + t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-1.3d+91)) then
tmp = t_0 + (ndchar / (1.0d0 + (mu / kbt)))
else if (nachar <= 8.5d-100) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / 2.0d0)
else
tmp = ndchar + t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -1.3e+91) {
tmp = t_0 + (NdChar / (1.0 + (mu / KbT)));
} else if (NaChar <= 8.5e-100) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
} else {
tmp = NdChar + t_0;
}
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 <= -1.3e+91: tmp = t_0 + (NdChar / (1.0 + (mu / KbT))) elif NaChar <= 8.5e-100: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0) else: tmp = NdChar + t_0 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 <= -1.3e+91) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(mu / KbT)))); elseif (NaChar <= 8.5e-100) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / 2.0)); else tmp = Float64(NdChar + t_0); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -1.3e+91) tmp = t_0 + (NdChar / (1.0 + (mu / KbT))); elseif (NaChar <= 8.5e-100) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0); else tmp = NdChar + t_0; 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, -1.3e+91], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 8.5e-100], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NdChar + t$95$0), $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 -1.3 \cdot 10^{+91}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + \frac{mu}{KbT}}\\
\mathbf{elif}\;NaChar \leq 8.5 \cdot 10^{-100}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;NdChar + t_0\\
\end{array}
\end{array}
if NaChar < -1.3e91Initial 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 72.1%
flip--49.6%
Applied egg-rr49.6%
Taylor expanded in mu around inf 78.2%
if -1.3e91 < NaChar < 8.50000000000000017e-100Initial 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.5%
if 8.50000000000000017e-100 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 51.0%
Taylor expanded in Ec around inf 57.2%
neg-mul-157.2%
distribute-neg-frac57.2%
Simplified57.2%
Taylor expanded in Ec around 0 72.3%
Final simplification70.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -3.6e+95) (not (<= NaChar 1.45e-102)))
(+ NdChar (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar 2.0))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -3.6e+95) || !(NaChar <= 1.45e-102)) {
tmp = NdChar + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((nachar <= (-3.6d+95)) .or. (.not. (nachar <= 1.45d-102))) then
tmp = ndchar + (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt))))
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -3.6e+95) || !(NaChar <= 1.45e-102)) {
tmp = NdChar + (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -3.6e+95) or not (NaChar <= 1.45e-102): tmp = NdChar + (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -3.6e+95) || !(NaChar <= 1.45e-102)) tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -3.6e+95) || ~((NaChar <= 1.45e-102))) tmp = NdChar + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))); else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -3.6e+95], N[Not[LessEqual[NaChar, 1.45e-102]], $MachinePrecision]], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $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 / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -3.6 \cdot 10^{+95} \lor \neg \left(NaChar \leq 1.45 \cdot 10^{-102}\right):\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{2}\\
\end{array}
\end{array}
if NaChar < -3.59999999999999978e95 or 1.44999999999999993e-102 < 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 59.3%
Taylor expanded in Ec around inf 63.6%
neg-mul-163.6%
distribute-neg-frac63.6%
Simplified63.6%
Taylor expanded in Ec around 0 72.0%
if -3.59999999999999978e95 < NaChar < 1.44999999999999993e-102Initial 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.5%
Final simplification69.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT))))))
(if (<= KbT -2.5e-109)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
(if (<= KbT 4.4e-166)
(+ t_0 (/ (* NdChar KbT) mu))
(+ t_0 (* NdChar 0.5))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((Ev / KbT)));
double tmp;
if (KbT <= -2.5e-109) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
} else if (KbT <= 4.4e-166) {
tmp = t_0 + ((NdChar * KbT) / mu);
} else {
tmp = t_0 + (NdChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((ev / kbt)))
if (kbt <= (-2.5d-109)) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
else if (kbt <= 4.4d-166) then
tmp = t_0 + ((ndchar * kbt) / mu)
else
tmp = t_0 + (ndchar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((Ev / KbT)));
double tmp;
if (KbT <= -2.5e-109) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
} else if (KbT <= 4.4e-166) {
tmp = t_0 + ((NdChar * KbT) / mu);
} else {
tmp = t_0 + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((Ev / KbT))) tmp = 0 if KbT <= -2.5e-109: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) elif KbT <= 4.4e-166: tmp = t_0 + ((NdChar * KbT) / mu) else: tmp = t_0 + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) tmp = 0.0 if (KbT <= -2.5e-109) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); elseif (KbT <= 4.4e-166) tmp = Float64(t_0 + Float64(Float64(NdChar * KbT) / mu)); else tmp = Float64(t_0 + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((Ev / KbT))); tmp = 0.0; if (KbT <= -2.5e-109) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); elseif (KbT <= 4.4e-166) tmp = t_0 + ((NdChar * KbT) / mu); else tmp = t_0 + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -2.5e-109], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4.4e-166], N[(t$95$0 + N[(N[(NdChar * KbT), $MachinePrecision] / mu), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{if}\;KbT \leq -2.5 \cdot 10^{-109}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 4.4 \cdot 10^{-166}:\\
\;\;\;\;t_0 + \frac{NdChar \cdot KbT}{mu}\\
\mathbf{else}:\\
\;\;\;\;t_0 + NdChar \cdot 0.5\\
\end{array}
\end{array}
if KbT < -2.5000000000000001e-109Initial 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 61.3%
Taylor expanded in EAccept around inf 51.1%
if -2.5000000000000001e-109 < KbT < 4.4000000000000002e-166Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 45.8%
Taylor expanded in mu around inf 51.5%
Taylor expanded in Ev around inf 30.2%
if 4.4000000000000002e-166 < KbT Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 51.4%
Taylor expanded in Ev around inf 42.5%
Final simplification41.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ NdChar (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NdChar + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = ndchar + (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NdChar + (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return NdChar + (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = NdChar + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NdChar + 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}
\\
NdChar + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 53.7%
Taylor expanded in Ec around inf 53.5%
neg-mul-153.5%
distribute-neg-frac53.5%
Simplified53.5%
Taylor expanded in Ec around 0 63.1%
Final simplification63.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= EDonor 3.65e+68)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))
(+
(/ NdChar (- 1.0 (/ Ec KbT)))
(/
NaChar
(+
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ 1.0 (/ Vef KbT))))
(/ mu KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (EDonor <= 3.65e+68) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (edonor <= 3.65d+68) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
else
tmp = (ndchar / (1.0d0 - (ec / kbt))) + (nachar / (1.0d0 + (((ev / kbt) + ((eaccept / kbt) + (1.0d0 + (vef / kbt)))) - (mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (EDonor <= 3.65e+68) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if EDonor <= 3.65e+68: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) else: tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (EDonor <= 3.65e+68) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); else tmp = Float64(Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(1.0 + Float64(Vef / 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 (EDonor <= 3.65e+68) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); else tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[EDonor, 3.65e+68], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;EDonor \leq 3.65 \cdot 10^{+68}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 - \frac{Ec}{KbT}} + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if EDonor < 3.65000000000000017e68Initial 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 42.3%
if 3.65000000000000017e68 < EDonor Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 42.4%
Taylor expanded in Ec around inf 59.4%
neg-mul-159.4%
distribute-neg-frac59.4%
Simplified59.4%
Taylor expanded in KbT around inf 37.4%
Final simplification41.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (<= Ev -2.3e-41) (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5)) (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (* NdChar 0.5))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (Ev <= -2.3e-41) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (ev <= (-2.3d-41)) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (Ev <= -2.3e-41) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if Ev <= -2.3e-41: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (Ev <= -2.3e-41) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (Ev <= -2.3e-41) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -2.3e-41], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;Ev \leq -2.3 \cdot 10^{-41}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if Ev < -2.3000000000000001e-41Initial 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.6%
Taylor expanded in Ev around inf 41.3%
if -2.3000000000000001e-41 < Ev Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 49.9%
Taylor expanded in EAccept around inf 43.5%
Final simplification42.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -5.2e+96)
(+
(/
NdChar
(+
1.0
(- (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ Ec KbT))))
(* NaChar 0.5))
(if (<= KbT 5.9e+131)
(+
(/ NdChar (- 1.0 (/ Ec KbT)))
(/
NaChar
(+
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ 1.0 (/ Vef KbT))))
(/ mu KbT)))))
(+ (* NdChar 0.5) (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -5.2e+96) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar * 0.5);
} else if (KbT <= 5.9e+131) {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
} else {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-5.2d+96)) then
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))) + (nachar * 0.5d0)
else if (kbt <= 5.9d+131) then
tmp = (ndchar / (1.0d0 - (ec / kbt))) + (nachar / (1.0d0 + (((ev / kbt) + ((eaccept / kbt) + (1.0d0 + (vef / kbt)))) - (mu / kbt))))
else
tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -5.2e+96) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar * 0.5);
} else if (KbT <= 5.9e+131) {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
} else {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -5.2e+96: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar * 0.5) elif KbT <= 5.9e+131: tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))) else: tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -5.2e+96) tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar * 0.5)); elseif (KbT <= 5.9e+131) tmp = Float64(Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(1.0 + Float64(Vef / KbT)))) - Float64(mu / KbT))))); else tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -5.2e+96) tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar * 0.5); elseif (KbT <= 5.9e+131) tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))); else tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -5.2e+96], N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 5.9e+131], N[(N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -5.2 \cdot 10^{+96}:\\
\;\;\;\;\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + NaChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 5.9 \cdot 10^{+131}:\\
\;\;\;\;\frac{NdChar}{1 - \frac{Ec}{KbT}} + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\end{array}
\end{array}
if KbT < -5.2e96Initial program 99.7%
neg-sub099.7%
associate--r-99.7%
+-commutative99.7%
neg-sub099.7%
sub-neg99.7%
associate--l-99.7%
unsub-neg99.7%
+-commutative99.7%
associate-+l+99.7%
Simplified99.7%
Taylor expanded in KbT around inf 79.4%
Taylor expanded in KbT around inf 67.6%
if -5.2e96 < KbT < 5.89999999999999984e131Initial 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.1%
Taylor expanded in Ec around inf 53.8%
neg-mul-153.8%
distribute-neg-frac53.8%
Simplified53.8%
Taylor expanded in KbT around inf 22.4%
if 5.89999999999999984e131 < 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.0%
Taylor expanded in EAccept around inf 59.0%
Taylor expanded in EAccept around 0 51.1%
Final simplification33.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -4.8e+104)
(+
(/
NdChar
(+
1.0
(- (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ Ec KbT))))
(* NaChar 0.5))
(if (<= KbT 1.1e+124)
(+ (/ NdChar (- 1.0 (/ Ec KbT))) (* NaChar 0.5))
(+ (* NdChar 0.5) (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -4.8e+104) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar * 0.5);
} else if (KbT <= 1.1e+124) {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5);
} else {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-4.8d+104)) then
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))) + (nachar * 0.5d0)
else if (kbt <= 1.1d+124) then
tmp = (ndchar / (1.0d0 - (ec / kbt))) + (nachar * 0.5d0)
else
tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -4.8e+104) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar * 0.5);
} else if (KbT <= 1.1e+124) {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5);
} else {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -4.8e+104: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar * 0.5) elif KbT <= 1.1e+124: tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5) else: tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -4.8e+104) tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar * 0.5)); elseif (KbT <= 1.1e+124) tmp = Float64(Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -4.8e+104) tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar * 0.5); elseif (KbT <= 1.1e+124) tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5); else tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -4.8e+104], N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.1e+124], N[(N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -4.8 \cdot 10^{+104}:\\
\;\;\;\;\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + NaChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 1.1 \cdot 10^{+124}:\\
\;\;\;\;\frac{NdChar}{1 - \frac{Ec}{KbT}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\end{array}
\end{array}
if KbT < -4.8e104Initial program 99.6%
neg-sub099.6%
associate--r-99.6%
+-commutative99.6%
neg-sub099.6%
sub-neg99.6%
associate--l-99.6%
unsub-neg99.6%
+-commutative99.6%
associate-+l+99.6%
Simplified99.6%
Taylor expanded in KbT around inf 77.7%
Taylor expanded in KbT around inf 69.4%
if -4.8e104 < KbT < 1.1e124Initial 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.0%
Taylor expanded in Ec around inf 55.0%
neg-mul-155.0%
distribute-neg-frac55.0%
Simplified55.0%
Taylor expanded in KbT around inf 22.9%
if 1.1e124 < 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 65.2%
Taylor expanded in EAccept around inf 56.1%
Taylor expanded in EAccept around 0 48.7%
Final simplification33.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -4.8e+104)
(+ (* NdChar 0.5) (* NaChar 0.5))
(if (<= KbT 7e+123)
(+ (/ NdChar (- 1.0 (/ Ec KbT))) (* NaChar 0.5))
(+ (* NdChar 0.5) (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -4.8e+104) {
tmp = (NdChar * 0.5) + (NaChar * 0.5);
} else if (KbT <= 7e+123) {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5);
} else {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-4.8d+104)) then
tmp = (ndchar * 0.5d0) + (nachar * 0.5d0)
else if (kbt <= 7d+123) then
tmp = (ndchar / (1.0d0 - (ec / kbt))) + (nachar * 0.5d0)
else
tmp = (ndchar * 0.5d0) + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -4.8e+104) {
tmp = (NdChar * 0.5) + (NaChar * 0.5);
} else if (KbT <= 7e+123) {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5);
} else {
tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -4.8e+104: tmp = (NdChar * 0.5) + (NaChar * 0.5) elif KbT <= 7e+123: tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5) else: tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -4.8e+104) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar * 0.5)); elseif (KbT <= 7e+123) tmp = Float64(Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -4.8e+104) tmp = (NdChar * 0.5) + (NaChar * 0.5); elseif (KbT <= 7e+123) tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5); else tmp = (NdChar * 0.5) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -4.8e+104], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 7e+123], N[(N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -4.8 \cdot 10^{+104}:\\
\;\;\;\;NdChar \cdot 0.5 + NaChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 7 \cdot 10^{+123}:\\
\;\;\;\;\frac{NdChar}{1 - \frac{Ec}{KbT}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\end{array}
\end{array}
if KbT < -4.8e104Initial program 99.6%
neg-sub099.6%
associate--r-99.6%
+-commutative99.6%
neg-sub099.6%
sub-neg99.6%
associate--l-99.6%
unsub-neg99.6%
+-commutative99.6%
associate-+l+99.6%
Simplified99.6%
Taylor expanded in KbT around inf 77.4%
Taylor expanded in KbT around inf 68.3%
if -4.8e104 < KbT < 6.99999999999999999e123Initial 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.0%
Taylor expanded in Ec around inf 55.0%
neg-mul-155.0%
distribute-neg-frac55.0%
Simplified55.0%
Taylor expanded in KbT around inf 22.9%
if 6.99999999999999999e123 < 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 65.2%
Taylor expanded in EAccept around inf 56.1%
Taylor expanded in EAccept around 0 48.7%
Final simplification33.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -3.2e+104)
(+ (* NdChar 0.5) (* NaChar 0.5))
(if (<= KbT 2.6e+131)
(+ (/ NdChar (- 1.0 (/ Ec KbT))) (* NaChar 0.5))
(+ (* NdChar 0.5) (/ NaChar (- 2.0 (/ 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 (KbT <= -3.2e+104) {
tmp = (NdChar * 0.5) + (NaChar * 0.5);
} else if (KbT <= 2.6e+131) {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5);
} else {
tmp = (NdChar * 0.5) + (NaChar / (2.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) :: tmp
if (kbt <= (-3.2d+104)) then
tmp = (ndchar * 0.5d0) + (nachar * 0.5d0)
else if (kbt <= 2.6d+131) then
tmp = (ndchar / (1.0d0 - (ec / kbt))) + (nachar * 0.5d0)
else
tmp = (ndchar * 0.5d0) + (nachar / (2.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 tmp;
if (KbT <= -3.2e+104) {
tmp = (NdChar * 0.5) + (NaChar * 0.5);
} else if (KbT <= 2.6e+131) {
tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5);
} else {
tmp = (NdChar * 0.5) + (NaChar / (2.0 - (mu / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -3.2e+104: tmp = (NdChar * 0.5) + (NaChar * 0.5) elif KbT <= 2.6e+131: tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5) else: tmp = (NdChar * 0.5) + (NaChar / (2.0 - (mu / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -3.2e+104) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar * 0.5)); elseif (KbT <= 2.6e+131) tmp = Float64(Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -3.2e+104) tmp = (NdChar * 0.5) + (NaChar * 0.5); elseif (KbT <= 2.6e+131) tmp = (NdChar / (1.0 - (Ec / KbT))) + (NaChar * 0.5); else tmp = (NdChar * 0.5) + (NaChar / (2.0 - (mu / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -3.2e+104], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.6e+131], N[(N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -3.2 \cdot 10^{+104}:\\
\;\;\;\;NdChar \cdot 0.5 + NaChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq 2.6 \cdot 10^{+131}:\\
\;\;\;\;\frac{NdChar}{1 - \frac{Ec}{KbT}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\end{array}
\end{array}
if KbT < -3.2e104Initial program 99.6%
neg-sub099.6%
associate--r-99.6%
+-commutative99.6%
neg-sub099.6%
sub-neg99.6%
associate--l-99.6%
unsub-neg99.6%
+-commutative99.6%
associate-+l+99.6%
Simplified99.6%
Taylor expanded in KbT around inf 77.4%
Taylor expanded in KbT around inf 68.3%
if -3.2e104 < KbT < 2.6e131Initial 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.0%
Taylor expanded in Ec around inf 54.5%
neg-mul-154.5%
distribute-neg-frac54.5%
Simplified54.5%
Taylor expanded in KbT around inf 22.7%
if 2.6e131 < 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.0%
Taylor expanded in mu around inf 52.9%
neg-mul-152.9%
distribute-neg-frac52.9%
Simplified52.9%
Taylor expanded in mu around 0 52.1%
mul-1-neg52.1%
distribute-frac-neg52.1%
Simplified52.1%
Taylor expanded in NaChar around 0 52.1%
mul-1-neg52.1%
unsub-neg52.1%
Simplified52.1%
Final simplification33.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (* NdChar 0.5) (* NaChar 0.5)))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar * 0.5) + (NaChar * 0.5);
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar * 0.5d0) + (nachar * 0.5d0)
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar * 0.5) + (NaChar * 0.5);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar * 0.5) + (NaChar * 0.5)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar * 0.5) + Float64(NaChar * 0.5)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar * 0.5) + (NaChar * 0.5); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
NdChar \cdot 0.5 + NaChar \cdot 0.5
\end{array}
Initial program 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 49.0%
Taylor expanded in KbT around inf 28.8%
Final simplification28.8%
herbie shell --seed 2023195
(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))))))