
(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 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}}
\end{array}
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}
\end{array}
Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (+ 1.0 (exp (/ Vef KbT))))
(t_1 (+ (/ NaChar t_0) (/ NdChar t_0)))
(t_2 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(t_3 (/ NdChar (+ 1.0 (exp (/ (- mu Ec) KbT)))))
(t_4 (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_3)))
(if (<= EAccept -5.8e-241)
t_4
(if (<= EAccept 2.8e-288)
t_1
(if (<= EAccept 2.15e-252)
t_4
(if (<= EAccept 1.5e-184)
t_1
(if (<= EAccept 2.25e+24)
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ mu (- Vef Ec)) KbT)))))
(if (or (<= EAccept 1.5e+161) (not (<= EAccept 2.5e+263)))
(+ t_2 (/ NdChar (+ 1.0 (exp (/ (+ mu EDonor) KbT)))))
(+ t_2 t_3)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = 1.0 + exp((Vef / KbT));
double t_1 = (NaChar / t_0) + (NdChar / t_0);
double t_2 = NaChar / (1.0 + exp((EAccept / KbT)));
double t_3 = NdChar / (1.0 + exp(((mu - Ec) / KbT)));
double t_4 = (NaChar / (1.0 + exp((Ev / KbT)))) + t_3;
double tmp;
if (EAccept <= -5.8e-241) {
tmp = t_4;
} else if (EAccept <= 2.8e-288) {
tmp = t_1;
} else if (EAccept <= 2.15e-252) {
tmp = t_4;
} else if (EAccept <= 1.5e-184) {
tmp = t_1;
} else if (EAccept <= 2.25e+24) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((mu + (Vef - Ec)) / KbT))));
} else if ((EAccept <= 1.5e+161) || !(EAccept <= 2.5e+263)) {
tmp = t_2 + (NdChar / (1.0 + exp(((mu + EDonor) / KbT))));
} else {
tmp = t_2 + t_3;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: tmp
t_0 = 1.0d0 + exp((vef / kbt))
t_1 = (nachar / t_0) + (ndchar / t_0)
t_2 = nachar / (1.0d0 + exp((eaccept / kbt)))
t_3 = ndchar / (1.0d0 + exp(((mu - ec) / kbt)))
t_4 = (nachar / (1.0d0 + exp((ev / kbt)))) + t_3
if (eaccept <= (-5.8d-241)) then
tmp = t_4
else if (eaccept <= 2.8d-288) then
tmp = t_1
else if (eaccept <= 2.15d-252) then
tmp = t_4
else if (eaccept <= 1.5d-184) then
tmp = t_1
else if (eaccept <= 2.25d+24) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp(((mu + (vef - ec)) / kbt))))
else if ((eaccept <= 1.5d+161) .or. (.not. (eaccept <= 2.5d+263))) then
tmp = t_2 + (ndchar / (1.0d0 + exp(((mu + edonor) / kbt))))
else
tmp = t_2 + t_3
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = 1.0 + Math.exp((Vef / KbT));
double t_1 = (NaChar / t_0) + (NdChar / t_0);
double t_2 = NaChar / (1.0 + Math.exp((EAccept / KbT)));
double t_3 = NdChar / (1.0 + Math.exp(((mu - Ec) / KbT)));
double t_4 = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_3;
double tmp;
if (EAccept <= -5.8e-241) {
tmp = t_4;
} else if (EAccept <= 2.8e-288) {
tmp = t_1;
} else if (EAccept <= 2.15e-252) {
tmp = t_4;
} else if (EAccept <= 1.5e-184) {
tmp = t_1;
} else if (EAccept <= 2.25e+24) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + (Vef - Ec)) / KbT))));
} else if ((EAccept <= 1.5e+161) || !(EAccept <= 2.5e+263)) {
tmp = t_2 + (NdChar / (1.0 + Math.exp(((mu + EDonor) / KbT))));
} else {
tmp = t_2 + t_3;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = 1.0 + math.exp((Vef / KbT)) t_1 = (NaChar / t_0) + (NdChar / t_0) t_2 = NaChar / (1.0 + math.exp((EAccept / KbT))) t_3 = NdChar / (1.0 + math.exp(((mu - Ec) / KbT))) t_4 = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_3 tmp = 0 if EAccept <= -5.8e-241: tmp = t_4 elif EAccept <= 2.8e-288: tmp = t_1 elif EAccept <= 2.15e-252: tmp = t_4 elif EAccept <= 1.5e-184: tmp = t_1 elif EAccept <= 2.25e+24: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp(((mu + (Vef - Ec)) / KbT)))) elif (EAccept <= 1.5e+161) or not (EAccept <= 2.5e+263): tmp = t_2 + (NdChar / (1.0 + math.exp(((mu + EDonor) / KbT)))) else: tmp = t_2 + t_3 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(1.0 + exp(Float64(Vef / KbT))) t_1 = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0)) t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) t_3 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Ec) / KbT)))) t_4 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_3) tmp = 0.0 if (EAccept <= -5.8e-241) tmp = t_4; elseif (EAccept <= 2.8e-288) tmp = t_1; elseif (EAccept <= 2.15e-252) tmp = t_4; elseif (EAccept <= 1.5e-184) tmp = t_1; elseif (EAccept <= 2.25e+24) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Vef - Ec)) / KbT))))); elseif ((EAccept <= 1.5e+161) || !(EAccept <= 2.5e+263)) tmp = Float64(t_2 + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + EDonor) / KbT))))); else tmp = Float64(t_2 + t_3); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = 1.0 + exp((Vef / KbT)); t_1 = (NaChar / t_0) + (NdChar / t_0); t_2 = NaChar / (1.0 + exp((EAccept / KbT))); t_3 = NdChar / (1.0 + exp(((mu - Ec) / KbT))); t_4 = (NaChar / (1.0 + exp((Ev / KbT)))) + t_3; tmp = 0.0; if (EAccept <= -5.8e-241) tmp = t_4; elseif (EAccept <= 2.8e-288) tmp = t_1; elseif (EAccept <= 2.15e-252) tmp = t_4; elseif (EAccept <= 1.5e-184) tmp = t_1; elseif (EAccept <= 2.25e+24) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((mu + (Vef - Ec)) / KbT)))); elseif ((EAccept <= 1.5e+161) || ~((EAccept <= 2.5e+263))) tmp = t_2 + (NdChar / (1.0 + exp(((mu + EDonor) / KbT)))); else tmp = t_2 + t_3; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision]}, If[LessEqual[EAccept, -5.8e-241], t$95$4, If[LessEqual[EAccept, 2.8e-288], t$95$1, If[LessEqual[EAccept, 2.15e-252], t$95$4, If[LessEqual[EAccept, 1.5e-184], t$95$1, If[LessEqual[EAccept, 2.25e+24], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[EAccept, 1.5e+161], N[Not[LessEqual[EAccept, 2.5e+263]], $MachinePrecision]], N[(t$95$2 + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + EDonor), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$2 + t$95$3), $MachinePrecision]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + e^{\frac{Vef}{KbT}}\\
t_1 := \frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\
t_2 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
t_3 := \frac{NdChar}{1 + e^{\frac{mu - Ec}{KbT}}}\\
t_4 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t_3\\
\mathbf{if}\;EAccept \leq -5.8 \cdot 10^{-241}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;EAccept \leq 2.8 \cdot 10^{-288}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 2.15 \cdot 10^{-252}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;EAccept \leq 1.5 \cdot 10^{-184}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 2.25 \cdot 10^{+24}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(Vef - Ec\right)}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 1.5 \cdot 10^{+161} \lor \neg \left(EAccept \leq 2.5 \cdot 10^{+263}\right):\\
\;\;\;\;t_2 + \frac{NdChar}{1 + e^{\frac{mu + EDonor}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_2 + t_3\\
\end{array}
\end{array}
if EAccept < -5.7999999999999998e-241 or 2.7999999999999999e-288 < EAccept < 2.14999999999999996e-252Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 73.1%
Taylor expanded in Ec around inf 63.7%
if -5.7999999999999998e-241 < EAccept < 2.7999999999999999e-288 or 2.14999999999999996e-252 < EAccept < 1.49999999999999996e-184Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 78.0%
Taylor expanded in Vef around inf 59.3%
if 1.49999999999999996e-184 < EAccept < 2.2500000000000001e24Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 78.1%
neg-mul-178.1%
Simplified78.1%
Taylor expanded in EDonor around 0 75.7%
+-commutative75.7%
+-commutative75.7%
associate--l+75.7%
Simplified75.7%
if 2.2500000000000001e24 < EAccept < 1.50000000000000006e161 or 2.50000000000000011e263 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 88.7%
Taylor expanded in EDonor around inf 86.1%
neg-mul-186.1%
Simplified86.1%
if 1.50000000000000006e161 < EAccept < 2.50000000000000011e263Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 81.9%
Taylor expanded in Ec around inf 81.9%
Final simplification70.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (+ 1.0 (exp (/ Vef KbT))))
(t_1 (+ (/ NaChar t_0) (/ NdChar t_0)))
(t_2
(+
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(/ NdChar (+ 1.0 (exp (/ (- mu Ec) KbT)))))))
(if (<= EAccept -5.4e-241)
t_2
(if (<= EAccept 3.8e-289)
t_1
(if (<= EAccept 1.4e-253)
t_2
(if (<= EAccept 4.2e-186)
t_1
(if (<= EAccept 2.05e+17)
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ mu (- Vef Ec)) KbT)))))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = 1.0 + exp((Vef / KbT));
double t_1 = (NaChar / t_0) + (NdChar / t_0);
double t_2 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp(((mu - Ec) / KbT))));
double tmp;
if (EAccept <= -5.4e-241) {
tmp = t_2;
} else if (EAccept <= 3.8e-289) {
tmp = t_1;
} else if (EAccept <= 1.4e-253) {
tmp = t_2;
} else if (EAccept <= 4.2e-186) {
tmp = t_1;
} else if (EAccept <= 2.05e+17) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((mu + (Vef - Ec)) / KbT))));
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = 1.0d0 + exp((vef / kbt))
t_1 = (nachar / t_0) + (ndchar / t_0)
t_2 = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp(((mu - ec) / kbt))))
if (eaccept <= (-5.4d-241)) then
tmp = t_2
else if (eaccept <= 3.8d-289) then
tmp = t_1
else if (eaccept <= 1.4d-253) then
tmp = t_2
else if (eaccept <= 4.2d-186) then
tmp = t_1
else if (eaccept <= 2.05d+17) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp(((mu + (vef - ec)) / kbt))))
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = 1.0 + Math.exp((Vef / KbT));
double t_1 = (NaChar / t_0) + (NdChar / t_0);
double t_2 = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp(((mu - Ec) / KbT))));
double tmp;
if (EAccept <= -5.4e-241) {
tmp = t_2;
} else if (EAccept <= 3.8e-289) {
tmp = t_1;
} else if (EAccept <= 1.4e-253) {
tmp = t_2;
} else if (EAccept <= 4.2e-186) {
tmp = t_1;
} else if (EAccept <= 2.05e+17) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + (Vef - Ec)) / KbT))));
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = 1.0 + math.exp((Vef / KbT)) t_1 = (NaChar / t_0) + (NdChar / t_0) t_2 = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp(((mu - Ec) / KbT)))) tmp = 0 if EAccept <= -5.4e-241: tmp = t_2 elif EAccept <= 3.8e-289: tmp = t_1 elif EAccept <= 1.4e-253: tmp = t_2 elif EAccept <= 4.2e-186: tmp = t_1 elif EAccept <= 2.05e+17: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp(((mu + (Vef - Ec)) / KbT)))) else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(1.0 + exp(Float64(Vef / KbT))) t_1 = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0)) t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Ec) / KbT))))) tmp = 0.0 if (EAccept <= -5.4e-241) tmp = t_2; elseif (EAccept <= 3.8e-289) tmp = t_1; elseif (EAccept <= 1.4e-253) tmp = t_2; elseif (EAccept <= 4.2e-186) tmp = t_1; elseif (EAccept <= 2.05e+17) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Vef - Ec)) / KbT))))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = 1.0 + exp((Vef / KbT)); t_1 = (NaChar / t_0) + (NdChar / t_0); t_2 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp(((mu - Ec) / KbT)))); tmp = 0.0; if (EAccept <= -5.4e-241) tmp = t_2; elseif (EAccept <= 3.8e-289) tmp = t_1; elseif (EAccept <= 1.4e-253) tmp = t_2; elseif (EAccept <= 4.2e-186) tmp = t_1; elseif (EAccept <= 2.05e+17) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((mu + (Vef - Ec)) / KbT)))); else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -5.4e-241], t$95$2, If[LessEqual[EAccept, 3.8e-289], t$95$1, If[LessEqual[EAccept, 1.4e-253], t$95$2, If[LessEqual[EAccept, 4.2e-186], t$95$1, If[LessEqual[EAccept, 2.05e+17], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + e^{\frac{Vef}{KbT}}\\
t_1 := \frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\
t_2 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu - Ec}{KbT}}}\\
\mathbf{if}\;EAccept \leq -5.4 \cdot 10^{-241}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;EAccept \leq 3.8 \cdot 10^{-289}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 1.4 \cdot 10^{-253}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;EAccept \leq 4.2 \cdot 10^{-186}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;EAccept \leq 2.05 \cdot 10^{+17}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(Vef - Ec\right)}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -5.3999999999999998e-241 or 3.80000000000000009e-289 < EAccept < 1.40000000000000003e-253Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 73.1%
Taylor expanded in Ec around inf 63.7%
if -5.3999999999999998e-241 < EAccept < 3.80000000000000009e-289 or 1.40000000000000003e-253 < EAccept < 4.2000000000000004e-186Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 78.0%
Taylor expanded in Vef around inf 59.3%
if 4.2000000000000004e-186 < EAccept < 2.05e17Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 81.0%
neg-mul-181.0%
Simplified81.0%
Taylor expanded in EDonor around 0 78.3%
+-commutative78.3%
+-commutative78.3%
associate--l+78.3%
Simplified78.3%
if 2.05e17 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 86.7%
Final simplification71.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= EAccept -1.3e-62)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= EAccept 1.52e-176)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
(if (<= EAccept 9.4e+17)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= -1.3e-62) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (EAccept <= 1.52e-176) {
tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
} else if (EAccept <= 9.4e+17) {
tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (eaccept <= (-1.3d-62)) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (eaccept <= 1.52d-176) then
tmp = t_0 + (nachar / (1.0d0 + exp((vef / kbt))))
else if (eaccept <= 9.4d+17) then
tmp = t_0 + (nachar / (1.0d0 + exp((-mu / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= -1.3e-62) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (EAccept <= 1.52e-176) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
} else if (EAccept <= 9.4e+17) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if EAccept <= -1.3e-62: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif EAccept <= 1.52e-176: tmp = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT)))) elif EAccept <= 9.4e+17: tmp = t_0 + (NaChar / (1.0 + math.exp((-mu / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (EAccept <= -1.3e-62) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (EAccept <= 1.52e-176) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))); elseif (EAccept <= 9.4e+17) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (EAccept <= -1.3e-62) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (EAccept <= 1.52e-176) tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT)))); elseif (EAccept <= 9.4e+17) tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -1.3e-62], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.52e-176], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 9.4e+17], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;EAccept \leq -1.3 \cdot 10^{-62}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 1.52 \cdot 10^{-176}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 9.4 \cdot 10^{+17}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -1.3e-62Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 70.6%
if -1.3e-62 < EAccept < 1.52000000000000001e-176Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 75.6%
if 1.52000000000000001e-176 < EAccept < 9.4e17Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 81.0%
neg-mul-181.0%
Simplified81.0%
if 9.4e17 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 86.7%
Final simplification77.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= EAccept -5.2e-63)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= EAccept 1.3e-185)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
(if (<= EAccept 2.05e+17)
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ mu (- Vef Ec)) KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= -5.2e-63) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (EAccept <= 1.3e-185) {
tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
} else if (EAccept <= 2.05e+17) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((mu + (Vef - Ec)) / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (eaccept <= (-5.2d-63)) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (eaccept <= 1.3d-185) then
tmp = t_0 + (nachar / (1.0d0 + exp((vef / kbt))))
else if (eaccept <= 2.05d+17) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp(((mu + (vef - ec)) / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= -5.2e-63) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (EAccept <= 1.3e-185) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
} else if (EAccept <= 2.05e+17) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + (Vef - Ec)) / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if EAccept <= -5.2e-63: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif EAccept <= 1.3e-185: tmp = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT)))) elif EAccept <= 2.05e+17: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp(((mu + (Vef - Ec)) / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (EAccept <= -5.2e-63) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (EAccept <= 1.3e-185) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))); elseif (EAccept <= 2.05e+17) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Vef - Ec)) / KbT))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (EAccept <= -5.2e-63) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (EAccept <= 1.3e-185) tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT)))); elseif (EAccept <= 2.05e+17) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((mu + (Vef - Ec)) / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, -5.2e-63], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 1.3e-185], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 2.05e+17], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;EAccept \leq -5.2 \cdot 10^{-63}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 1.3 \cdot 10^{-185}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 2.05 \cdot 10^{+17}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(Vef - Ec\right)}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < -5.2000000000000003e-63Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 70.6%
if -5.2000000000000003e-63 < EAccept < 1.29999999999999992e-185Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 75.6%
if 1.29999999999999992e-185 < EAccept < 2.05e17Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 81.0%
neg-mul-181.0%
Simplified81.0%
Taylor expanded in EDonor around 0 78.3%
+-commutative78.3%
+-commutative78.3%
associate--l+78.3%
Simplified78.3%
if 2.05e17 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 86.7%
Final simplification77.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= EAccept 2.4e-191)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= EAccept 9.2e+17)
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ (+ mu (- Vef Ec)) KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= 2.4e-191) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (EAccept <= 9.2e+17) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((mu + (Vef - Ec)) / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (eaccept <= 2.4d-191) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (eaccept <= 9.2d+17) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp(((mu + (vef - ec)) / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (EAccept <= 2.4e-191) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (EAccept <= 9.2e+17) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + (Vef - Ec)) / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if EAccept <= 2.4e-191: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif EAccept <= 9.2e+17: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp(((mu + (Vef - Ec)) / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (EAccept <= 2.4e-191) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (EAccept <= 9.2e+17) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Vef - Ec)) / KbT))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (EAccept <= 2.4e-191) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (EAccept <= 9.2e+17) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp(((mu + (Vef - Ec)) / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, 2.4e-191], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 9.2e+17], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;EAccept \leq 2.4 \cdot 10^{-191}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 9.2 \cdot 10^{+17}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu + \left(Vef - Ec\right)}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < 2.3999999999999999e-191Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 74.1%
if 2.3999999999999999e-191 < EAccept < 9.2e17Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 78.2%
neg-mul-178.2%
Simplified78.2%
Taylor expanded in EDonor around 0 75.8%
+-commutative75.8%
+-commutative75.8%
associate--l+75.8%
Simplified75.8%
if 9.2e17 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 86.7%
Final simplification77.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (+ 1.0 (exp (/ Vef KbT)))))
(if (or (<= Vef -1.45e+211) (not (<= Vef 4.2e+172)))
(+ (/ NaChar t_0) (/ NdChar t_0))
(+
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(/ NdChar (+ 1.0 (exp (/ (- mu Ec) KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = 1.0 + exp((Vef / KbT));
double tmp;
if ((Vef <= -1.45e+211) || !(Vef <= 4.2e+172)) {
tmp = (NaChar / t_0) + (NdChar / t_0);
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(((mu - Ec) / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = 1.0d0 + exp((vef / kbt))
if ((vef <= (-1.45d+211)) .or. (.not. (vef <= 4.2d+172))) then
tmp = (nachar / t_0) + (ndchar / t_0)
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp(((mu - ec) / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = 1.0 + Math.exp((Vef / KbT));
double tmp;
if ((Vef <= -1.45e+211) || !(Vef <= 4.2e+172)) {
tmp = (NaChar / t_0) + (NdChar / t_0);
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp(((mu - Ec) / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = 1.0 + math.exp((Vef / KbT)) tmp = 0 if (Vef <= -1.45e+211) or not (Vef <= 4.2e+172): tmp = (NaChar / t_0) + (NdChar / t_0) else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp(((mu - Ec) / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(1.0 + exp(Float64(Vef / KbT))) tmp = 0.0 if ((Vef <= -1.45e+211) || !(Vef <= 4.2e+172)) tmp = Float64(Float64(NaChar / t_0) + Float64(NdChar / t_0)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Ec) / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = 1.0 + exp((Vef / KbT)); tmp = 0.0; if ((Vef <= -1.45e+211) || ~((Vef <= 4.2e+172))) tmp = (NaChar / t_0) + (NdChar / t_0); else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp(((mu - Ec) / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[Vef, -1.45e+211], N[Not[LessEqual[Vef, 4.2e+172]], $MachinePrecision]], N[(N[(NaChar / t$95$0), $MachinePrecision] + N[(NdChar / t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + e^{\frac{Vef}{KbT}}\\
\mathbf{if}\;Vef \leq -1.45 \cdot 10^{+211} \lor \neg \left(Vef \leq 4.2 \cdot 10^{+172}\right):\\
\;\;\;\;\frac{NaChar}{t_0} + \frac{NdChar}{t_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu - Ec}{KbT}}}\\
\end{array}
\end{array}
if Vef < -1.45e211 or 4.2000000000000003e172 < Vef Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 89.0%
Taylor expanded in Vef around inf 81.6%
if -1.45e211 < Vef < 4.2000000000000003e172Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 75.2%
Taylor expanded in Ec around inf 66.2%
Final simplification69.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= NdChar -3e+54)
(+ t_1 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
(if (<= NdChar -2.25e-26)
(+
t_0
(/
NdChar
(-
(+
(/ mu KbT)
(+
2.0
(/ (* (+ Vef EDonor) (- Vef EDonor)) (* KbT (- Vef EDonor)))))
(/ Ec KbT))))
(if (<= NdChar -2.05e-84)
(+ t_1 (/ NaChar (- 2.0 (/ mu KbT))))
(if (<= NdChar 7.5e+28)
(+ t_0 (/ NdChar 2.0))
(+ t_1 (/ NaChar (+ 1.0 (+ 1.0 (/ Ev KbT)))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -3e+54) {
tmp = t_1 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NdChar <= -2.25e-26) {
tmp = t_0 + (NdChar / (((mu / KbT) + (2.0 + (((Vef + EDonor) * (Vef - EDonor)) / (KbT * (Vef - EDonor))))) - (Ec / KbT)));
} else if (NdChar <= -2.05e-84) {
tmp = t_1 + (NaChar / (2.0 - (mu / KbT)));
} else if (NdChar <= 7.5e+28) {
tmp = t_0 + (NdChar / 2.0);
} else {
tmp = t_1 + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ndchar <= (-3d+54)) then
tmp = t_1 + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
else if (ndchar <= (-2.25d-26)) then
tmp = t_0 + (ndchar / (((mu / kbt) + (2.0d0 + (((vef + edonor) * (vef - edonor)) / (kbt * (vef - edonor))))) - (ec / kbt)))
else if (ndchar <= (-2.05d-84)) then
tmp = t_1 + (nachar / (2.0d0 - (mu / kbt)))
else if (ndchar <= 7.5d+28) then
tmp = t_0 + (ndchar / 2.0d0)
else
tmp = t_1 + (nachar / (1.0d0 + (1.0d0 + (ev / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -3e+54) {
tmp = t_1 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NdChar <= -2.25e-26) {
tmp = t_0 + (NdChar / (((mu / KbT) + (2.0 + (((Vef + EDonor) * (Vef - EDonor)) / (KbT * (Vef - EDonor))))) - (Ec / KbT)));
} else if (NdChar <= -2.05e-84) {
tmp = t_1 + (NaChar / (2.0 - (mu / KbT)));
} else if (NdChar <= 7.5e+28) {
tmp = t_0 + (NdChar / 2.0);
} else {
tmp = t_1 + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if NdChar <= -3e+54: tmp = t_1 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) elif NdChar <= -2.25e-26: tmp = t_0 + (NdChar / (((mu / KbT) + (2.0 + (((Vef + EDonor) * (Vef - EDonor)) / (KbT * (Vef - EDonor))))) - (Ec / KbT))) elif NdChar <= -2.05e-84: tmp = t_1 + (NaChar / (2.0 - (mu / KbT))) elif NdChar <= 7.5e+28: tmp = t_0 + (NdChar / 2.0) else: tmp = t_1 + (NaChar / (1.0 + (1.0 + (Ev / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (NdChar <= -3e+54) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); elseif (NdChar <= -2.25e-26) tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(Float64(mu / KbT) + Float64(2.0 + Float64(Float64(Float64(Vef + EDonor) * Float64(Vef - EDonor)) / Float64(KbT * Float64(Vef - EDonor))))) - Float64(Ec / KbT)))); elseif (NdChar <= -2.05e-84) tmp = Float64(t_1 + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); elseif (NdChar <= 7.5e+28) tmp = Float64(t_0 + Float64(NdChar / 2.0)); else tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Ev / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (NdChar <= -3e+54) tmp = t_1 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); elseif (NdChar <= -2.25e-26) tmp = t_0 + (NdChar / (((mu / KbT) + (2.0 + (((Vef + EDonor) * (Vef - EDonor)) / (KbT * (Vef - EDonor))))) - (Ec / KbT))); elseif (NdChar <= -2.05e-84) tmp = t_1 + (NaChar / (2.0 - (mu / KbT))); elseif (NdChar <= 7.5e+28) tmp = t_0 + (NdChar / 2.0); else tmp = t_1 + (NaChar / (1.0 + (1.0 + (Ev / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -3e+54], N[(t$95$1 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2.25e-26], N[(t$95$0 + N[(NdChar / N[(N[(N[(mu / KbT), $MachinePrecision] + N[(2.0 + N[(N[(N[(Vef + EDonor), $MachinePrecision] * N[(Vef - EDonor), $MachinePrecision]), $MachinePrecision] / N[(KbT * N[(Vef - EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2.05e-84], N[(t$95$1 + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 7.5e+28], N[(t$95$0 + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(NaChar / N[(1.0 + N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;NdChar \leq -3 \cdot 10^{+54}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\mathbf{elif}\;NdChar \leq -2.25 \cdot 10^{-26}:\\
\;\;\;\;t_0 + \frac{NdChar}{\left(\frac{mu}{KbT} + \left(2 + \frac{\left(Vef + EDonor\right) \cdot \left(Vef - EDonor\right)}{KbT \cdot \left(Vef - EDonor\right)}\right)\right) - \frac{Ec}{KbT}}\\
\mathbf{elif}\;NdChar \leq -2.05 \cdot 10^{-84}:\\
\;\;\;\;t_1 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\mathbf{elif}\;NdChar \leq 7.5 \cdot 10^{+28}:\\
\;\;\;\;t_0 + \frac{NdChar}{2}\\
\mathbf{else}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + \left(1 + \frac{Ev}{KbT}\right)}\\
\end{array}
\end{array}
if NdChar < -2.9999999999999999e54Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 81.1%
Taylor expanded in EAccept around 0 65.4%
if -2.9999999999999999e54 < NdChar < -2.2499999999999999e-26Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 52.0%
flip-+50.5%
Applied egg-rr50.5%
Taylor expanded in KbT around 0 64.9%
unpow264.9%
unpow264.9%
difference-of-squares64.9%
Simplified64.9%
if -2.2499999999999999e-26 < NdChar < -2.05000000000000003e-84Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 71.7%
neg-mul-171.7%
Simplified71.7%
Taylor expanded in mu around 0 58.7%
mul-1-neg58.7%
unsub-neg58.7%
Simplified58.7%
if -2.05000000000000003e-84 < NdChar < 7.4999999999999998e28Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 68.1%
if 7.4999999999999998e28 < NdChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 81.2%
Taylor expanded in Ev around 0 56.7%
Final simplification64.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= NdChar -1.3e-85)
(+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
(if (<= NdChar 4.2e+29)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar 2.0))
(+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ Ev KbT)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -1.3e-85) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NdChar <= 4.2e+29) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
} else {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ndchar <= (-1.3d-85)) then
tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
else if (ndchar <= 4.2d+29) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / 2.0d0)
else
tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (ev / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -1.3e-85) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NdChar <= 4.2e+29) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
} else {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if NdChar <= -1.3e-85: tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) elif NdChar <= 4.2e+29: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0) else: tmp = t_0 + (NaChar / (1.0 + (1.0 + (Ev / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (NdChar <= -1.3e-85) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); elseif (NdChar <= 4.2e+29) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / 2.0)); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Ev / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (NdChar <= -1.3e-85) tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); elseif (NdChar <= 4.2e+29) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0); else tmp = t_0 + (NaChar / (1.0 + (1.0 + (Ev / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.3e-85], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 4.2e+29], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;NdChar \leq -1.3 \cdot 10^{-85}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\mathbf{elif}\;NdChar \leq 4.2 \cdot 10^{+29}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{Ev}{KbT}\right)}\\
\end{array}
\end{array}
if NdChar < -1.30000000000000006e-85Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 72.7%
Taylor expanded in EAccept around 0 57.9%
if -1.30000000000000006e-85 < NdChar < 4.2000000000000003e29Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 68.1%
if 4.2000000000000003e29 < NdChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 81.2%
Taylor expanded in Ev around 0 56.7%
Final simplification62.2%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -4.1e-85) (not (<= NdChar 3.8e+28)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (- 2.0 (/ 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 ((NdChar <= -4.1e-85) || !(NdChar <= 3.8e+28)) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (2.0 - (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 ((ndchar <= (-4.1d-85)) .or. (.not. (ndchar <= 3.8d+28))) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (2.0d0 - (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 ((NdChar <= -4.1e-85) || !(NdChar <= 3.8e+28)) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (2.0 - (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 (NdChar <= -4.1e-85) or not (NdChar <= 3.8e+28): tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (2.0 - (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 ((NdChar <= -4.1e-85) || !(NdChar <= 3.8e+28)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + 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 ((NdChar <= -4.1e-85) || ~((NdChar <= 3.8e+28))) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (2.0 - (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[Or[LessEqual[NdChar, -4.1e-85], N[Not[LessEqual[NdChar, 3.8e+28]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -4.1 \cdot 10^{-85} \lor \neg \left(NdChar \leq 3.8 \cdot 10^{+28}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if NdChar < -4.09999999999999994e-85 or 3.7999999999999999e28 < NdChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 71.5%
neg-mul-171.5%
Simplified71.5%
Taylor expanded in mu around 0 56.4%
mul-1-neg56.4%
unsub-neg56.4%
Simplified56.4%
if -4.09999999999999994e-85 < NdChar < 3.7999999999999999e28Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 68.1%
Final simplification61.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))))
(if (<= NdChar -1.9e-84)
(+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
(if (<= NdChar 1.45e+29)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar 2.0))
(+ t_0 (/ NaChar (- 2.0 (/ mu KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -1.9e-84) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NdChar <= 1.45e+29) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
} else {
tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
if (ndchar <= (-1.9d-84)) then
tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
else if (ndchar <= 1.45d+29) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / 2.0d0)
else
tmp = t_0 + (nachar / (2.0d0 - (mu / kbt)))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double tmp;
if (NdChar <= -1.9e-84) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NdChar <= 1.45e+29) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
} else {
tmp = t_0 + (NaChar / (2.0 - (mu / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) tmp = 0 if NdChar <= -1.9e-84: tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) elif NdChar <= 1.45e+29: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0) else: tmp = t_0 + (NaChar / (2.0 - (mu / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) tmp = 0.0 if (NdChar <= -1.9e-84) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); elseif (NdChar <= 1.45e+29) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / 2.0)); else tmp = Float64(t_0 + Float64(NaChar / Float64(2.0 - Float64(mu / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); tmp = 0.0; if (NdChar <= -1.9e-84) tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); elseif (NdChar <= 1.45e+29) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0); else tmp = t_0 + (NaChar / (2.0 - (mu / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.9e-84], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.45e+29], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(2.0 - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
\mathbf{if}\;NdChar \leq -1.9 \cdot 10^{-84}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\mathbf{elif}\;NdChar \leq 1.45 \cdot 10^{+29}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{2 - \frac{mu}{KbT}}\\
\end{array}
\end{array}
if NdChar < -1.89999999999999993e-84Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 72.7%
Taylor expanded in EAccept around 0 57.9%
if -1.89999999999999993e-84 < NdChar < 1.45e29Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 68.1%
if 1.45e29 < NdChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 65.0%
neg-mul-165.0%
Simplified65.0%
Taylor expanded in mu around 0 57.1%
mul-1-neg57.1%
unsub-neg57.1%
Simplified57.1%
Final simplification62.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -1.5e+52) (not (<= NdChar 5e+28)))
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(* NaChar 0.5))
(+
(/ 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 ((NdChar <= -1.5e+52) || !(NdChar <= 5e+28)) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((ndchar <= (-1.5d+52)) .or. (.not. (ndchar <= 5d+28))) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -1.5e+52) || !(NdChar <= 5e+28)) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -1.5e+52) or not (NdChar <= 5e+28): tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -1.5e+52) || !(NdChar <= 5e+28)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -1.5e+52) || ~((NdChar <= 5e+28))) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.5e+52], N[Not[LessEqual[NdChar, 5e+28]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -1.5 \cdot 10^{+52} \lor \neg \left(NdChar \leq 5 \cdot 10^{+28}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if NdChar < -1.5e52 or 4.99999999999999957e28 < NdChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 76.0%
Taylor expanded in EAccept around 0 56.1%
if -1.5e52 < NdChar < 4.99999999999999957e28Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 61.6%
Final simplification59.2%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ 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) {
return (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (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 / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (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 / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / 2.0)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{2}
\end{array}
Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 47.3%
Final simplification47.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= EAccept 2.6e-97)
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar 2.0))
(if (<= EAccept 2.9e+21)
(/ NaChar (+ (/ Ev KbT) 2.0))
(+ (/ 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 (EAccept <= 2.6e-97) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
} else if (EAccept <= 2.9e+21) {
tmp = NaChar / ((Ev / KbT) + 2.0);
} 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 (eaccept <= 2.6d-97) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / 2.0d0)
else if (eaccept <= 2.9d+21) then
tmp = nachar / ((ev / kbt) + 2.0d0)
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 (EAccept <= 2.6e-97) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
} else if (EAccept <= 2.9e+21) {
tmp = NaChar / ((Ev / KbT) + 2.0);
} 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 EAccept <= 2.6e-97: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0) elif EAccept <= 2.9e+21: tmp = NaChar / ((Ev / KbT) + 2.0) 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 (EAccept <= 2.6e-97) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / 2.0)); elseif (EAccept <= 2.9e+21) tmp = Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0)); 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 (EAccept <= 2.6e-97) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0); elseif (EAccept <= 2.9e+21) tmp = NaChar / ((Ev / KbT) + 2.0); 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[EAccept, 2.6e-97], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 2.9e+21], N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $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}\;EAccept \leq 2.6 \cdot 10^{-97}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{elif}\;EAccept \leq 2.9 \cdot 10^{+21}:\\
\;\;\;\;\frac{NaChar}{\frac{Ev}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if EAccept < 2.60000000000000007e-97Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 73.8%
Taylor expanded in KbT around inf 34.9%
if 2.60000000000000007e-97 < EAccept < 2.9e21Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 76.8%
Taylor expanded in KbT around inf 21.6%
Taylor expanded in Ev around 0 21.0%
Taylor expanded in NaChar around -inf 29.9%
if 2.9e21 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 86.1%
Taylor expanded in KbT around inf 47.3%
Final simplification37.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (<= EAccept 1.15e+64) (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (/ NdChar 2.0)) (+ (/ 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 (EAccept <= 1.15e+64) {
tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
} 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 (eaccept <= 1.15d+64) then
tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / 2.0d0)
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 (EAccept <= 1.15e+64) {
tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / 2.0);
} 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 EAccept <= 1.15e+64: tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / 2.0) 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 (EAccept <= 1.15e+64) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / 2.0)); 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 (EAccept <= 1.15e+64) tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0); 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[EAccept, 1.15e+64], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $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}\;EAccept \leq 1.15 \cdot 10^{+64}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if EAccept < 1.15e64Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 46.0%
Taylor expanded in Vef around inf 38.0%
if 1.15e64 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 89.8%
Taylor expanded in KbT around inf 46.8%
Final simplification39.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ 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) {
return (NaChar / (1.0 + exp((EAccept / KbT)))) + (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 / (1.0d0 + exp((eaccept / kbt)))) + (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 / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}
\end{array}
Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 70.8%
Taylor expanded in KbT around inf 36.8%
Final simplification36.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (* 0.5 (+ NdChar NaChar)))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return 0.5 * (NdChar + NaChar);
}
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 = 0.5d0 * (ndchar + nachar)
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 0.5 * (NdChar + NaChar);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return 0.5 * (NdChar + NaChar)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(0.5 * Float64(NdChar + NaChar)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.5 * (NdChar + NaChar); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \left(NdChar + NaChar\right)
\end{array}
Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 70.3%
Taylor expanded in KbT around inf 34.1%
Taylor expanded in Ev around 0 24.6%
Taylor expanded in Ev around 0 25.8%
distribute-lft-out25.8%
Simplified25.8%
Final simplification25.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (* NdChar 0.5))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NdChar * 0.5;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = ndchar * 0.5d0
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NdChar * 0.5;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return NdChar * 0.5
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(NdChar * 0.5) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = NdChar * 0.5; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NdChar * 0.5), $MachinePrecision]
\begin{array}{l}
\\
NdChar \cdot 0.5
\end{array}
Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 70.3%
Taylor expanded in KbT around inf 34.1%
Taylor expanded in Ev around 0 24.6%
Taylor expanded in NdChar around inf 19.3%
Final simplification19.3%
herbie shell --seed 2023240
(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))))))