
(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 25 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}}
\end{array}
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))) + (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[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{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}}
\end{array}
Initial program 100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT)))))
(t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))))
(t_2 (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
(if (<= Ec -1.65e+24)
t_1
(if (<= Ec -6.6e-136)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(if (<= Ec 1.2e-250)
t_2
(if (<= Ec 9e+29)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Ec 7.5e+149) t_2 t_1)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + exp((-Ec / KbT))));
double t_2 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
double tmp;
if (Ec <= -1.65e+24) {
tmp = t_1;
} else if (Ec <= -6.6e-136) {
tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
} else if (Ec <= 1.2e-250) {
tmp = t_2;
} else if (Ec <= 9e+29) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Ec <= 7.5e+149) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))
t_1 = t_0 + (ndchar / (1.0d0 + exp((-ec / kbt))))
t_2 = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
if (ec <= (-1.65d+24)) then
tmp = t_1
else if (ec <= (-6.6d-136)) then
tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
else if (ec <= 1.2d-250) then
tmp = t_2
else if (ec <= 9d+29) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (ec <= 7.5d+149) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
double t_2 = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
double tmp;
if (Ec <= -1.65e+24) {
tmp = t_1;
} else if (Ec <= -6.6e-136) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
} else if (Ec <= 1.2e-250) {
tmp = t_2;
} else if (Ec <= 9e+29) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Ec <= 7.5e+149) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))) t_1 = t_0 + (NdChar / (1.0 + math.exp((-Ec / KbT)))) t_2 = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT)))) tmp = 0 if Ec <= -1.65e+24: tmp = t_1 elif Ec <= -6.6e-136: tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT)))) elif Ec <= 1.2e-250: tmp = t_2 elif Ec <= 9e+29: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Ec <= 7.5e+149: tmp = t_2 else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))) t_2 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))) tmp = 0.0 if (Ec <= -1.65e+24) tmp = t_1; elseif (Ec <= -6.6e-136) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); elseif (Ec <= 1.2e-250) tmp = t_2; elseif (Ec <= 9e+29) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Ec <= 7.5e+149) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT))); t_1 = t_0 + (NdChar / (1.0 + exp((-Ec / KbT)))); t_2 = t_0 + (NdChar / (1.0 + exp((Vef / KbT)))); tmp = 0.0; if (Ec <= -1.65e+24) tmp = t_1; elseif (Ec <= -6.6e-136) tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT)))); elseif (Ec <= 1.2e-250) tmp = t_2; elseif (Ec <= 9e+29) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Ec <= 7.5e+149) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ec, -1.65e+24], t$95$1, If[LessEqual[Ec, -6.6e-136], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, 1.2e-250], t$95$2, If[LessEqual[Ec, 9e+29], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, 7.5e+149], t$95$2, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}}\\
t_1 := t\_0 + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
t_2 := t\_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;Ec \leq -1.65 \cdot 10^{+24}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;Ec \leq -6.6 \cdot 10^{-136}:\\
\;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{elif}\;Ec \leq 1.2 \cdot 10^{-250}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;Ec \leq 9 \cdot 10^{+29}:\\
\;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Ec \leq 7.5 \cdot 10^{+149}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if Ec < -1.6499999999999999e24 or 7.50000000000000031e149 < Ec Initial program 100.0%
Simplified100.0%
Taylor expanded in Ec around inf 91.6%
mul-1-neg91.6%
distribute-neg-frac291.6%
Simplified91.6%
if -1.6499999999999999e24 < Ec < -6.60000000000000035e-136Initial program 100.0%
Simplified100.0%
Taylor expanded in mu around inf 82.2%
if -6.60000000000000035e-136 < Ec < 1.1999999999999999e-250 or 9.0000000000000005e29 < Ec < 7.50000000000000031e149Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 87.1%
if 1.1999999999999999e-250 < Ec < 9.0000000000000005e29Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 78.0%
Final simplification86.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(t_1
(+
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
(t_2 (/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))))
(if (<= mu -1.4e+141)
t_1
(if (<= mu -3.3e-241)
t_2
(if (<= mu 1.9e-173)
(+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) t_0)
(if (<= mu 2.05e-60)
(+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) t_0)
(if (<= mu 1.7e+118) t_2 t_1)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((Ev / KbT)));
double t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
double t_2 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
double tmp;
if (mu <= -1.4e+141) {
tmp = t_1;
} else if (mu <= -3.3e-241) {
tmp = t_2;
} else if (mu <= 1.9e-173) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + t_0;
} else if (mu <= 2.05e-60) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0;
} else if (mu <= 1.7e+118) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((ev / kbt)))
t_1 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
t_2 = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
if (mu <= (-1.4d+141)) then
tmp = t_1
else if (mu <= (-3.3d-241)) then
tmp = t_2
else if (mu <= 1.9d-173) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + t_0
else if (mu <= 2.05d-60) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + t_0
else if (mu <= 1.7d+118) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((Ev / KbT)));
double t_1 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
double t_2 = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
double tmp;
if (mu <= -1.4e+141) {
tmp = t_1;
} else if (mu <= -3.3e-241) {
tmp = t_2;
} else if (mu <= 1.9e-173) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + t_0;
} else if (mu <= 2.05e-60) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
} else if (mu <= 1.7e+118) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((Ev / KbT))) t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT)))) t_2 = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT))) tmp = 0 if mu <= -1.4e+141: tmp = t_1 elif mu <= -3.3e-241: tmp = t_2 elif mu <= 1.9e-173: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + t_0 elif mu <= 2.05e-60: tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + t_0 elif mu <= 1.7e+118: tmp = t_2 else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))) t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)))) tmp = 0.0 if (mu <= -1.4e+141) tmp = t_1; elseif (mu <= -3.3e-241) tmp = t_2; elseif (mu <= 1.9e-173) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + t_0); elseif (mu <= 2.05e-60) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0); elseif (mu <= 1.7e+118) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((Ev / KbT))); t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT)))); t_2 = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT))); tmp = 0.0; if (mu <= -1.4e+141) tmp = t_1; elseif (mu <= -3.3e-241) tmp = t_2; elseif (mu <= 1.9e-173) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + t_0; elseif (mu <= 2.05e-60) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0; elseif (mu <= 1.7e+118) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.4e+141], t$95$1, If[LessEqual[mu, -3.3e-241], t$95$2, If[LessEqual[mu, 1.9e-173], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[mu, 2.05e-60], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[mu, 1.7e+118], t$95$2, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
t_2 := \frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;mu \leq -1.4 \cdot 10^{+141}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;mu \leq -3.3 \cdot 10^{-241}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;mu \leq 1.9 \cdot 10^{-173}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + t\_0\\
\mathbf{elif}\;mu \leq 2.05 \cdot 10^{-60}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + t\_0\\
\mathbf{elif}\;mu \leq 1.7 \cdot 10^{+118}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if mu < -1.39999999999999996e141 or 1.69999999999999993e118 < mu Initial program 100.0%
Simplified100.0%
Taylor expanded in mu around inf 89.1%
Taylor expanded in mu around inf 81.6%
associate-*r/41.8%
mul-1-neg41.8%
Simplified81.6%
if -1.39999999999999996e141 < mu < -3.2999999999999999e-241 or 2.05000000000000006e-60 < mu < 1.69999999999999993e118Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 65.9%
mul-1-neg65.9%
associate-+r+65.9%
+-commutative65.9%
associate-+r+65.9%
unsub-neg65.9%
associate-+r+65.9%
+-commutative65.9%
associate-+r+65.9%
associate--r+65.9%
Simplified65.9%
Taylor expanded in Ec around inf 37.6%
mul-1-neg37.6%
associate-/l*36.3%
distribute-lft-neg-in36.3%
Simplified36.3%
Taylor expanded in KbT around 0 70.0%
if -3.2999999999999999e-241 < mu < 1.90000000000000015e-173Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 83.2%
Taylor expanded in Ev around inf 64.6%
if 1.90000000000000015e-173 < mu < 2.05000000000000006e-60Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 85.9%
Taylor expanded in Ev around inf 76.3%
Final simplification73.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) KbT)))))
(t_1 (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) t_0)))
(if (<= EDonor -5.3e+165)
t_1
(if (<= EDonor -1.6e-241)
(+
(/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))
(/ NdChar (+ 2.0 (/ (- (+ Vef mu) (- Ec EDonor)) KbT))))
(if (<= EDonor 7.4e-236)
(+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) t_0)
(if (<= EDonor 2.85e-130)
(+
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
t_1))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)));
double t_1 = (NdChar / (1.0 + exp((EDonor / KbT)))) + t_0;
double tmp;
if (EDonor <= -5.3e+165) {
tmp = t_1;
} else if (EDonor <= -1.6e-241) {
tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)));
} else if (EDonor <= 7.4e-236) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0;
} else if (EDonor <= 2.85e-130) {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt)))
t_1 = (ndchar / (1.0d0 + exp((edonor / kbt)))) + t_0
if (edonor <= (-5.3d+165)) then
tmp = t_1
else if (edonor <= (-1.6d-241)) then
tmp = (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))) + (ndchar / (2.0d0 + (((vef + mu) - (ec - edonor)) / kbt)))
else if (edonor <= 7.4d-236) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + t_0
else if (edonor <= 2.85d-130) then
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT)));
double t_1 = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + t_0;
double tmp;
if (EDonor <= -5.3e+165) {
tmp = t_1;
} else if (EDonor <= -1.6e-241) {
tmp = (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)));
} else if (EDonor <= 7.4e-236) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
} else if (EDonor <= 2.85e-130) {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT))) t_1 = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + t_0 tmp = 0 if EDonor <= -5.3e+165: tmp = t_1 elif EDonor <= -1.6e-241: tmp = (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT))) elif EDonor <= 7.4e-236: tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + t_0 elif EDonor <= 2.85e-130: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT)))) else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT)))) t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + t_0) tmp = 0.0 if (EDonor <= -5.3e+165) tmp = t_1; elseif (EDonor <= -1.6e-241) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(Float64(Float64(Vef + mu) - Float64(Ec - EDonor)) / KbT)))); elseif (EDonor <= 7.4e-236) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0); elseif (EDonor <= 2.85e-130) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))); t_1 = (NdChar / (1.0 + exp((EDonor / KbT)))) + t_0; tmp = 0.0; if (EDonor <= -5.3e+165) tmp = t_1; elseif (EDonor <= -1.6e-241) tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT))); elseif (EDonor <= 7.4e-236) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0; elseif (EDonor <= 2.85e-130) tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT)))); else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, If[LessEqual[EDonor, -5.3e+165], t$95$1, If[LessEqual[EDonor, -1.6e-241], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(N[(N[(Vef + mu), $MachinePrecision] - N[(Ec - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 7.4e-236], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[EDonor, 2.85e-130], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + t\_0\\
\mathbf{if}\;EDonor \leq -5.3 \cdot 10^{+165}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;EDonor \leq -1.6 \cdot 10^{-241}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{NdChar}{2 + \frac{\left(Vef + mu\right) - \left(Ec - EDonor\right)}{KbT}}\\
\mathbf{elif}\;EDonor \leq 7.4 \cdot 10^{-236}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + t\_0\\
\mathbf{elif}\;EDonor \leq 2.85 \cdot 10^{-130}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if EDonor < -5.3000000000000001e165 or 2.8499999999999999e-130 < EDonor Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 86.3%
Taylor expanded in Ev around 0 74.6%
+-commutative74.6%
Simplified74.6%
if -5.3000000000000001e165 < EDonor < -1.6e-241Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 65.2%
mul-1-neg65.2%
associate-+r+65.2%
+-commutative65.2%
associate-+r+65.2%
unsub-neg65.2%
associate-+r+65.2%
+-commutative65.2%
associate-+r+65.2%
associate--r+65.2%
Simplified65.2%
if -1.6e-241 < EDonor < 7.40000000000000042e-236Initial program 99.9%
Simplified99.9%
Taylor expanded in Vef around inf 77.3%
Taylor expanded in Ev around 0 70.9%
+-commutative46.2%
Simplified70.9%
if 7.40000000000000042e-236 < EDonor < 2.8499999999999999e-130Initial program 100.0%
Simplified100.0%
Taylor expanded in mu around inf 95.9%
Taylor expanded in Ev around inf 83.0%
Final simplification71.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))))
(if (<= mu -1.4e+172)
t_0
(if (<= mu 7.2e-168)
(+
(/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= mu 3e-60)
(+
(/ NdChar (+ 1.0 (exp (/ Vef KbT))))
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) KbT)))))
(if (<= mu 2.5e+117)
(/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
t_0))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
double tmp;
if (mu <= -1.4e+172) {
tmp = t_0;
} else if (mu <= 7.2e-168) {
tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (mu <= 3e-60) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
} else if (mu <= 2.5e+117) {
tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
if (mu <= (-1.4d+172)) then
tmp = t_0
else if (mu <= 7.2d-168) then
tmp = (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (mu <= 3d-60) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt))))
else if (mu <= 2.5d+117) then
tmp = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
double tmp;
if (mu <= -1.4e+172) {
tmp = t_0;
} else if (mu <= 7.2e-168) {
tmp = (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (mu <= 3e-60) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT))));
} else if (mu <= 2.5e+117) {
tmp = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT)))) tmp = 0 if mu <= -1.4e+172: tmp = t_0 elif mu <= 7.2e-168: tmp = (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif mu <= 3e-60: tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT)))) elif mu <= 2.5e+117: tmp = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT))) else: tmp = t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))) tmp = 0.0 if (mu <= -1.4e+172) tmp = t_0; elseif (mu <= 7.2e-168) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (mu <= 3e-60) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT))))); elseif (mu <= 2.5e+117) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)))); else tmp = t_0; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT)))); tmp = 0.0; if (mu <= -1.4e+172) tmp = t_0; elseif (mu <= 7.2e-168) tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (mu <= 3e-60) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)))); elseif (mu <= 2.5e+117) tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT))); else tmp = t_0; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.4e+172], t$95$0, If[LessEqual[mu, 7.2e-168], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3e-60], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.5e+117], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{if}\;mu \leq -1.4 \cdot 10^{+172}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;mu \leq 7.2 \cdot 10^{-168}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;mu \leq 3 \cdot 10^{-60}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\
\mathbf{elif}\;mu \leq 2.5 \cdot 10^{+117}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if mu < -1.4e172 or 2.49999999999999992e117 < mu Initial program 100.0%
Simplified100.0%
Taylor expanded in mu around inf 89.5%
Taylor expanded in mu around inf 82.9%
associate-*r/42.5%
mul-1-neg42.5%
Simplified82.9%
if -1.4e172 < mu < 7.1999999999999998e-168Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 78.5%
if 7.1999999999999998e-168 < mu < 3.00000000000000019e-60Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 84.9%
Taylor expanded in Ev around 0 77.9%
+-commutative51.8%
Simplified77.9%
if 3.00000000000000019e-60 < mu < 2.49999999999999992e117Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 66.6%
mul-1-neg66.6%
associate-+r+66.6%
+-commutative66.6%
associate-+r+66.6%
unsub-neg66.6%
associate-+r+66.6%
+-commutative66.6%
associate-+r+66.6%
associate--r+66.6%
Simplified66.6%
Taylor expanded in Ec around inf 42.5%
mul-1-neg42.5%
associate-/l*42.5%
distribute-lft-neg-in42.5%
Simplified42.5%
Taylor expanded in KbT around 0 75.8%
Final simplification79.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT)))))
(t_1 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))
(if (<= Vef -3.65e+171)
(+ t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) KbT)))))
(if (<= Vef -5.2e+51)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(if (<= Vef 1.15e-46)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(+ t_0 t_1))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)));
double t_1 = NdChar / (1.0 + exp((Vef / KbT)));
double tmp;
if (Vef <= -3.65e+171) {
tmp = t_1 + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
} else if (Vef <= -5.2e+51) {
tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
} else if (Vef <= 1.15e-46) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else {
tmp = t_0 + t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))
t_1 = ndchar / (1.0d0 + exp((vef / kbt)))
if (vef <= (-3.65d+171)) then
tmp = t_1 + (nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt))))
else if (vef <= (-5.2d+51)) then
tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
else if (vef <= 1.15d-46) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else
tmp = t_0 + t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)));
double t_1 = NdChar / (1.0 + Math.exp((Vef / KbT)));
double tmp;
if (Vef <= -3.65e+171) {
tmp = t_1 + (NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT))));
} else if (Vef <= -5.2e+51) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
} else if (Vef <= 1.15e-46) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else {
tmp = t_0 + t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))) t_1 = NdChar / (1.0 + math.exp((Vef / KbT))) tmp = 0 if Vef <= -3.65e+171: tmp = t_1 + (NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT)))) elif Vef <= -5.2e+51: tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT)))) elif Vef <= 1.15e-46: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) else: tmp = t_0 + t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) tmp = 0.0 if (Vef <= -3.65e+171) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT))))); elseif (Vef <= -5.2e+51) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); elseif (Vef <= 1.15e-46) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); else tmp = Float64(t_0 + t_1); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT))); t_1 = NdChar / (1.0 + exp((Vef / KbT))); tmp = 0.0; if (Vef <= -3.65e+171) tmp = t_1 + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)))); elseif (Vef <= -5.2e+51) tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT)))); elseif (Vef <= 1.15e-46) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); else tmp = t_0 + t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.65e+171], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -5.2e+51], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.15e-46], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + t$95$1), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;Vef \leq -3.65 \cdot 10^{+171}:\\
\;\;\;\;t\_1 + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\
\mathbf{elif}\;Vef \leq -5.2 \cdot 10^{+51}:\\
\;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{elif}\;Vef \leq 1.15 \cdot 10^{-46}:\\
\;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t\_0 + t\_1\\
\end{array}
\end{array}
if Vef < -3.6500000000000001e171Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 82.2%
Taylor expanded in Ev around 0 71.8%
+-commutative49.9%
Simplified71.8%
if -3.6500000000000001e171 < Vef < -5.2000000000000002e51Initial program 99.9%
Simplified99.9%
Taylor expanded in mu around inf 91.0%
if -5.2000000000000002e51 < Vef < 1.15e-46Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 77.3%
if 1.15e-46 < Vef Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 87.3%
Final simplification80.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) KbT)))))))
(if (<= EDonor -1.25e+166)
t_0
(if (<= EDonor 2.75e-254)
(+
(/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))
(/ NdChar (+ 2.0 (/ (- (+ Vef mu) (- Ec EDonor)) KbT))))
(if (<= EDonor 1.65e-131)
(+
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
double tmp;
if (EDonor <= -1.25e+166) {
tmp = t_0;
} else if (EDonor <= 2.75e-254) {
tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)));
} else if (EDonor <= 1.65e-131) {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt))))
if (edonor <= (-1.25d+166)) then
tmp = t_0
else if (edonor <= 2.75d-254) then
tmp = (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))) + (ndchar / (2.0d0 + (((vef + mu) - (ec - edonor)) / kbt)))
else if (edonor <= 1.65d-131) then
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT))));
double tmp;
if (EDonor <= -1.25e+166) {
tmp = t_0;
} else if (EDonor <= 2.75e-254) {
tmp = (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)));
} else if (EDonor <= 1.65e-131) {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT)))) tmp = 0 if EDonor <= -1.25e+166: tmp = t_0 elif EDonor <= 2.75e-254: tmp = (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT))) elif EDonor <= 1.65e-131: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT)))) else: tmp = t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT))))) tmp = 0.0 if (EDonor <= -1.25e+166) tmp = t_0; elseif (EDonor <= 2.75e-254) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(Float64(Float64(Vef + mu) - Float64(Ec - EDonor)) / KbT)))); elseif (EDonor <= 1.65e-131) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); else tmp = t_0; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)))); tmp = 0.0; if (EDonor <= -1.25e+166) tmp = t_0; elseif (EDonor <= 2.75e-254) tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT))); elseif (EDonor <= 1.65e-131) tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT)))); else tmp = t_0; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -1.25e+166], t$95$0, If[LessEqual[EDonor, 2.75e-254], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(N[(N[(Vef + mu), $MachinePrecision] - N[(Ec - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 1.65e-131], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\
\mathbf{if}\;EDonor \leq -1.25 \cdot 10^{+166}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;EDonor \leq 2.75 \cdot 10^{-254}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{NdChar}{2 + \frac{\left(Vef + mu\right) - \left(Ec - EDonor\right)}{KbT}}\\
\mathbf{elif}\;EDonor \leq 1.65 \cdot 10^{-131}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if EDonor < -1.25e166 or 1.6500000000000001e-131 < EDonor Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 86.3%
Taylor expanded in Ev around 0 74.6%
+-commutative74.6%
Simplified74.6%
if -1.25e166 < EDonor < 2.74999999999999995e-254Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 63.8%
mul-1-neg63.8%
associate-+r+63.8%
+-commutative63.8%
associate-+r+63.8%
unsub-neg63.8%
associate-+r+63.8%
+-commutative63.8%
associate-+r+63.8%
associate--r+63.8%
Simplified63.8%
if 2.74999999999999995e-254 < EDonor < 1.6500000000000001e-131Initial program 100.0%
Simplified100.0%
Taylor expanded in mu around inf 90.5%
Taylor expanded in Ev around inf 76.5%
Final simplification70.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(if (<= NdChar -7.5e+211)
(+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) t_0)
(if (<= NdChar -1.3e+21)
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= NdChar -1.1e-35)
(+ (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))) t_0)
(if (<= NdChar 1.95e+129)
(+
(/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))
(/ 1.0 (/ (+ 2.0 (/ (- (+ Vef mu) (- Ec EDonor)) KbT)) NdChar)))
(+
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))
(* NaChar 0.5))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
double tmp;
if (NdChar <= -7.5e+211) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0;
} else if (NdChar <= -1.3e+21) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (NdChar <= -1.1e-35) {
tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + t_0;
} else if (NdChar <= 1.95e+129) {
tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar));
} else {
tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((eaccept / kbt)))
if (ndchar <= (-7.5d+211)) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + t_0
else if (ndchar <= (-1.3d+21)) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
else if (ndchar <= (-1.1d-35)) then
tmp = (ndchar / (1.0d0 + exp((-ec / kbt)))) + t_0
else if (ndchar <= 1.95d+129) then
tmp = (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))) + (1.0d0 / ((2.0d0 + (((vef + mu) - (ec - edonor)) / kbt)) / ndchar))
else
tmp = (ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))) + (nachar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
double tmp;
if (NdChar <= -7.5e+211) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + t_0;
} else if (NdChar <= -1.3e+21) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (NdChar <= -1.1e-35) {
tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + t_0;
} else if (NdChar <= 1.95e+129) {
tmp = (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar));
} else {
tmp = (NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((EAccept / KbT))) tmp = 0 if NdChar <= -7.5e+211: tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + t_0 elif NdChar <= -1.3e+21: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif NdChar <= -1.1e-35: tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + t_0 elif NdChar <= 1.95e+129: tmp = (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar)) else: tmp = (NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) tmp = 0.0 if (NdChar <= -7.5e+211) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + t_0); elseif (NdChar <= -1.3e+21) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (NdChar <= -1.1e-35) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + t_0); elseif (NdChar <= 1.95e+129) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) + Float64(1.0 / Float64(Float64(2.0 + Float64(Float64(Float64(Vef + mu) - Float64(Ec - EDonor)) / KbT)) / NdChar))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT)))) + Float64(NaChar * 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((EAccept / KbT))); tmp = 0.0; if (NdChar <= -7.5e+211) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + t_0; elseif (NdChar <= -1.3e+21) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (NdChar <= -1.1e-35) tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + t_0; elseif (NdChar <= 1.95e+129) tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar)); else tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 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[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -7.5e+211], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[NdChar, -1.3e+21], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -1.1e-35], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[NdChar, 1.95e+129], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(N[(2.0 + N[(N[(N[(Vef + mu), $MachinePrecision] - N[(Ec - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision] / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{if}\;NdChar \leq -7.5 \cdot 10^{+211}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + t\_0\\
\mathbf{elif}\;NdChar \leq -1.3 \cdot 10^{+21}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;NdChar \leq -1.1 \cdot 10^{-35}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + t\_0\\
\mathbf{elif}\;NdChar \leq 1.95 \cdot 10^{+129}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{1}{\frac{2 + \frac{\left(Vef + mu\right) - \left(Ec - EDonor\right)}{KbT}}{NdChar}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}} + NaChar \cdot 0.5\\
\end{array}
\end{array}
if NdChar < -7.5e211Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 73.3%
Taylor expanded in EAccept around inf 58.4%
if -7.5e211 < NdChar < -1.3e21Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 75.0%
Taylor expanded in Ev around inf 59.4%
if -1.3e21 < NdChar < -1.09999999999999997e-35Initial program 100.0%
Simplified100.0%
Taylor expanded in Ec around inf 65.6%
mul-1-neg65.6%
distribute-neg-frac265.6%
Simplified65.6%
Taylor expanded in EAccept around inf 52.2%
if -1.09999999999999997e-35 < NdChar < 1.9499999999999999e129Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 75.0%
mul-1-neg75.0%
associate-+r+75.0%
+-commutative75.0%
associate-+r+75.0%
unsub-neg75.0%
associate-+r+75.0%
+-commutative75.0%
associate-+r+75.0%
associate--r+75.0%
Simplified75.0%
clear-num75.5%
inv-pow75.5%
Applied egg-rr75.5%
unpow-175.5%
+-commutative75.5%
Simplified75.5%
if 1.9499999999999999e129 < NdChar Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 69.8%
*-commutative27.5%
Simplified69.8%
Final simplification69.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT)))))
(t_1 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))
(if (<= Vef -6.5e+164)
(+ t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef EAccept) mu) KbT)))))
(if (<= Vef 4.1e-30)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(+ t_0 t_1)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)));
double t_1 = NdChar / (1.0 + exp((Vef / KbT)));
double tmp;
if (Vef <= -6.5e+164) {
tmp = t_1 + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT))));
} else if (Vef <= 4.1e-30) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else {
tmp = t_0 + t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))
t_1 = ndchar / (1.0d0 + exp((vef / kbt)))
if (vef <= (-6.5d+164)) then
tmp = t_1 + (nachar / (1.0d0 + exp((((vef + eaccept) - mu) / kbt))))
else if (vef <= 4.1d-30) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else
tmp = t_0 + t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)));
double t_1 = NdChar / (1.0 + Math.exp((Vef / KbT)));
double tmp;
if (Vef <= -6.5e+164) {
tmp = t_1 + (NaChar / (1.0 + Math.exp((((Vef + EAccept) - mu) / KbT))));
} else if (Vef <= 4.1e-30) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else {
tmp = t_0 + t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))) t_1 = NdChar / (1.0 + math.exp((Vef / KbT))) tmp = 0 if Vef <= -6.5e+164: tmp = t_1 + (NaChar / (1.0 + math.exp((((Vef + EAccept) - mu) / KbT)))) elif Vef <= 4.1e-30: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) else: tmp = t_0 + t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) tmp = 0.0 if (Vef <= -6.5e+164) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + EAccept) - mu) / KbT))))); elseif (Vef <= 4.1e-30) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); else tmp = Float64(t_0 + t_1); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT))); t_1 = NdChar / (1.0 + exp((Vef / KbT))); tmp = 0.0; if (Vef <= -6.5e+164) tmp = t_1 + (NaChar / (1.0 + exp((((Vef + EAccept) - mu) / KbT)))); elseif (Vef <= 4.1e-30) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); else tmp = t_0 + t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -6.5e+164], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + EAccept), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 4.1e-30], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;Vef \leq -6.5 \cdot 10^{+164}:\\
\;\;\;\;t\_1 + \frac{NaChar}{1 + e^{\frac{\left(Vef + EAccept\right) - mu}{KbT}}}\\
\mathbf{elif}\;Vef \leq 4.1 \cdot 10^{-30}:\\
\;\;\;\;t\_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t\_0 + t\_1\\
\end{array}
\end{array}
if Vef < -6.5000000000000003e164Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 82.8%
Taylor expanded in Ev around 0 72.7%
+-commutative48.8%
Simplified72.7%
if -6.5000000000000003e164 < Vef < 4.1000000000000003e-30Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 76.0%
if 4.1000000000000003e-30 < Vef Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 87.3%
Final simplification78.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NdChar -5.5e+211)
(+
(/ NdChar (+ 1.0 (exp (/ Vef KbT))))
(/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(if (<= NdChar -3.5e+20)
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= NdChar -9.5e+19)
(+ (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))) (* NaChar 0.5))
(if (<= NdChar 5e+132)
(+
(/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))
(/ 1.0 (/ (+ 2.0 (/ (- (+ Vef mu) (- Ec EDonor)) KbT)) NdChar)))
(+
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))
(* NaChar 0.5)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NdChar <= -5.5e+211) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
} else if (NdChar <= -3.5e+20) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (NdChar <= -9.5e+19) {
tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar * 0.5);
} else if (NdChar <= 5e+132) {
tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar));
} else {
tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (ndchar <= (-5.5d+211)) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
else if (ndchar <= (-3.5d+20)) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
else if (ndchar <= (-9.5d+19)) then
tmp = (ndchar / (1.0d0 + exp((-ec / kbt)))) + (nachar * 0.5d0)
else if (ndchar <= 5d+132) then
tmp = (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))) + (1.0d0 / ((2.0d0 + (((vef + mu) - (ec - edonor)) / kbt)) / ndchar))
else
tmp = (ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))) + (nachar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NdChar <= -5.5e+211) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else if (NdChar <= -3.5e+20) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (NdChar <= -9.5e+19) {
tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar * 0.5);
} else if (NdChar <= 5e+132) {
tmp = (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar));
} else {
tmp = (NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NdChar <= -5.5e+211: tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) elif NdChar <= -3.5e+20: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif NdChar <= -9.5e+19: tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar * 0.5) elif NdChar <= 5e+132: tmp = (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar)) else: tmp = (NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NdChar <= -5.5e+211) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); elseif (NdChar <= -3.5e+20) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (NdChar <= -9.5e+19) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + Float64(NaChar * 0.5)); elseif (NdChar <= 5e+132) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) + Float64(1.0 / Float64(Float64(2.0 + Float64(Float64(Float64(Vef + mu) - Float64(Ec - EDonor)) / KbT)) / NdChar))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT)))) + Float64(NaChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NdChar <= -5.5e+211) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT)))); elseif (NdChar <= -3.5e+20) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (NdChar <= -9.5e+19) tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar * 0.5); elseif (NdChar <= 5e+132) tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar)); else tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NdChar, -5.5e+211], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -3.5e+20], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -9.5e+19], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 5e+132], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(N[(2.0 + N[(N[(N[(Vef + mu), $MachinePrecision] - N[(Ec - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision] / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -5.5 \cdot 10^{+211}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{elif}\;NdChar \leq -3.5 \cdot 10^{+20}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;NdChar \leq -9.5 \cdot 10^{+19}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{elif}\;NdChar \leq 5 \cdot 10^{+132}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{1}{\frac{2 + \frac{\left(Vef + mu\right) - \left(Ec - EDonor\right)}{KbT}}{NdChar}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}} + NaChar \cdot 0.5\\
\end{array}
\end{array}
if NdChar < -5.49999999999999988e211Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 73.3%
Taylor expanded in EAccept around inf 58.4%
if -5.49999999999999988e211 < NdChar < -3.5e20Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 75.0%
Taylor expanded in Ev around inf 59.4%
if -3.5e20 < NdChar < -9.5e19Initial program 100.0%
Simplified100.0%
Taylor expanded in Ec around inf 100.0%
mul-1-neg100.0%
distribute-neg-frac2100.0%
Simplified100.0%
Taylor expanded in KbT around inf 100.0%
*-commutative18.8%
Simplified100.0%
if -9.5e19 < NdChar < 5.0000000000000001e132Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 73.4%
mul-1-neg73.4%
associate-+r+73.4%
+-commutative73.4%
associate-+r+73.4%
unsub-neg73.4%
associate-+r+73.4%
+-commutative73.4%
associate-+r+73.4%
associate--r+73.4%
Simplified73.4%
clear-num73.9%
inv-pow73.9%
Applied egg-rr73.9%
unpow-173.9%
+-commutative73.9%
Simplified73.9%
if 5.0000000000000001e132 < NdChar Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 69.8%
*-commutative27.5%
Simplified69.8%
Final simplification69.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(t_1 (+ t_0 (/ NdChar 2.0)))
(t_2 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(if (<= Ev -2e+232)
t_0
(if (<= Ev -4e+135)
t_1
(if (<= Ev -5.6e+127)
t_2
(if (<= Ev -4.2e-47)
t_1
(if (<= Ev -1.35e-298)
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(if (<= Ev 6.8e-87) (+ t_2 (/ NdChar 2.0)) t_2))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((Ev / KbT)));
double t_1 = t_0 + (NdChar / 2.0);
double t_2 = NaChar / (1.0 + exp((EAccept / KbT)));
double tmp;
if (Ev <= -2e+232) {
tmp = t_0;
} else if (Ev <= -4e+135) {
tmp = t_1;
} else if (Ev <= -5.6e+127) {
tmp = t_2;
} else if (Ev <= -4.2e-47) {
tmp = t_1;
} else if (Ev <= -1.35e-298) {
tmp = NaChar / (1.0 + exp((-mu / KbT)));
} else if (Ev <= 6.8e-87) {
tmp = t_2 + (NdChar / 2.0);
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((ev / kbt)))
t_1 = t_0 + (ndchar / 2.0d0)
t_2 = nachar / (1.0d0 + exp((eaccept / kbt)))
if (ev <= (-2d+232)) then
tmp = t_0
else if (ev <= (-4d+135)) then
tmp = t_1
else if (ev <= (-5.6d+127)) then
tmp = t_2
else if (ev <= (-4.2d-47)) then
tmp = t_1
else if (ev <= (-1.35d-298)) then
tmp = nachar / (1.0d0 + exp((-mu / kbt)))
else if (ev <= 6.8d-87) then
tmp = t_2 + (ndchar / 2.0d0)
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((Ev / KbT)));
double t_1 = t_0 + (NdChar / 2.0);
double t_2 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
double tmp;
if (Ev <= -2e+232) {
tmp = t_0;
} else if (Ev <= -4e+135) {
tmp = t_1;
} else if (Ev <= -5.6e+127) {
tmp = t_2;
} else if (Ev <= -4.2e-47) {
tmp = t_1;
} else if (Ev <= -1.35e-298) {
tmp = NaChar / (1.0 + Math.exp((-mu / KbT)));
} else if (Ev <= 6.8e-87) {
tmp = t_2 + (NdChar / 2.0);
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((Ev / KbT))) t_1 = t_0 + (NdChar / 2.0) t_2 = NaChar / (1.0 + math.exp((EAccept / KbT))) tmp = 0 if Ev <= -2e+232: tmp = t_0 elif Ev <= -4e+135: tmp = t_1 elif Ev <= -5.6e+127: tmp = t_2 elif Ev <= -4.2e-47: tmp = t_1 elif Ev <= -1.35e-298: tmp = NaChar / (1.0 + math.exp((-mu / KbT))) elif Ev <= 6.8e-87: tmp = t_2 + (NdChar / 2.0) 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(Ev / KbT)))) t_1 = Float64(t_0 + Float64(NdChar / 2.0)) t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) tmp = 0.0 if (Ev <= -2e+232) tmp = t_0; elseif (Ev <= -4e+135) tmp = t_1; elseif (Ev <= -5.6e+127) tmp = t_2; elseif (Ev <= -4.2e-47) tmp = t_1; elseif (Ev <= -1.35e-298) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))); elseif (Ev <= 6.8e-87) tmp = Float64(t_2 + Float64(NdChar / 2.0)); 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((Ev / KbT))); t_1 = t_0 + (NdChar / 2.0); t_2 = NaChar / (1.0 + exp((EAccept / KbT))); tmp = 0.0; if (Ev <= -2e+232) tmp = t_0; elseif (Ev <= -4e+135) tmp = t_1; elseif (Ev <= -5.6e+127) tmp = t_2; elseif (Ev <= -4.2e-47) tmp = t_1; elseif (Ev <= -1.35e-298) tmp = NaChar / (1.0 + exp((-mu / KbT))); elseif (Ev <= 6.8e-87) tmp = t_2 + (NdChar / 2.0); else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -2e+232], t$95$0, If[LessEqual[Ev, -4e+135], t$95$1, If[LessEqual[Ev, -5.6e+127], t$95$2, If[LessEqual[Ev, -4.2e-47], t$95$1, If[LessEqual[Ev, -1.35e-298], N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 6.8e-87], N[(t$95$2 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
t_1 := t\_0 + \frac{NdChar}{2}\\
t_2 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{if}\;Ev \leq -2 \cdot 10^{+232}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;Ev \leq -4 \cdot 10^{+135}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;Ev \leq -5.6 \cdot 10^{+127}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;Ev \leq -4.2 \cdot 10^{-47}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;Ev \leq -1.35 \cdot 10^{-298}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{elif}\;Ev \leq 6.8 \cdot 10^{-87}:\\
\;\;\;\;t\_2 + \frac{NdChar}{2}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if Ev < -2.00000000000000011e232Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.9%
mul-1-neg60.9%
associate-+r+60.9%
+-commutative60.9%
associate-+r+60.9%
unsub-neg60.9%
associate-+r+60.9%
+-commutative60.9%
associate-+r+60.9%
associate--r+60.9%
Simplified60.9%
Taylor expanded in Ec around inf 33.4%
mul-1-neg33.4%
associate-/l*41.9%
distribute-lft-neg-in41.9%
Simplified41.9%
Taylor expanded in KbT around 0 80.7%
Taylor expanded in Ev around inf 74.4%
if -2.00000000000000011e232 < Ev < -3.99999999999999985e135 or -5.6000000000000004e127 < Ev < -4.2000000000000001e-47Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 52.8%
Taylor expanded in Ev around inf 46.6%
if -3.99999999999999985e135 < Ev < -5.6000000000000004e127 or 6.7999999999999997e-87 < Ev Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 61.0%
mul-1-neg61.0%
associate-+r+61.0%
+-commutative61.0%
associate-+r+61.0%
unsub-neg61.0%
associate-+r+61.0%
+-commutative61.0%
associate-+r+61.0%
associate--r+61.0%
Simplified61.0%
Taylor expanded in Ec around inf 34.8%
mul-1-neg34.8%
associate-/l*33.8%
distribute-lft-neg-in33.8%
Simplified33.8%
Taylor expanded in KbT around 0 61.4%
Taylor expanded in EAccept around inf 36.0%
if -4.2000000000000001e-47 < Ev < -1.3500000000000001e-298Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 62.3%
mul-1-neg62.3%
associate-+r+62.3%
+-commutative62.3%
associate-+r+62.3%
unsub-neg62.3%
associate-+r+62.3%
+-commutative62.3%
associate-+r+62.3%
associate--r+62.3%
Simplified62.3%
Taylor expanded in Ec around inf 27.0%
mul-1-neg27.0%
associate-/l*25.0%
distribute-lft-neg-in25.0%
Simplified25.0%
Taylor expanded in KbT around 0 62.2%
Taylor expanded in mu around inf 43.0%
associate-*r/43.0%
mul-1-neg43.0%
Simplified43.0%
if -1.3500000000000001e-298 < Ev < 6.7999999999999997e-87Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 51.7%
Taylor expanded in EAccept around inf 44.4%
Final simplification43.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(if (<= Ev -2e+232)
t_0
(if (<= Ev -1.3e+134)
(+ t_0 (/ NdChar 2.0))
(if (<= Ev -6.5e+92)
t_1
(if (<= Ev -2.6e-20)
(+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (* NaChar 0.5))
(if (<= Ev 5.5e-254)
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(if (<= Ev 3.4e-86)
(+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 0.5))
t_1))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((Ev / KbT)));
double t_1 = NaChar / (1.0 + exp((EAccept / KbT)));
double tmp;
if (Ev <= -2e+232) {
tmp = t_0;
} else if (Ev <= -1.3e+134) {
tmp = t_0 + (NdChar / 2.0);
} else if (Ev <= -6.5e+92) {
tmp = t_1;
} else if (Ev <= -2.6e-20) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar * 0.5);
} else if (Ev <= 5.5e-254) {
tmp = NaChar / (1.0 + exp((-mu / KbT)));
} else if (Ev <= 3.4e-86) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((ev / kbt)))
t_1 = nachar / (1.0d0 + exp((eaccept / kbt)))
if (ev <= (-2d+232)) then
tmp = t_0
else if (ev <= (-1.3d+134)) then
tmp = t_0 + (ndchar / 2.0d0)
else if (ev <= (-6.5d+92)) then
tmp = t_1
else if (ev <= (-2.6d-20)) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar * 0.5d0)
else if (ev <= 5.5d-254) then
tmp = nachar / (1.0d0 + exp((-mu / kbt)))
else if (ev <= 3.4d-86) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar * 0.5d0)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((Ev / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
double tmp;
if (Ev <= -2e+232) {
tmp = t_0;
} else if (Ev <= -1.3e+134) {
tmp = t_0 + (NdChar / 2.0);
} else if (Ev <= -6.5e+92) {
tmp = t_1;
} else if (Ev <= -2.6e-20) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar * 0.5);
} else if (Ev <= 5.5e-254) {
tmp = NaChar / (1.0 + Math.exp((-mu / KbT)));
} else if (Ev <= 3.4e-86) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar * 0.5);
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((Ev / KbT))) t_1 = NaChar / (1.0 + math.exp((EAccept / KbT))) tmp = 0 if Ev <= -2e+232: tmp = t_0 elif Ev <= -1.3e+134: tmp = t_0 + (NdChar / 2.0) elif Ev <= -6.5e+92: tmp = t_1 elif Ev <= -2.6e-20: tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar * 0.5) elif Ev <= 5.5e-254: tmp = NaChar / (1.0 + math.exp((-mu / KbT))) elif Ev <= 3.4e-86: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar * 0.5) else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) tmp = 0.0 if (Ev <= -2e+232) tmp = t_0; elseif (Ev <= -1.3e+134) tmp = Float64(t_0 + Float64(NdChar / 2.0)); elseif (Ev <= -6.5e+92) tmp = t_1; elseif (Ev <= -2.6e-20) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar * 0.5)); elseif (Ev <= 5.5e-254) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))); elseif (Ev <= 3.4e-86) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar * 0.5)); else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((Ev / KbT))); t_1 = NaChar / (1.0 + exp((EAccept / KbT))); tmp = 0.0; if (Ev <= -2e+232) tmp = t_0; elseif (Ev <= -1.3e+134) tmp = t_0 + (NdChar / 2.0); elseif (Ev <= -6.5e+92) tmp = t_1; elseif (Ev <= -2.6e-20) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar * 0.5); elseif (Ev <= 5.5e-254) tmp = NaChar / (1.0 + exp((-mu / KbT))); elseif (Ev <= 3.4e-86) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5); else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -2e+232], t$95$0, If[LessEqual[Ev, -1.3e+134], N[(t$95$0 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, -6.5e+92], t$95$1, If[LessEqual[Ev, -2.6e-20], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 5.5e-254], N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ev, 3.4e-86], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{if}\;Ev \leq -2 \cdot 10^{+232}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;Ev \leq -1.3 \cdot 10^{+134}:\\
\;\;\;\;t\_0 + \frac{NdChar}{2}\\
\mathbf{elif}\;Ev \leq -6.5 \cdot 10^{+92}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;Ev \leq -2.6 \cdot 10^{-20}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{elif}\;Ev \leq 5.5 \cdot 10^{-254}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{elif}\;Ev \leq 3.4 \cdot 10^{-86}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if Ev < -2.00000000000000011e232Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.9%
mul-1-neg60.9%
associate-+r+60.9%
+-commutative60.9%
associate-+r+60.9%
unsub-neg60.9%
associate-+r+60.9%
+-commutative60.9%
associate-+r+60.9%
associate--r+60.9%
Simplified60.9%
Taylor expanded in Ec around inf 33.4%
mul-1-neg33.4%
associate-/l*41.9%
distribute-lft-neg-in41.9%
Simplified41.9%
Taylor expanded in KbT around 0 80.7%
Taylor expanded in Ev around inf 74.4%
if -2.00000000000000011e232 < Ev < -1.3000000000000001e134Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 46.8%
Taylor expanded in Ev around inf 43.0%
if -1.3000000000000001e134 < Ev < -6.49999999999999999e92 or 3.4e-86 < Ev Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.4%
mul-1-neg60.4%
associate-+r+60.4%
+-commutative60.4%
associate-+r+60.4%
unsub-neg60.4%
associate-+r+60.4%
+-commutative60.4%
associate-+r+60.4%
associate--r+60.4%
Simplified60.4%
Taylor expanded in Ec around inf 36.4%
mul-1-neg36.4%
associate-/l*35.5%
distribute-lft-neg-in35.5%
Simplified35.5%
Taylor expanded in KbT around 0 60.9%
Taylor expanded in EAccept around inf 34.4%
if -6.49999999999999999e92 < Ev < -2.59999999999999995e-20Initial program 100.0%
Simplified100.0%
Taylor expanded in Vef around inf 90.2%
Taylor expanded in KbT around inf 64.8%
*-commutative45.9%
Simplified64.8%
if -2.59999999999999995e-20 < Ev < 5.4999999999999999e-254Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 64.2%
mul-1-neg64.2%
associate-+r+64.2%
+-commutative64.2%
associate-+r+64.2%
unsub-neg64.2%
associate-+r+64.2%
+-commutative64.2%
associate-+r+64.2%
associate--r+64.2%
Simplified64.2%
Taylor expanded in Ec around inf 27.6%
mul-1-neg27.6%
associate-/l*26.0%
distribute-lft-neg-in26.0%
Simplified26.0%
Taylor expanded in KbT around 0 62.8%
Taylor expanded in mu around inf 43.5%
associate-*r/43.5%
mul-1-neg43.5%
Simplified43.5%
if 5.4999999999999999e-254 < Ev < 3.4e-86Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 89.5%
Taylor expanded in KbT around inf 52.9%
*-commutative38.0%
Simplified52.9%
Final simplification45.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -2.4e+61) (not (<= NdChar 1e+128)))
(+
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))
(* NaChar 0.5))
(+
(/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))
(/ 1.0 (/ (+ 2.0 (/ (- (+ Vef mu) (- Ec EDonor)) KbT)) NdChar)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -2.4e+61) || !(NdChar <= 1e+128)) {
tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((ndchar <= (-2.4d+61)) .or. (.not. (ndchar <= 1d+128))) then
tmp = (ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))) + (1.0d0 / ((2.0d0 + (((vef + mu) - (ec - edonor)) / kbt)) / ndchar))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -2.4e+61) || !(NdChar <= 1e+128)) {
tmp = (NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -2.4e+61) or not (NdChar <= 1e+128): tmp = (NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -2.4e+61) || !(NdChar <= 1e+128)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) + Float64(1.0 / Float64(Float64(2.0 + Float64(Float64(Float64(Vef + mu) - Float64(Ec - EDonor)) / KbT)) / NdChar))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -2.4e+61) || ~((NdChar <= 1e+128))) tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (1.0 / ((2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)) / NdChar)); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -2.4e+61], N[Not[LessEqual[NdChar, 1e+128]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(N[(2.0 + N[(N[(N[(Vef + mu), $MachinePrecision] - N[(Ec - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision] / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -2.4 \cdot 10^{+61} \lor \neg \left(NdChar \leq 10^{+128}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{1}{\frac{2 + \frac{\left(Vef + mu\right) - \left(Ec - EDonor\right)}{KbT}}{NdChar}}\\
\end{array}
\end{array}
if NdChar < -2.3999999999999999e61 or 1.0000000000000001e128 < NdChar Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 63.4%
*-commutative25.9%
Simplified63.4%
if -2.3999999999999999e61 < NdChar < 1.0000000000000001e128Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 71.9%
mul-1-neg71.9%
associate-+r+71.9%
+-commutative71.9%
associate-+r+71.9%
unsub-neg71.9%
associate-+r+71.9%
+-commutative71.9%
associate-+r+71.9%
associate--r+71.9%
Simplified71.9%
clear-num72.4%
inv-pow72.4%
Applied egg-rr72.4%
unpow-172.4%
+-commutative72.4%
Simplified72.4%
Final simplification69.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= KbT -6.8e+161)
(not
(or (<= KbT -3.4e+119)
(and (not (<= KbT -6e+14)) (<= KbT 7.4e+142)))))
(+
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))
(* NaChar 0.5))
(/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) 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 <= -6.8e+161) || !((KbT <= -3.4e+119) || (!(KbT <= -6e+14) && (KbT <= 7.4e+142)))) {
tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
} else {
tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - 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 <= (-6.8d+161)) .or. (.not. (kbt <= (-3.4d+119)) .or. (.not. (kbt <= (-6d+14))) .and. (kbt <= 7.4d+142))) then
tmp = (ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))) + (nachar * 0.5d0)
else
tmp = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - 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 <= -6.8e+161) || !((KbT <= -3.4e+119) || (!(KbT <= -6e+14) && (KbT <= 7.4e+142)))) {
tmp = (NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
} else {
tmp = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (KbT <= -6.8e+161) or not ((KbT <= -3.4e+119) or (not (KbT <= -6e+14) and (KbT <= 7.4e+142))): tmp = (NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5) else: tmp = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((KbT <= -6.8e+161) || !((KbT <= -3.4e+119) || (!(KbT <= -6e+14) && (KbT <= 7.4e+142)))) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((KbT <= -6.8e+161) || ~(((KbT <= -3.4e+119) || (~((KbT <= -6e+14)) && (KbT <= 7.4e+142))))) tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5); else tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -6.8e+161], N[Not[Or[LessEqual[KbT, -3.4e+119], And[N[Not[LessEqual[KbT, -6e+14]], $MachinePrecision], LessEqual[KbT, 7.4e+142]]]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -6.8 \cdot 10^{+161} \lor \neg \left(KbT \leq -3.4 \cdot 10^{+119} \lor \neg \left(KbT \leq -6 \cdot 10^{+14}\right) \land KbT \leq 7.4 \cdot 10^{+142}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\
\end{array}
\end{array}
if KbT < -6.79999999999999986e161 or -3.40000000000000013e119 < KbT < -6e14 or 7.3999999999999995e142 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 79.4%
*-commutative60.3%
Simplified79.4%
if -6.79999999999999986e161 < KbT < -3.40000000000000013e119 or -6e14 < KbT < 7.3999999999999995e142Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 56.9%
mul-1-neg56.9%
associate-+r+56.9%
+-commutative56.9%
associate-+r+56.9%
unsub-neg56.9%
associate-+r+56.9%
+-commutative56.9%
associate-+r+56.9%
associate--r+56.9%
Simplified56.9%
Taylor expanded in Ec around inf 40.8%
mul-1-neg40.8%
associate-/l*38.0%
distribute-lft-neg-in38.0%
Simplified38.0%
Taylor expanded in KbT around 0 65.6%
Final simplification69.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -1.05e+61) (not (<= NdChar 2.6e+132)))
(+
(/ NdChar (+ 1.0 (exp (/ (- (+ Vef (+ EDonor mu)) Ec) KbT))))
(* NaChar 0.5))
(+
(/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))
(/ NdChar (+ 2.0 (/ (- (+ Vef mu) (- Ec EDonor)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -1.05e+61) || !(NdChar <= 2.6e+132)) {
tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((ndchar <= (-1.05d+61)) .or. (.not. (ndchar <= 2.6d+132))) then
tmp = (ndchar / (1.0d0 + exp((((vef + (edonor + mu)) - ec) / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))) + (ndchar / (2.0d0 + (((vef + mu) - (ec - edonor)) / kbt)))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -1.05e+61) || !(NdChar <= 2.6e+132)) {
tmp = (NdChar / (1.0 + Math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -1.05e+61) or not (NdChar <= 2.6e+132): tmp = (NdChar / (1.0 + math.exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -1.05e+61) || !(NdChar <= 2.6e+132)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(EDonor + mu)) - Ec) / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) + Float64(NdChar / Float64(2.0 + Float64(Float64(Float64(Vef + mu) - Float64(Ec - EDonor)) / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -1.05e+61) || ~((NdChar <= 2.6e+132))) tmp = (NdChar / (1.0 + exp((((Vef + (EDonor + mu)) - Ec) / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / (2.0 + (((Vef + mu) - (Ec - EDonor)) / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.05e+61], N[Not[LessEqual[NdChar, 2.6e+132]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(EDonor + mu), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(N[(N[(Vef + mu), $MachinePrecision] - N[(Ec - EDonor), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -1.05 \cdot 10^{+61} \lor \neg \left(NdChar \leq 2.6 \cdot 10^{+132}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(Vef + \left(EDonor + mu\right)\right) - Ec}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{NdChar}{2 + \frac{\left(Vef + mu\right) - \left(Ec - EDonor\right)}{KbT}}\\
\end{array}
\end{array}
if NdChar < -1.0500000000000001e61 or 2.6e132 < NdChar Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 63.4%
*-commutative25.9%
Simplified63.4%
if -1.0500000000000001e61 < NdChar < 2.6e132Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 71.9%
mul-1-neg71.9%
associate-+r+71.9%
+-commutative71.9%
associate-+r+71.9%
unsub-neg71.9%
associate-+r+71.9%
+-commutative71.9%
associate-+r+71.9%
associate--r+71.9%
Simplified71.9%
Final simplification68.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(if (<= KbT -5e+161)
(+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (/ NdChar 2.0))
(if (<= KbT -2.6e+118)
(/ NaChar (+ 1.0 (exp (/ Vef KbT))))
(if (<= KbT -6.6e+22)
(+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 0.5))
(if (<= KbT -2.8e-259)
t_0
(if (<= KbT 1.7e+127)
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(+ t_0 (/ NdChar 2.0)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
double tmp;
if (KbT <= -5e+161) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
} else if (KbT <= -2.6e+118) {
tmp = NaChar / (1.0 + exp((Vef / KbT)));
} else if (KbT <= -6.6e+22) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
} else if (KbT <= -2.8e-259) {
tmp = t_0;
} else if (KbT <= 1.7e+127) {
tmp = NaChar / (1.0 + exp((Ev / KbT)));
} else {
tmp = t_0 + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((eaccept / kbt)))
if (kbt <= (-5d+161)) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / 2.0d0)
else if (kbt <= (-2.6d+118)) then
tmp = nachar / (1.0d0 + exp((vef / kbt)))
else if (kbt <= (-6.6d+22)) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar * 0.5d0)
else if (kbt <= (-2.8d-259)) then
tmp = t_0
else if (kbt <= 1.7d+127) then
tmp = nachar / (1.0d0 + exp((ev / kbt)))
else
tmp = t_0 + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
double tmp;
if (KbT <= -5e+161) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / 2.0);
} else if (KbT <= -2.6e+118) {
tmp = NaChar / (1.0 + Math.exp((Vef / KbT)));
} else if (KbT <= -6.6e+22) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar * 0.5);
} else if (KbT <= -2.8e-259) {
tmp = t_0;
} else if (KbT <= 1.7e+127) {
tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
} else {
tmp = t_0 + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((EAccept / KbT))) tmp = 0 if KbT <= -5e+161: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / 2.0) elif KbT <= -2.6e+118: tmp = NaChar / (1.0 + math.exp((Vef / KbT))) elif KbT <= -6.6e+22: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar * 0.5) elif KbT <= -2.8e-259: tmp = t_0 elif KbT <= 1.7e+127: tmp = NaChar / (1.0 + math.exp((Ev / KbT))) else: tmp = t_0 + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) tmp = 0.0 if (KbT <= -5e+161) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / 2.0)); elseif (KbT <= -2.6e+118) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))); elseif (KbT <= -6.6e+22) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar * 0.5)); elseif (KbT <= -2.8e-259) tmp = t_0; elseif (KbT <= 1.7e+127) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))); else tmp = Float64(t_0 + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((EAccept / KbT))); tmp = 0.0; if (KbT <= -5e+161) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0); elseif (KbT <= -2.6e+118) tmp = NaChar / (1.0 + exp((Vef / KbT))); elseif (KbT <= -6.6e+22) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5); elseif (KbT <= -2.8e-259) tmp = t_0; elseif (KbT <= 1.7e+127) tmp = NaChar / (1.0 + exp((Ev / KbT))); else tmp = t_0 + (NdChar / 2.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[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -5e+161], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2.6e+118], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -6.6e+22], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2.8e-259], t$95$0, If[LessEqual[KbT, 1.7e+127], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{if}\;KbT \leq -5 \cdot 10^{+161}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{elif}\;KbT \leq -2.6 \cdot 10^{+118}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{elif}\;KbT \leq -6.6 \cdot 10^{+22}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq -2.8 \cdot 10^{-259}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;KbT \leq 1.7 \cdot 10^{+127}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t\_0 + \frac{NdChar}{2}\\
\end{array}
\end{array}
if KbT < -4.9999999999999997e161Initial program 99.9%
Simplified99.9%
Taylor expanded in KbT around inf 81.0%
Taylor expanded in mu around inf 81.0%
associate-*r/81.0%
mul-1-neg81.0%
Simplified81.0%
if -4.9999999999999997e161 < KbT < -2.60000000000000016e118Initial program 99.9%
Simplified99.9%
Taylor expanded in KbT around inf 64.7%
mul-1-neg64.7%
associate-+r+64.7%
+-commutative64.7%
associate-+r+64.7%
unsub-neg64.7%
associate-+r+64.7%
+-commutative64.7%
associate-+r+64.7%
associate--r+64.7%
Simplified64.7%
Taylor expanded in Ec around inf 37.5%
mul-1-neg37.5%
associate-/l*37.5%
distribute-lft-neg-in37.5%
Simplified37.5%
Taylor expanded in KbT around 0 79.9%
Taylor expanded in Vef around inf 65.3%
if -2.60000000000000016e118 < KbT < -6.5999999999999996e22Initial program 100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 72.8%
Taylor expanded in KbT around inf 52.5%
*-commutative27.9%
Simplified52.5%
if -6.5999999999999996e22 < KbT < -2.8e-259Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 53.2%
mul-1-neg53.2%
associate-+r+53.2%
+-commutative53.2%
associate-+r+53.2%
unsub-neg53.2%
associate-+r+53.2%
+-commutative53.2%
associate-+r+53.2%
associate--r+53.2%
Simplified53.2%
Taylor expanded in Ec around inf 40.6%
mul-1-neg40.6%
associate-/l*39.1%
distribute-lft-neg-in39.1%
Simplified39.1%
Taylor expanded in KbT around 0 57.7%
Taylor expanded in EAccept around inf 30.5%
if -2.8e-259 < KbT < 1.69999999999999989e127Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 58.0%
mul-1-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
unsub-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
associate--r+58.0%
Simplified58.0%
Taylor expanded in Ec around inf 40.9%
mul-1-neg40.9%
associate-/l*37.1%
distribute-lft-neg-in37.1%
Simplified37.1%
Taylor expanded in KbT around 0 67.6%
Taylor expanded in Ev around inf 43.5%
if 1.69999999999999989e127 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 76.2%
Taylor expanded in EAccept around inf 64.9%
Final simplification48.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(if (<= KbT -5.5e+161)
(+ (/ NdChar 2.0) (/ NaChar (- 2.0 (/ mu KbT))))
(if (<= KbT -3.3e-7)
(/ NaChar (+ 1.0 (exp (/ Vef KbT))))
(if (<= KbT -1.65e-258)
t_0
(if (<= KbT 3.4e+137)
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(+ t_0 (/ NdChar 2.0))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
double tmp;
if (KbT <= -5.5e+161) {
tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT)));
} else if (KbT <= -3.3e-7) {
tmp = NaChar / (1.0 + exp((Vef / KbT)));
} else if (KbT <= -1.65e-258) {
tmp = t_0;
} else if (KbT <= 3.4e+137) {
tmp = NaChar / (1.0 + exp((Ev / KbT)));
} else {
tmp = t_0 + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((eaccept / kbt)))
if (kbt <= (-5.5d+161)) then
tmp = (ndchar / 2.0d0) + (nachar / (2.0d0 - (mu / kbt)))
else if (kbt <= (-3.3d-7)) then
tmp = nachar / (1.0d0 + exp((vef / kbt)))
else if (kbt <= (-1.65d-258)) then
tmp = t_0
else if (kbt <= 3.4d+137) then
tmp = nachar / (1.0d0 + exp((ev / kbt)))
else
tmp = t_0 + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
double tmp;
if (KbT <= -5.5e+161) {
tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT)));
} else if (KbT <= -3.3e-7) {
tmp = NaChar / (1.0 + Math.exp((Vef / KbT)));
} else if (KbT <= -1.65e-258) {
tmp = t_0;
} else if (KbT <= 3.4e+137) {
tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
} else {
tmp = t_0 + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((EAccept / KbT))) tmp = 0 if KbT <= -5.5e+161: tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT))) elif KbT <= -3.3e-7: tmp = NaChar / (1.0 + math.exp((Vef / KbT))) elif KbT <= -1.65e-258: tmp = t_0 elif KbT <= 3.4e+137: tmp = NaChar / (1.0 + math.exp((Ev / KbT))) else: tmp = t_0 + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) tmp = 0.0 if (KbT <= -5.5e+161) tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); elseif (KbT <= -3.3e-7) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))); elseif (KbT <= -1.65e-258) tmp = t_0; elseif (KbT <= 3.4e+137) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))); else tmp = Float64(t_0 + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((EAccept / KbT))); tmp = 0.0; if (KbT <= -5.5e+161) tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT))); elseif (KbT <= -3.3e-7) tmp = NaChar / (1.0 + exp((Vef / KbT))); elseif (KbT <= -1.65e-258) tmp = t_0; elseif (KbT <= 3.4e+137) tmp = NaChar / (1.0 + exp((Ev / KbT))); else tmp = t_0 + (NdChar / 2.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[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -5.5e+161], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -3.3e-7], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -1.65e-258], t$95$0, If[LessEqual[KbT, 3.4e+137], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{if}\;KbT \leq -5.5 \cdot 10^{+161}:\\
\;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\mathbf{elif}\;KbT \leq -3.3 \cdot 10^{-7}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{elif}\;KbT \leq -1.65 \cdot 10^{-258}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;KbT \leq 3.4 \cdot 10^{+137}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t\_0 + \frac{NdChar}{2}\\
\end{array}
\end{array}
if KbT < -5.5000000000000005e161Initial program 99.9%
Simplified99.9%
Taylor expanded in KbT around inf 81.0%
Taylor expanded in mu around inf 81.0%
associate-*r/81.0%
mul-1-neg81.0%
Simplified81.0%
Taylor expanded in mu around 0 77.3%
mul-1-neg77.3%
unsub-neg77.3%
Simplified77.3%
if -5.5000000000000005e161 < KbT < -3.3000000000000002e-7Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 46.0%
mul-1-neg46.0%
associate-+r+46.0%
+-commutative46.0%
associate-+r+46.0%
unsub-neg46.0%
associate-+r+46.0%
+-commutative46.0%
associate-+r+46.0%
associate--r+46.0%
Simplified46.0%
Taylor expanded in Ec around inf 30.4%
mul-1-neg30.4%
associate-/l*30.2%
distribute-lft-neg-in30.2%
Simplified30.2%
Taylor expanded in KbT around 0 56.9%
Taylor expanded in Vef around inf 43.5%
if -3.3000000000000002e-7 < KbT < -1.65e-258Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 54.1%
mul-1-neg54.1%
associate-+r+54.1%
+-commutative54.1%
associate-+r+54.1%
unsub-neg54.1%
associate-+r+54.1%
+-commutative54.1%
associate-+r+54.1%
associate--r+54.1%
Simplified54.1%
Taylor expanded in Ec around inf 40.3%
mul-1-neg40.3%
associate-/l*38.8%
distribute-lft-neg-in38.8%
Simplified38.8%
Taylor expanded in KbT around 0 59.0%
Taylor expanded in EAccept around inf 32.7%
if -1.65e-258 < KbT < 3.39999999999999986e137Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 58.0%
mul-1-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
unsub-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
associate--r+58.0%
Simplified58.0%
Taylor expanded in Ec around inf 40.9%
mul-1-neg40.9%
associate-/l*37.1%
distribute-lft-neg-in37.1%
Simplified37.1%
Taylor expanded in KbT around 0 67.6%
Taylor expanded in Ev around inf 43.5%
if 3.39999999999999986e137 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 76.2%
Taylor expanded in EAccept around inf 64.9%
Final simplification47.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -6.2e+161)
(+ (/ NdChar 2.0) (/ NaChar (- 2.0 (/ mu KbT))))
(if (<= KbT -1.7e-7)
(/ NaChar (+ 1.0 (exp (/ Vef KbT))))
(if (<= KbT -2e-258)
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(if (<= KbT 4e+126)
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(+ (* NaChar 0.5) (/ NdChar 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 (KbT <= -6.2e+161) {
tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT)));
} else if (KbT <= -1.7e-7) {
tmp = NaChar / (1.0 + exp((Vef / KbT)));
} else if (KbT <= -2e-258) {
tmp = NaChar / (1.0 + exp((EAccept / KbT)));
} else if (KbT <= 4e+126) {
tmp = NaChar / (1.0 + exp((Ev / KbT)));
} else {
tmp = (NaChar * 0.5) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-6.2d+161)) then
tmp = (ndchar / 2.0d0) + (nachar / (2.0d0 - (mu / kbt)))
else if (kbt <= (-1.7d-7)) then
tmp = nachar / (1.0d0 + exp((vef / kbt)))
else if (kbt <= (-2d-258)) then
tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
else if (kbt <= 4d+126) then
tmp = nachar / (1.0d0 + exp((ev / kbt)))
else
tmp = (nachar * 0.5d0) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -6.2e+161) {
tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT)));
} else if (KbT <= -1.7e-7) {
tmp = NaChar / (1.0 + Math.exp((Vef / KbT)));
} else if (KbT <= -2e-258) {
tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
} else if (KbT <= 4e+126) {
tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
} else {
tmp = (NaChar * 0.5) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -6.2e+161: tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT))) elif KbT <= -1.7e-7: tmp = NaChar / (1.0 + math.exp((Vef / KbT))) elif KbT <= -2e-258: tmp = NaChar / (1.0 + math.exp((EAccept / KbT))) elif KbT <= 4e+126: tmp = NaChar / (1.0 + math.exp((Ev / KbT))) else: tmp = (NaChar * 0.5) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -6.2e+161) tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); elseif (KbT <= -1.7e-7) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))); elseif (KbT <= -2e-258) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))); elseif (KbT <= 4e+126) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))); else tmp = Float64(Float64(NaChar * 0.5) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -6.2e+161) tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT))); elseif (KbT <= -1.7e-7) tmp = NaChar / (1.0 + exp((Vef / KbT))); elseif (KbT <= -2e-258) tmp = NaChar / (1.0 + exp((EAccept / KbT))); elseif (KbT <= 4e+126) tmp = NaChar / (1.0 + exp((Ev / KbT))); else tmp = (NaChar * 0.5) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -6.2e+161], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -1.7e-7], N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2e-258], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4e+126], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -6.2 \cdot 10^{+161}:\\
\;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\mathbf{elif}\;KbT \leq -1.7 \cdot 10^{-7}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{elif}\;KbT \leq -2 \cdot 10^{-258}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{elif}\;KbT \leq 4 \cdot 10^{+126}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{2}\\
\end{array}
\end{array}
if KbT < -6.20000000000000013e161Initial program 99.9%
Simplified99.9%
Taylor expanded in KbT around inf 81.0%
Taylor expanded in mu around inf 81.0%
associate-*r/81.0%
mul-1-neg81.0%
Simplified81.0%
Taylor expanded in mu around 0 77.3%
mul-1-neg77.3%
unsub-neg77.3%
Simplified77.3%
if -6.20000000000000013e161 < KbT < -1.69999999999999987e-7Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 46.0%
mul-1-neg46.0%
associate-+r+46.0%
+-commutative46.0%
associate-+r+46.0%
unsub-neg46.0%
associate-+r+46.0%
+-commutative46.0%
associate-+r+46.0%
associate--r+46.0%
Simplified46.0%
Taylor expanded in Ec around inf 30.4%
mul-1-neg30.4%
associate-/l*30.2%
distribute-lft-neg-in30.2%
Simplified30.2%
Taylor expanded in KbT around 0 56.9%
Taylor expanded in Vef around inf 43.5%
if -1.69999999999999987e-7 < KbT < -1.99999999999999991e-258Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 54.1%
mul-1-neg54.1%
associate-+r+54.1%
+-commutative54.1%
associate-+r+54.1%
unsub-neg54.1%
associate-+r+54.1%
+-commutative54.1%
associate-+r+54.1%
associate--r+54.1%
Simplified54.1%
Taylor expanded in Ec around inf 40.3%
mul-1-neg40.3%
associate-/l*38.8%
distribute-lft-neg-in38.8%
Simplified38.8%
Taylor expanded in KbT around 0 59.0%
Taylor expanded in EAccept around inf 32.7%
if -1.99999999999999991e-258 < KbT < 3.9999999999999997e126Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 58.0%
mul-1-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
unsub-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
associate--r+58.0%
Simplified58.0%
Taylor expanded in Ec around inf 40.9%
mul-1-neg40.9%
associate-/l*37.1%
distribute-lft-neg-in37.1%
Simplified37.1%
Taylor expanded in KbT around 0 67.6%
Taylor expanded in Ev around inf 43.5%
if 3.9999999999999997e126 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 76.2%
Taylor expanded in KbT around inf 62.3%
*-commutative62.3%
Simplified62.3%
Final simplification47.2%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -5e+187)
(+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (/ NdChar 2.0))
(if (<= KbT 1.4e+88)
(/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
(+
(/ NaChar (+ 1.0 (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))))
(/ NdChar 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 (KbT <= -5e+187) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
} else if (KbT <= 1.4e+88) {
tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
} else {
tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-5d+187)) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / 2.0d0)
else if (kbt <= 1.4d+88) then
tmp = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
else
tmp = (nachar / (1.0d0 + exp(((vef + ((ev + eaccept) - mu)) / kbt)))) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -5e+187) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / 2.0);
} else if (KbT <= 1.4e+88) {
tmp = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
} else {
tmp = (NaChar / (1.0 + Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -5e+187: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / 2.0) elif KbT <= 1.4e+88: tmp = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT))) else: tmp = (NaChar / (1.0 + math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -5e+187) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / 2.0)); elseif (KbT <= 1.4e+88) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT)))) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -5e+187) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0); elseif (KbT <= 1.4e+88) tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT))); else tmp = (NaChar / (1.0 + exp(((Vef + ((Ev + EAccept) - mu)) / KbT)))) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -5e+187], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.4e+88], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -5 \cdot 10^{+187}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{elif}\;KbT \leq 1.4 \cdot 10^{+88}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if KbT < -5.0000000000000001e187Initial program 99.9%
Simplified99.9%
Taylor expanded in KbT around inf 88.1%
Taylor expanded in mu around inf 88.1%
associate-*r/88.1%
mul-1-neg88.1%
Simplified88.1%
if -5.0000000000000001e187 < KbT < 1.39999999999999994e88Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 52.9%
mul-1-neg52.9%
associate-+r+52.9%
+-commutative52.9%
associate-+r+52.9%
unsub-neg52.9%
associate-+r+52.9%
+-commutative52.9%
associate-+r+52.9%
associate--r+52.9%
Simplified52.9%
Taylor expanded in Ec around inf 37.7%
mul-1-neg37.7%
associate-/l*35.1%
distribute-lft-neg-in35.1%
Simplified35.1%
Taylor expanded in KbT around 0 62.3%
if 1.39999999999999994e88 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 78.7%
Final simplification67.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(if (<= KbT -6.2e+18)
(+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 0.5))
(if (<= KbT -4e-261)
t_0
(if (<= KbT 1.1e+126)
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(+ t_0 (/ NdChar 2.0)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((EAccept / KbT)));
double tmp;
if (KbT <= -6.2e+18) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
} else if (KbT <= -4e-261) {
tmp = t_0;
} else if (KbT <= 1.1e+126) {
tmp = NaChar / (1.0 + exp((Ev / KbT)));
} else {
tmp = t_0 + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((eaccept / kbt)))
if (kbt <= (-6.2d+18)) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar * 0.5d0)
else if (kbt <= (-4d-261)) then
tmp = t_0
else if (kbt <= 1.1d+126) then
tmp = nachar / (1.0d0 + exp((ev / kbt)))
else
tmp = t_0 + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
double tmp;
if (KbT <= -6.2e+18) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar * 0.5);
} else if (KbT <= -4e-261) {
tmp = t_0;
} else if (KbT <= 1.1e+126) {
tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
} else {
tmp = t_0 + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((EAccept / KbT))) tmp = 0 if KbT <= -6.2e+18: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar * 0.5) elif KbT <= -4e-261: tmp = t_0 elif KbT <= 1.1e+126: tmp = NaChar / (1.0 + math.exp((Ev / KbT))) else: tmp = t_0 + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) tmp = 0.0 if (KbT <= -6.2e+18) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar * 0.5)); elseif (KbT <= -4e-261) tmp = t_0; elseif (KbT <= 1.1e+126) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))); else tmp = Float64(t_0 + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((EAccept / KbT))); tmp = 0.0; if (KbT <= -6.2e+18) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5); elseif (KbT <= -4e-261) tmp = t_0; elseif (KbT <= 1.1e+126) tmp = NaChar / (1.0 + exp((Ev / KbT))); else tmp = t_0 + (NdChar / 2.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[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -6.2e+18], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -4e-261], t$95$0, If[LessEqual[KbT, 1.1e+126], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{if}\;KbT \leq -6.2 \cdot 10^{+18}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq -4 \cdot 10^{-261}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;KbT \leq 1.1 \cdot 10^{+126}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t\_0 + \frac{NdChar}{2}\\
\end{array}
\end{array}
if KbT < -6.2e18Initial program 99.9%
Simplified99.9%
Taylor expanded in EDonor around inf 76.1%
Taylor expanded in KbT around inf 60.8%
*-commutative52.0%
Simplified60.8%
if -6.2e18 < KbT < -3.99999999999999994e-261Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 53.2%
mul-1-neg53.2%
associate-+r+53.2%
+-commutative53.2%
associate-+r+53.2%
unsub-neg53.2%
associate-+r+53.2%
+-commutative53.2%
associate-+r+53.2%
associate--r+53.2%
Simplified53.2%
Taylor expanded in Ec around inf 40.6%
mul-1-neg40.6%
associate-/l*39.1%
distribute-lft-neg-in39.1%
Simplified39.1%
Taylor expanded in KbT around 0 57.7%
Taylor expanded in EAccept around inf 30.5%
if -3.99999999999999994e-261 < KbT < 1.09999999999999999e126Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 58.0%
mul-1-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
unsub-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
associate--r+58.0%
Simplified58.0%
Taylor expanded in Ec around inf 40.9%
mul-1-neg40.9%
associate-/l*37.1%
distribute-lft-neg-in37.1%
Simplified37.1%
Taylor expanded in KbT around 0 67.6%
Taylor expanded in Ev around inf 43.5%
if 1.09999999999999999e126 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 76.2%
Taylor expanded in EAccept around inf 64.9%
Final simplification46.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -3.5e+184)
(+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) (/ NdChar 2.0))
(if (<= KbT 2.65e+152)
(/ NaChar (+ 1.0 (exp (/ (- (+ EAccept (+ Vef Ev)) mu) KbT))))
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 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 (KbT <= -3.5e+184) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0);
} else if (KbT <= 2.65e+152) {
tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-3.5d+184)) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / 2.0d0)
else if (kbt <= 2.65d+152) then
tmp = nachar / (1.0d0 + exp((((eaccept + (vef + ev)) - mu) / kbt)))
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -3.5e+184) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / 2.0);
} else if (KbT <= 2.65e+152) {
tmp = NaChar / (1.0 + Math.exp((((EAccept + (Vef + Ev)) - mu) / KbT)));
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -3.5e+184: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / 2.0) elif KbT <= 2.65e+152: tmp = NaChar / (1.0 + math.exp((((EAccept + (Vef + Ev)) - mu) / KbT))) else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -3.5e+184) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / 2.0)); elseif (KbT <= 2.65e+152) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(EAccept + Float64(Vef + Ev)) - mu) / KbT)))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -3.5e+184) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / 2.0); elseif (KbT <= 2.65e+152) tmp = NaChar / (1.0 + exp((((EAccept + (Vef + Ev)) - mu) / KbT))); else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -3.5e+184], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 2.65e+152], N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(EAccept + N[(Vef + Ev), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -3.5 \cdot 10^{+184}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{elif}\;KbT \leq 2.65 \cdot 10^{+152}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(EAccept + \left(Vef + Ev\right)\right) - mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if KbT < -3.49999999999999978e184Initial program 99.9%
Simplified99.9%
Taylor expanded in KbT around inf 88.1%
Taylor expanded in mu around inf 88.1%
associate-*r/88.1%
mul-1-neg88.1%
Simplified88.1%
if -3.49999999999999978e184 < KbT < 2.64999999999999988e152Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 54.0%
mul-1-neg54.0%
associate-+r+54.0%
+-commutative54.0%
associate-+r+54.0%
unsub-neg54.0%
associate-+r+54.0%
+-commutative54.0%
associate-+r+54.0%
associate--r+54.0%
Simplified54.0%
Taylor expanded in Ec around inf 38.1%
mul-1-neg38.1%
associate-/l*35.6%
distribute-lft-neg-in35.6%
Simplified35.6%
Taylor expanded in KbT around 0 63.1%
if 2.64999999999999988e152 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 78.5%
Taylor expanded in EAccept around inf 66.9%
Final simplification66.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -4e+182)
(+ (/ NdChar 2.0) (/ NaChar (- 2.0 (/ mu KbT))))
(if (<= KbT -5e-260)
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(if (<= KbT 9.5e+137)
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(+ (* NaChar 0.5) (/ NdChar 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 (KbT <= -4e+182) {
tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT)));
} else if (KbT <= -5e-260) {
tmp = NaChar / (1.0 + exp((EAccept / KbT)));
} else if (KbT <= 9.5e+137) {
tmp = NaChar / (1.0 + exp((Ev / KbT)));
} else {
tmp = (NaChar * 0.5) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-4d+182)) then
tmp = (ndchar / 2.0d0) + (nachar / (2.0d0 - (mu / kbt)))
else if (kbt <= (-5d-260)) then
tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
else if (kbt <= 9.5d+137) then
tmp = nachar / (1.0d0 + exp((ev / kbt)))
else
tmp = (nachar * 0.5d0) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -4e+182) {
tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT)));
} else if (KbT <= -5e-260) {
tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
} else if (KbT <= 9.5e+137) {
tmp = NaChar / (1.0 + Math.exp((Ev / KbT)));
} else {
tmp = (NaChar * 0.5) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -4e+182: tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT))) elif KbT <= -5e-260: tmp = NaChar / (1.0 + math.exp((EAccept / KbT))) elif KbT <= 9.5e+137: tmp = NaChar / (1.0 + math.exp((Ev / KbT))) else: tmp = (NaChar * 0.5) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -4e+182) tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); elseif (KbT <= -5e-260) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))); elseif (KbT <= 9.5e+137) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))); else tmp = Float64(Float64(NaChar * 0.5) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -4e+182) tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT))); elseif (KbT <= -5e-260) tmp = NaChar / (1.0 + exp((EAccept / KbT))); elseif (KbT <= 9.5e+137) tmp = NaChar / (1.0 + exp((Ev / KbT))); else tmp = (NaChar * 0.5) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -4e+182], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -5e-260], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 9.5e+137], N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -4 \cdot 10^{+182}:\\
\;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\mathbf{elif}\;KbT \leq -5 \cdot 10^{-260}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{elif}\;KbT \leq 9.5 \cdot 10^{+137}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{2}\\
\end{array}
\end{array}
if KbT < -4.0000000000000003e182Initial program 99.9%
Simplified99.9%
Taylor expanded in KbT around inf 88.1%
Taylor expanded in mu around inf 88.1%
associate-*r/88.1%
mul-1-neg88.1%
Simplified88.1%
Taylor expanded in mu around 0 83.8%
mul-1-neg83.8%
unsub-neg83.8%
Simplified83.8%
if -4.0000000000000003e182 < KbT < -5.0000000000000003e-260Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 50.4%
mul-1-neg50.4%
associate-+r+50.4%
+-commutative50.4%
associate-+r+50.4%
unsub-neg50.4%
associate-+r+50.4%
+-commutative50.4%
associate-+r+50.4%
associate--r+50.4%
Simplified50.4%
Taylor expanded in Ec around inf 35.5%
mul-1-neg35.5%
associate-/l*34.5%
distribute-lft-neg-in34.5%
Simplified34.5%
Taylor expanded in KbT around 0 57.9%
Taylor expanded in EAccept around inf 30.0%
if -5.0000000000000003e-260 < KbT < 9.50000000000000031e137Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 58.0%
mul-1-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
unsub-neg58.0%
associate-+r+58.0%
+-commutative58.0%
associate-+r+58.0%
associate--r+58.0%
Simplified58.0%
Taylor expanded in Ec around inf 40.9%
mul-1-neg40.9%
associate-/l*37.1%
distribute-lft-neg-in37.1%
Simplified37.1%
Taylor expanded in KbT around 0 67.6%
Taylor expanded in Ev around inf 43.5%
if 9.50000000000000031e137 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 76.2%
Taylor expanded in KbT around inf 62.3%
*-commutative62.3%
Simplified62.3%
Final simplification44.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -2.2e+189)
(+ (/ NdChar 2.0) (/ NaChar (- 2.0 (/ mu KbT))))
(if (<= KbT 3.7e+70)
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(+ (* NaChar 0.5) (/ NdChar 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 (KbT <= -2.2e+189) {
tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT)));
} else if (KbT <= 3.7e+70) {
tmp = NaChar / (1.0 + exp((EAccept / KbT)));
} else {
tmp = (NaChar * 0.5) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-2.2d+189)) then
tmp = (ndchar / 2.0d0) + (nachar / (2.0d0 - (mu / kbt)))
else if (kbt <= 3.7d+70) then
tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
else
tmp = (nachar * 0.5d0) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -2.2e+189) {
tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT)));
} else if (KbT <= 3.7e+70) {
tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
} else {
tmp = (NaChar * 0.5) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -2.2e+189: tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT))) elif KbT <= 3.7e+70: tmp = NaChar / (1.0 + math.exp((EAccept / KbT))) else: tmp = (NaChar * 0.5) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -2.2e+189) tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); elseif (KbT <= 3.7e+70) tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))); else tmp = Float64(Float64(NaChar * 0.5) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -2.2e+189) tmp = (NdChar / 2.0) + (NaChar / (2.0 - (mu / KbT))); elseif (KbT <= 3.7e+70) tmp = NaChar / (1.0 + exp((EAccept / KbT))); else tmp = (NaChar * 0.5) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.2e+189], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.7e+70], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -2.2 \cdot 10^{+189}:\\
\;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\mathbf{elif}\;KbT \leq 3.7 \cdot 10^{+70}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{2}\\
\end{array}
\end{array}
if KbT < -2.20000000000000005e189Initial program 99.9%
Simplified99.9%
Taylor expanded in KbT around inf 88.1%
Taylor expanded in mu around inf 88.1%
associate-*r/88.1%
mul-1-neg88.1%
Simplified88.1%
Taylor expanded in mu around 0 83.8%
mul-1-neg83.8%
unsub-neg83.8%
Simplified83.8%
if -2.20000000000000005e189 < KbT < 3.69999999999999989e70Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 52.7%
mul-1-neg52.7%
associate-+r+52.7%
+-commutative52.7%
associate-+r+52.7%
unsub-neg52.7%
associate-+r+52.7%
+-commutative52.7%
associate-+r+52.7%
associate--r+52.7%
Simplified52.7%
Taylor expanded in Ec around inf 37.9%
mul-1-neg37.9%
associate-/l*35.2%
distribute-lft-neg-in35.2%
Simplified35.2%
Taylor expanded in KbT around 0 61.9%
Taylor expanded in EAccept around inf 33.3%
if 3.69999999999999989e70 < KbT Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 76.1%
Taylor expanded in KbT around inf 55.3%
*-commutative55.3%
Simplified55.3%
Final simplification42.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (* NaChar 0.5) (/ NdChar 2.0)))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar * 0.5) + (NdChar / 2.0);
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (nachar * 0.5d0) + (ndchar / 2.0d0)
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar * 0.5) + (NdChar / 2.0);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar * 0.5) + (NdChar / 2.0)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar * 0.5) + Float64(NdChar / 2.0)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar * 0.5) + (NdChar / 2.0); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
NaChar \cdot 0.5 + \frac{NdChar}{2}
\end{array}
Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 49.8%
Taylor expanded in KbT around inf 29.1%
*-commutative29.1%
Simplified29.1%
Final simplification29.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (* NaChar 0.5))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NaChar * 0.5;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = nachar * 0.5d0
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NaChar * 0.5;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return NaChar * 0.5
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(NaChar * 0.5) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = NaChar * 0.5; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NaChar * 0.5), $MachinePrecision]
\begin{array}{l}
\\
NaChar \cdot 0.5
\end{array}
Initial program 100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.2%
mul-1-neg60.2%
associate-+r+60.2%
+-commutative60.2%
associate-+r+60.2%
unsub-neg60.2%
associate-+r+60.2%
+-commutative60.2%
associate-+r+60.2%
associate--r+60.2%
Simplified60.2%
Taylor expanded in Ec around inf 33.2%
mul-1-neg33.2%
associate-/l*32.6%
distribute-lft-neg-in32.6%
Simplified32.6%
Taylor expanded in KbT around inf 11.7%
+-commutative11.7%
mul-1-neg11.7%
unsub-neg11.7%
associate-*r/12.1%
Simplified12.1%
Taylor expanded in NaChar around inf 18.8%
Final simplification18.8%
herbie shell --seed 2024044
(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))))))