
(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 21 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 (pow (sqrt (exp (/ (+ Vef (- (+ Ev EAccept) mu)) KbT))) 2.0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + pow(sqrt(exp(((Vef + ((Ev + EAccept) - mu)) / KbT))), 2.0)));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (sqrt(exp(((vef + ((ev + eaccept) - mu)) / kbt))) ** 2.0d0)))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + Math.pow(Math.sqrt(Math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))), 2.0)));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + math.pow(math.sqrt(math.exp(((Vef + ((Ev + EAccept) - mu)) / KbT))), 2.0)))
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 + (sqrt(exp(Float64(Float64(Vef + Float64(Float64(Ev + EAccept) - mu)) / KbT))) ^ 2.0)))) 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 + (sqrt(exp(((Vef + ((Ev + EAccept) - mu)) / KbT))) ^ 2.0))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Power[N[Sqrt[N[Exp[N[(N[(Vef + N[(N[(Ev + EAccept), $MachinePrecision] - mu), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + {\left(\sqrt{e^{\frac{Vef + \left(\left(Ev + EAccept\right) - mu\right)}{KbT}}}\right)}^{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%
add-sqr-sqrt100.0%
pow2100.0%
associate--l+100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_1
(+
t_0
(/
NaChar
(+
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ 1.0 (/ Vef KbT))))
(/ mu KbT))))))
(t_2 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_3
(+
(/ NdChar (+ 1.0 (exp (/ Vef KbT))))
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))))
(if (<= Vef -7.5e+114)
t_3
(if (<= Vef -3.4e-58)
t_1
(if (<= Vef -9e-164)
t_2
(if (<= Vef -3.2e-219)
(+
t_0
(/
NaChar
(+
(+ 2.0 (/ EAccept KbT))
(* 0.5 (/ (* EAccept EAccept) (* KbT KbT))))))
(if (<= Vef -1.45e-245)
(+ t_2 (/ NdChar (+ 1.0 (/ EDonor KbT))))
(if (<= Vef 2.9e-117)
(+ NdChar t_2)
(if (<= Vef 5.9e-31) t_1 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 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = t_0 + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
double t_2 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_3 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
double tmp;
if (Vef <= -7.5e+114) {
tmp = t_3;
} else if (Vef <= -3.4e-58) {
tmp = t_1;
} else if (Vef <= -9e-164) {
tmp = t_2;
} else if (Vef <= -3.2e-219) {
tmp = t_0 + (NaChar / ((2.0 + (EAccept / KbT)) + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (Vef <= -1.45e-245) {
tmp = t_2 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (Vef <= 2.9e-117) {
tmp = NdChar + t_2;
} else if (Vef <= 5.9e-31) {
tmp = t_1;
} else {
tmp = 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) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_1 = t_0 + (nachar / (1.0d0 + (((ev / kbt) + ((eaccept / kbt) + (1.0d0 + (vef / kbt)))) - (mu / kbt))))
t_2 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_3 = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
if (vef <= (-7.5d+114)) then
tmp = t_3
else if (vef <= (-3.4d-58)) then
tmp = t_1
else if (vef <= (-9d-164)) then
tmp = t_2
else if (vef <= (-3.2d-219)) then
tmp = t_0 + (nachar / ((2.0d0 + (eaccept / kbt)) + (0.5d0 * ((eaccept * eaccept) / (kbt * kbt)))))
else if (vef <= (-1.45d-245)) then
tmp = t_2 + (ndchar / (1.0d0 + (edonor / kbt)))
else if (vef <= 2.9d-117) then
tmp = ndchar + t_2
else if (vef <= 5.9d-31) then
tmp = t_1
else
tmp = 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 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_1 = t_0 + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
double t_2 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_3 = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
double tmp;
if (Vef <= -7.5e+114) {
tmp = t_3;
} else if (Vef <= -3.4e-58) {
tmp = t_1;
} else if (Vef <= -9e-164) {
tmp = t_2;
} else if (Vef <= -3.2e-219) {
tmp = t_0 + (NaChar / ((2.0 + (EAccept / KbT)) + (0.5 * ((EAccept * EAccept) / (KbT * KbT)))));
} else if (Vef <= -1.45e-245) {
tmp = t_2 + (NdChar / (1.0 + (EDonor / KbT)));
} else if (Vef <= 2.9e-117) {
tmp = NdChar + t_2;
} else if (Vef <= 5.9e-31) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_1 = t_0 + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))) t_2 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_3 = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT)))) tmp = 0 if Vef <= -7.5e+114: tmp = t_3 elif Vef <= -3.4e-58: tmp = t_1 elif Vef <= -9e-164: tmp = t_2 elif Vef <= -3.2e-219: tmp = t_0 + (NaChar / ((2.0 + (EAccept / KbT)) + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))) elif Vef <= -1.45e-245: tmp = t_2 + (NdChar / (1.0 + (EDonor / KbT))) elif Vef <= 2.9e-117: tmp = NdChar + t_2 elif Vef <= 5.9e-31: tmp = t_1 else: tmp = t_3 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_1 = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(1.0 + Float64(Vef / KbT)))) - Float64(mu / KbT))))) t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_3 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT))))) tmp = 0.0 if (Vef <= -7.5e+114) tmp = t_3; elseif (Vef <= -3.4e-58) tmp = t_1; elseif (Vef <= -9e-164) tmp = t_2; elseif (Vef <= -3.2e-219) tmp = Float64(t_0 + Float64(NaChar / Float64(Float64(2.0 + Float64(EAccept / KbT)) + Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT)))))); elseif (Vef <= -1.45e-245) tmp = Float64(t_2 + Float64(NdChar / Float64(1.0 + Float64(EDonor / KbT)))); elseif (Vef <= 2.9e-117) tmp = Float64(NdChar + t_2); elseif (Vef <= 5.9e-31) tmp = t_1; else tmp = t_3; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_1 = t_0 + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))); t_2 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_3 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT)))); tmp = 0.0; if (Vef <= -7.5e+114) tmp = t_3; elseif (Vef <= -3.4e-58) tmp = t_1; elseif (Vef <= -9e-164) tmp = t_2; elseif (Vef <= -3.2e-219) tmp = t_0 + (NaChar / ((2.0 + (EAccept / KbT)) + (0.5 * ((EAccept * EAccept) / (KbT * KbT))))); elseif (Vef <= -1.45e-245) tmp = t_2 + (NdChar / (1.0 + (EDonor / KbT))); elseif (Vef <= 2.9e-117) tmp = NdChar + t_2; elseif (Vef <= 5.9e-31) tmp = t_1; else tmp = t_3; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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$3 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -7.5e+114], t$95$3, If[LessEqual[Vef, -3.4e-58], t$95$1, If[LessEqual[Vef, -9e-164], t$95$2, If[LessEqual[Vef, -3.2e-219], N[(t$95$0 + N[(NaChar / N[(N[(2.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -1.45e-245], N[(t$95$2 + N[(NdChar / N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2.9e-117], N[(NdChar + t$95$2), $MachinePrecision], If[LessEqual[Vef, 5.9e-31], t$95$1, t$95$3]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_1 := t_0 + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\
t_2 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_3 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\
\mathbf{if}\;Vef \leq -7.5 \cdot 10^{+114}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;Vef \leq -3.4 \cdot 10^{-58}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Vef \leq -9 \cdot 10^{-164}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;Vef \leq -3.2 \cdot 10^{-219}:\\
\;\;\;\;t_0 + \frac{NaChar}{\left(2 + \frac{EAccept}{KbT}\right) + 0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT}}\\
\mathbf{elif}\;Vef \leq -1.45 \cdot 10^{-245}:\\
\;\;\;\;t_2 + \frac{NdChar}{1 + \frac{EDonor}{KbT}}\\
\mathbf{elif}\;Vef \leq 2.9 \cdot 10^{-117}:\\
\;\;\;\;NdChar + t_2\\
\mathbf{elif}\;Vef \leq 5.9 \cdot 10^{-31}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if Vef < -7.5000000000000001e114 or 5.90000000000000032e-31 < 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 88.6%
Taylor expanded in EAccept around 0 84.4%
+-commutative84.4%
+-commutative84.4%
Simplified84.4%
if -7.5000000000000001e114 < Vef < -3.39999999999999973e-58 or 2.9000000000000001e-117 < Vef < 5.90000000000000032e-31Initial 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 79.6%
if -3.39999999999999973e-58 < Vef < -8.9999999999999995e-164Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 69.3%
Taylor expanded in EDonor around inf 38.9%
associate-/l*43.1%
Simplified43.1%
Taylor expanded in KbT around 0 78.0%
if -8.9999999999999995e-164 < Vef < -3.19999999999999998e-219Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 86.0%
Taylor expanded in EAccept around 0 71.0%
associate-+r+71.0%
+-commutative71.0%
unpow271.0%
unpow271.0%
Simplified71.0%
if -3.19999999999999998e-219 < Vef < -1.45e-245Initial 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 80.7%
Taylor expanded in EDonor around inf 100.0%
if -1.45e-245 < Vef < 2.9000000000000001e-117Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 50.2%
Taylor expanded in Ec around inf 53.5%
neg-mul-153.5%
distribute-neg-frac53.5%
Simplified53.5%
Taylor expanded in Ec around 0 81.9%
Final simplification82.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_2 (/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT)))))
(t_3 (+ t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
(if (<= Vef -1.1e+137)
(+ t_1 t_0)
(if (<= Vef -4.2e-58)
(+ t_2 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= Vef -8.8e-149)
t_3
(if (<= Vef -7.2e-218)
(+ t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Vef -4.8e-306)
t_3
(if (<= Vef 9.5e+35)
(+ t_2 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(+
t_0
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp((Vef / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_3 = t_1 + (NdChar / (1.0 + exp((mu / KbT))));
double tmp;
if (Vef <= -1.1e+137) {
tmp = t_1 + t_0;
} else if (Vef <= -4.2e-58) {
tmp = t_2 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (Vef <= -8.8e-149) {
tmp = t_3;
} else if (Vef <= -7.2e-218) {
tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Vef <= -4.8e-306) {
tmp = t_3;
} else if (Vef <= 9.5e+35) {
tmp = t_2 + (NaChar / (1.0 + exp((EAccept / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp((vef / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_2 = ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))
t_3 = t_1 + (ndchar / (1.0d0 + exp((mu / kbt))))
if (vef <= (-1.1d+137)) then
tmp = t_1 + t_0
else if (vef <= (-4.2d-58)) then
tmp = t_2 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (vef <= (-8.8d-149)) then
tmp = t_3
else if (vef <= (-7.2d-218)) then
tmp = t_1 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (vef <= (-4.8d-306)) then
tmp = t_3
else if (vef <= 9.5d+35) then
tmp = t_2 + (nachar / (1.0d0 + exp((eaccept / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp((Vef / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)));
double t_3 = t_1 + (NdChar / (1.0 + Math.exp((mu / KbT))));
double tmp;
if (Vef <= -1.1e+137) {
tmp = t_1 + t_0;
} else if (Vef <= -4.2e-58) {
tmp = t_2 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (Vef <= -8.8e-149) {
tmp = t_3;
} else if (Vef <= -7.2e-218) {
tmp = t_1 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Vef <= -4.8e-306) {
tmp = t_3;
} else if (Vef <= 9.5e+35) {
tmp = t_2 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp((Vef / KbT))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_2 = NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT))) t_3 = t_1 + (NdChar / (1.0 + math.exp((mu / KbT)))) tmp = 0 if Vef <= -1.1e+137: tmp = t_1 + t_0 elif Vef <= -4.2e-58: tmp = t_2 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif Vef <= -8.8e-149: tmp = t_3 elif Vef <= -7.2e-218: tmp = t_1 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Vef <= -4.8e-306: tmp = t_3 elif Vef <= 9.5e+35: tmp = t_2 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) t_3 = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))) tmp = 0.0 if (Vef <= -1.1e+137) tmp = Float64(t_1 + t_0); elseif (Vef <= -4.2e-58) tmp = Float64(t_2 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (Vef <= -8.8e-149) tmp = t_3; elseif (Vef <= -7.2e-218) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Vef <= -4.8e-306) tmp = t_3; elseif (Vef <= 9.5e+35) tmp = Float64(t_2 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - 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((Vef / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_2 = NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT))); t_3 = t_1 + (NdChar / (1.0 + exp((mu / KbT)))); tmp = 0.0; if (Vef <= -1.1e+137) tmp = t_1 + t_0; elseif (Vef <= -4.2e-58) tmp = t_2 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (Vef <= -8.8e-149) tmp = t_3; elseif (Vef <= -7.2e-218) tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Vef <= -4.8e-306) tmp = t_3; elseif (Vef <= 9.5e+35) tmp = t_2 + (NaChar / (1.0 + exp((EAccept / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((((Vef + Ev) - 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[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -1.1e+137], N[(t$95$1 + t$95$0), $MachinePrecision], If[LessEqual[Vef, -4.2e-58], N[(t$95$2 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -8.8e-149], t$95$3, If[LessEqual[Vef, -7.2e-218], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -4.8e-306], t$95$3, If[LessEqual[Vef, 9.5e+35], N[(t$95$2 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}}\\
t_3 := t_1 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{if}\;Vef \leq -1.1 \cdot 10^{+137}:\\
\;\;\;\;t_1 + t_0\\
\mathbf{elif}\;Vef \leq -4.2 \cdot 10^{-58}:\\
\;\;\;\;t_2 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;Vef \leq -8.8 \cdot 10^{-149}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;Vef \leq -7.2 \cdot 10^{-218}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Vef \leq -4.8 \cdot 10^{-306}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;Vef \leq 9.5 \cdot 10^{+35}:\\
\;\;\;\;t_2 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\
\end{array}
\end{array}
if Vef < -1.10000000000000008e137Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in Vef around inf 93.2%
if -1.10000000000000008e137 < Vef < -4.19999999999999975e-58Initial 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 83.4%
if -4.19999999999999975e-58 < Vef < -8.7999999999999993e-149 or -7.20000000000000023e-218 < Vef < -4.7999999999999999e-306Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 88.9%
if -8.7999999999999993e-149 < Vef < -7.20000000000000023e-218Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 88.8%
if -4.7999999999999999e-306 < Vef < 9.50000000000000062e35Initial 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.8%
if 9.50000000000000062e35 < 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.6%
Taylor expanded in EAccept around 0 81.9%
+-commutative81.9%
+-commutative81.9%
Simplified81.9%
Final simplification84.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
(if (<= Vef -3.8e+81)
t_1
(if (<= Vef -4e-222)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Vef 2.05e-116)
(+ NdChar t_0)
(if (<= Vef 2.35e-28)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/
NaChar
(+
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ 1.0 (/ Vef KbT))))
(/ mu KbT)))))
t_1))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
double tmp;
if (Vef <= -3.8e+81) {
tmp = t_1;
} else if (Vef <= -4e-222) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Vef <= 2.05e-116) {
tmp = NdChar + t_0;
} else if (Vef <= 2.35e-28) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
if (vef <= (-3.8d+81)) then
tmp = t_1
else if (vef <= (-4d-222)) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (vef <= 2.05d-116) then
tmp = ndchar + t_0
else if (vef <= 2.35d-28) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (((ev / kbt) + ((eaccept / kbt) + (1.0d0 + (vef / kbt)))) - (mu / kbt))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
double tmp;
if (Vef <= -3.8e+81) {
tmp = t_1;
} else if (Vef <= -4e-222) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Vef <= 2.05e-116) {
tmp = NdChar + t_0;
} else if (Vef <= 2.35e-28) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT)))) tmp = 0 if Vef <= -3.8e+81: tmp = t_1 elif Vef <= -4e-222: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Vef <= 2.05e-116: tmp = NdChar + t_0 elif Vef <= 2.35e-28: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))) else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))) tmp = 0.0 if (Vef <= -3.8e+81) tmp = t_1; elseif (Vef <= -4e-222) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Vef <= 2.05e-116) tmp = Float64(NdChar + t_0); elseif (Vef <= 2.35e-28) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(1.0 + Float64(Vef / KbT)))) - Float64(mu / KbT))))); else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT)))); tmp = 0.0; if (Vef <= -3.8e+81) tmp = t_1; elseif (Vef <= -4e-222) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Vef <= 2.05e-116) tmp = NdChar + t_0; elseif (Vef <= 2.35e-28) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))); else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.8e+81], t$95$1, If[LessEqual[Vef, -4e-222], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 2.05e-116], N[(NdChar + t$95$0), $MachinePrecision], If[LessEqual[Vef, 2.35e-28], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;Vef \leq -3.8 \cdot 10^{+81}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Vef \leq -4 \cdot 10^{-222}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Vef \leq 2.05 \cdot 10^{-116}:\\
\;\;\;\;NdChar + t_0\\
\mathbf{elif}\;Vef \leq 2.35 \cdot 10^{-28}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if Vef < -3.8e81 or 2.3499999999999998e-28 < 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 87.0%
if -3.8e81 < Vef < -4.00000000000000019e-222Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 79.4%
if -4.00000000000000019e-222 < Vef < 2.0499999999999999e-116Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 52.2%
Taylor expanded in Ec around inf 57.2%
neg-mul-157.2%
distribute-neg-frac57.2%
Simplified57.2%
Taylor expanded in Ec around 0 83.4%
if 2.0499999999999999e-116 < Vef < 2.3499999999999998e-28Initial 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 85.5%
Final simplification84.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1
(+
(/ NdChar (+ 1.0 (exp (/ Vef KbT))))
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))))
(if (<= Vef -3.1e+82)
t_1
(if (<= Vef -2e-224)
(+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= Vef 7.2e-118)
(+ NdChar t_0)
(if (<= Vef 1.35e-27)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/
NaChar
(+
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ 1.0 (/ Vef KbT))))
(/ mu KbT)))))
t_1))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
double tmp;
if (Vef <= -3.1e+82) {
tmp = t_1;
} else if (Vef <= -2e-224) {
tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (Vef <= 7.2e-118) {
tmp = NdChar + t_0;
} else if (Vef <= 1.35e-27) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
if (vef <= (-3.1d+82)) then
tmp = t_1
else if (vef <= (-2d-224)) then
tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (vef <= 7.2d-118) then
tmp = ndchar + t_0
else if (vef <= 1.35d-27) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (((ev / kbt) + ((eaccept / kbt) + (1.0d0 + (vef / kbt)))) - (mu / kbt))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
double tmp;
if (Vef <= -3.1e+82) {
tmp = t_1;
} else if (Vef <= -2e-224) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (Vef <= 7.2e-118) {
tmp = NdChar + t_0;
} else if (Vef <= 1.35e-27) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT)))) tmp = 0 if Vef <= -3.1e+82: tmp = t_1 elif Vef <= -2e-224: tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif Vef <= 7.2e-118: tmp = NdChar + t_0 elif Vef <= 1.35e-27: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))) else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT))))) tmp = 0.0 if (Vef <= -3.1e+82) tmp = t_1; elseif (Vef <= -2e-224) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (Vef <= 7.2e-118) tmp = Float64(NdChar + t_0); elseif (Vef <= 1.35e-27) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(1.0 + Float64(Vef / KbT)))) - Float64(mu / KbT))))); else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT)))); tmp = 0.0; if (Vef <= -3.1e+82) tmp = t_1; elseif (Vef <= -2e-224) tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (Vef <= 7.2e-118) tmp = NdChar + t_0; elseif (Vef <= 1.35e-27) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))); else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(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[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + Ev), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -3.1e+82], t$95$1, If[LessEqual[Vef, -2e-224], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 7.2e-118], N[(NdChar + t$95$0), $MachinePrecision], If[LessEqual[Vef, 1.35e-27], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\
\mathbf{if}\;Vef \leq -3.1 \cdot 10^{+82}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Vef \leq -2 \cdot 10^{-224}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;Vef \leq 7.2 \cdot 10^{-118}:\\
\;\;\;\;NdChar + t_0\\
\mathbf{elif}\;Vef \leq 1.35 \cdot 10^{-27}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if Vef < -3.10000000000000032e82 or 1.34999999999999994e-27 < 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 87.0%
Taylor expanded in EAccept around 0 83.1%
+-commutative83.1%
+-commutative83.1%
Simplified83.1%
if -3.10000000000000032e82 < Vef < -2e-224Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EDonor around inf 79.4%
if -2e-224 < Vef < 7.2000000000000004e-118Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 52.2%
Taylor expanded in Ec around inf 57.2%
neg-mul-157.2%
distribute-neg-frac57.2%
Simplified57.2%
Taylor expanded in Ec around 0 83.4%
if 7.2000000000000004e-118 < Vef < 1.34999999999999994e-27Initial 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 85.5%
Final simplification82.4%
(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 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (or (<= mu -4.2e-38) (not (<= mu 3.15e+78)))
(+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if ((mu <= -4.2e-38) || !(mu <= 3.15e+78)) {
tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
} else {
tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if ((mu <= (-4.2d-38)) .or. (.not. (mu <= 3.15d+78))) then
tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
else
tmp = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if ((mu <= -4.2e-38) || !(mu <= 3.15e+78)) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
} else {
tmp = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if (mu <= -4.2e-38) or not (mu <= 3.15e+78): tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT)))) else: tmp = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if ((mu <= -4.2e-38) || !(mu <= 3.15e+78)) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); else tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if ((mu <= -4.2e-38) || ~((mu <= 3.15e+78))) tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT)))); else tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[mu, -4.2e-38], N[Not[LessEqual[mu, 3.15e+78]], $MachinePrecision]], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;mu \leq -4.2 \cdot 10^{-38} \lor \neg \left(mu \leq 3.15 \cdot 10^{+78}\right):\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\end{array}
\end{array}
if mu < -4.20000000000000026e-38 or 3.1500000000000001e78 < mu Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 84.0%
if -4.20000000000000026e-38 < mu < 3.1500000000000001e78Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 79.3%
Final simplification81.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (+ NdChar t_0)))
(if (<= NaChar -8.7e-79)
t_1
(if (<= NaChar 1.32e-101)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/
NaChar
(+
1.0
(-
(+ (/ Ev KbT) (+ (/ EAccept KbT) (+ 1.0 (/ Vef KbT))))
(/ mu KbT)))))
(if (or (<= NaChar 1.35e-42) (not (<= NaChar 1.05e+232))) t_0 t_1)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar + t_0;
double tmp;
if (NaChar <= -8.7e-79) {
tmp = t_1;
} else if (NaChar <= 1.32e-101) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
} else if ((NaChar <= 1.35e-42) || !(NaChar <= 1.05e+232)) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar + t_0
if (nachar <= (-8.7d-79)) then
tmp = t_1
else if (nachar <= 1.32d-101) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (1.0d0 + (((ev / kbt) + ((eaccept / kbt) + (1.0d0 + (vef / kbt)))) - (mu / kbt))))
else if ((nachar <= 1.35d-42) .or. (.not. (nachar <= 1.05d+232))) then
tmp = t_0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar + t_0;
double tmp;
if (NaChar <= -8.7e-79) {
tmp = t_1;
} else if (NaChar <= 1.32e-101) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT))));
} else if ((NaChar <= 1.35e-42) || !(NaChar <= 1.05e+232)) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar + t_0 tmp = 0 if NaChar <= -8.7e-79: tmp = t_1 elif NaChar <= 1.32e-101: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))) elif (NaChar <= 1.35e-42) or not (NaChar <= 1.05e+232): tmp = t_0 else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar + t_0) tmp = 0.0 if (NaChar <= -8.7e-79) tmp = t_1; elseif (NaChar <= 1.32e-101) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(1.0 + Float64(Vef / KbT)))) - Float64(mu / KbT))))); elseif ((NaChar <= 1.35e-42) || !(NaChar <= 1.05e+232)) tmp = t_0; else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar + t_0; tmp = 0.0; if (NaChar <= -8.7e-79) tmp = t_1; elseif (NaChar <= 1.32e-101) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (1.0 + (((Ev / KbT) + ((EAccept / KbT) + (1.0 + (Vef / KbT)))) - (mu / KbT)))); elseif ((NaChar <= 1.35e-42) || ~((NaChar <= 1.05e+232))) tmp = t_0; else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar + t$95$0), $MachinePrecision]}, If[LessEqual[NaChar, -8.7e-79], t$95$1, If[LessEqual[NaChar, 1.32e-101], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, 1.35e-42], N[Not[LessEqual[NaChar, 1.05e+232]], $MachinePrecision]], t$95$0, t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := NdChar + t_0\\
\mathbf{if}\;NaChar \leq -8.7 \cdot 10^{-79}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NaChar \leq 1.32 \cdot 10^{-101}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{1 + \left(\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(1 + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}\right)}\\
\mathbf{elif}\;NaChar \leq 1.35 \cdot 10^{-42} \lor \neg \left(NaChar \leq 1.05 \cdot 10^{+232}\right):\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if NaChar < -8.7000000000000002e-79 or 1.35e-42 < NaChar < 1.04999999999999996e232Initial 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.4%
Taylor expanded in Ec around inf 67.6%
neg-mul-167.6%
distribute-neg-frac67.6%
Simplified67.6%
Taylor expanded in Ec around 0 79.8%
if -8.7000000000000002e-79 < NaChar < 1.32e-101Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 76.1%
if 1.32e-101 < NaChar < 1.35e-42 or 1.04999999999999996e232 < NaChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 60.0%
Taylor expanded in EDonor around inf 34.4%
associate-/l*37.1%
Simplified37.1%
Taylor expanded in KbT around 0 88.5%
Final simplification79.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_1 (+ NdChar t_0)))
(if (<= NaChar -1.62e-49)
t_1
(if (<= NaChar -1.4e-210)
t_0
(if (<= NaChar 6.7e-105)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar (+ 2.0 (/ EAccept KbT))))
(if (or (<= NaChar 1.16e-42) (not (<= NaChar 1.05e+232)))
t_0
t_1))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar + t_0;
double tmp;
if (NaChar <= -1.62e-49) {
tmp = t_1;
} else if (NaChar <= -1.4e-210) {
tmp = t_0;
} else if (NaChar <= 6.7e-105) {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (2.0 + (EAccept / KbT)));
} else if ((NaChar <= 1.16e-42) || !(NaChar <= 1.05e+232)) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar + t_0
if (nachar <= (-1.62d-49)) then
tmp = t_1
else if (nachar <= (-1.4d-210)) then
tmp = t_0
else if (nachar <= 6.7d-105) then
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / (2.0d0 + (eaccept / kbt)))
else if ((nachar <= 1.16d-42) .or. (.not. (nachar <= 1.05d+232))) then
tmp = t_0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar + t_0;
double tmp;
if (NaChar <= -1.62e-49) {
tmp = t_1;
} else if (NaChar <= -1.4e-210) {
tmp = t_0;
} else if (NaChar <= 6.7e-105) {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (2.0 + (EAccept / KbT)));
} else if ((NaChar <= 1.16e-42) || !(NaChar <= 1.05e+232)) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar + t_0 tmp = 0 if NaChar <= -1.62e-49: tmp = t_1 elif NaChar <= -1.4e-210: tmp = t_0 elif NaChar <= 6.7e-105: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (2.0 + (EAccept / KbT))) elif (NaChar <= 1.16e-42) or not (NaChar <= 1.05e+232): tmp = t_0 else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar + t_0) tmp = 0.0 if (NaChar <= -1.62e-49) tmp = t_1; elseif (NaChar <= -1.4e-210) tmp = t_0; elseif (NaChar <= 6.7e-105) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / Float64(2.0 + Float64(EAccept / KbT)))); elseif ((NaChar <= 1.16e-42) || !(NaChar <= 1.05e+232)) tmp = t_0; else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar + t_0; tmp = 0.0; if (NaChar <= -1.62e-49) tmp = t_1; elseif (NaChar <= -1.4e-210) tmp = t_0; elseif (NaChar <= 6.7e-105) tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / (2.0 + (EAccept / KbT))); elseif ((NaChar <= 1.16e-42) || ~((NaChar <= 1.05e+232))) tmp = t_0; else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar + t$95$0), $MachinePrecision]}, If[LessEqual[NaChar, -1.62e-49], t$95$1, If[LessEqual[NaChar, -1.4e-210], t$95$0, If[LessEqual[NaChar, 6.7e-105], 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[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, 1.16e-42], N[Not[LessEqual[NaChar, 1.05e+232]], $MachinePrecision]], t$95$0, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := NdChar + t_0\\
\mathbf{if}\;NaChar \leq -1.62 \cdot 10^{-49}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NaChar \leq -1.4 \cdot 10^{-210}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq 6.7 \cdot 10^{-105}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{2 + \frac{EAccept}{KbT}}\\
\mathbf{elif}\;NaChar \leq 1.16 \cdot 10^{-42} \lor \neg \left(NaChar \leq 1.05 \cdot 10^{+232}\right):\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if NaChar < -1.62e-49 or 1.1600000000000001e-42 < NaChar < 1.04999999999999996e232Initial 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.7%
Taylor expanded in Ec around inf 68.1%
neg-mul-168.1%
distribute-neg-frac68.1%
Simplified68.1%
Taylor expanded in Ec around 0 81.4%
if -1.62e-49 < NaChar < -1.4e-210 or 6.7000000000000002e-105 < NaChar < 1.1600000000000001e-42 or 1.04999999999999996e232 < NaChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 50.4%
Taylor expanded in EDonor around inf 28.5%
associate-/l*32.8%
Simplified32.8%
Taylor expanded in KbT around 0 78.8%
if -1.4e-210 < NaChar < 6.7000000000000002e-105Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 78.9%
Taylor expanded in EAccept around 0 80.0%
Final simplification80.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 t_0)))
(if (<= KbT -5.4e+194)
(+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar 2.0))
(if (<= KbT -2.3e+131)
t_0
(if (<= KbT -3e+42)
t_1
(if (<= KbT -6.2e-189)
t_0
(if (<= KbT 9.2e+161)
t_1
(+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar + t_0;
double tmp;
if (KbT <= -5.4e+194) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
} else if (KbT <= -2.3e+131) {
tmp = t_0;
} else if (KbT <= -3e+42) {
tmp = t_1;
} else if (KbT <= -6.2e-189) {
tmp = t_0;
} else if (KbT <= 9.2e+161) {
tmp = t_1;
} else {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_1 = ndchar + t_0
if (kbt <= (-5.4d+194)) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / 2.0d0)
else if (kbt <= (-2.3d+131)) then
tmp = t_0
else if (kbt <= (-3d+42)) then
tmp = t_1
else if (kbt <= (-6.2d-189)) then
tmp = t_0
else if (kbt <= 9.2d+161) then
tmp = t_1
else
tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + exp((-ec / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_1 = NdChar + t_0;
double tmp;
if (KbT <= -5.4e+194) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / 2.0);
} else if (KbT <= -2.3e+131) {
tmp = t_0;
} else if (KbT <= -3e+42) {
tmp = t_1;
} else if (KbT <= -6.2e-189) {
tmp = t_0;
} else if (KbT <= 9.2e+161) {
tmp = t_1;
} else {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_1 = NdChar + t_0 tmp = 0 if KbT <= -5.4e+194: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / 2.0) elif KbT <= -2.3e+131: tmp = t_0 elif KbT <= -3e+42: tmp = t_1 elif KbT <= -6.2e-189: tmp = t_0 elif KbT <= 9.2e+161: tmp = t_1 else: tmp = (NaChar / 2.0) + (NdChar / (1.0 + math.exp((-Ec / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_1 = Float64(NdChar + t_0) tmp = 0.0 if (KbT <= -5.4e+194) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / 2.0)); elseif (KbT <= -2.3e+131) tmp = t_0; elseif (KbT <= -3e+42) tmp = t_1; elseif (KbT <= -6.2e-189) tmp = t_0; elseif (KbT <= 9.2e+161) tmp = t_1; else tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_1 = NdChar + t_0; tmp = 0.0; if (KbT <= -5.4e+194) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0); elseif (KbT <= -2.3e+131) tmp = t_0; elseif (KbT <= -3e+42) tmp = t_1; elseif (KbT <= -6.2e-189) tmp = t_0; elseif (KbT <= 9.2e+161) tmp = t_1; else tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar + t$95$0), $MachinePrecision]}, If[LessEqual[KbT, -5.4e+194], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2.3e+131], t$95$0, If[LessEqual[KbT, -3e+42], t$95$1, If[LessEqual[KbT, -6.2e-189], t$95$0, If[LessEqual[KbT, 9.2e+161], t$95$1, N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_1 := NdChar + t_0\\
\mathbf{if}\;KbT \leq -5.4 \cdot 10^{+194}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\
\mathbf{elif}\;KbT \leq -2.3 \cdot 10^{+131}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;KbT \leq -3 \cdot 10^{+42}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;KbT \leq -6.2 \cdot 10^{-189}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;KbT \leq 9.2 \cdot 10^{+161}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
\end{array}
\end{array}
if KbT < -5.4000000000000003e194Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EDonor around inf 86.7%
Taylor expanded in KbT around inf 67.5%
if -5.4000000000000003e194 < KbT < -2.29999999999999992e131 or -3.00000000000000029e42 < KbT < -6.2000000000000001e-189Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 59.0%
Taylor expanded in EDonor around inf 45.2%
associate-/l*43.7%
Simplified43.7%
Taylor expanded in KbT around 0 81.5%
if -2.29999999999999992e131 < KbT < -3.00000000000000029e42 or -6.2000000000000001e-189 < KbT < 9.1999999999999997e161Initial 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 40.8%
Taylor expanded in Ec around inf 48.0%
neg-mul-148.0%
distribute-neg-frac48.0%
Simplified48.0%
Taylor expanded in Ec around 0 72.6%
if 9.1999999999999997e161 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 83.2%
Taylor expanded in Ec around inf 81.3%
associate-*r/81.3%
mul-1-neg81.3%
Simplified81.3%
Final simplification75.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= KbT -1.32e+135)
(+ t_0 (* NdChar 0.5))
(if (<= KbT -3.6e-189)
t_0
(if (<= KbT 9.2e+161)
(+ NdChar t_0)
(+
(/ NdChar (+ 1.0 (exp (/ (+ mu (- (+ Vef EDonor) Ec)) KbT))))
(/ NaChar 2.0)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (KbT <= -1.32e+135) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= -3.6e-189) {
tmp = t_0;
} else if (KbT <= 9.2e+161) {
tmp = NdChar + t_0;
} else {
tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (kbt <= (-1.32d+135)) then
tmp = t_0 + (ndchar * 0.5d0)
else if (kbt <= (-3.6d-189)) then
tmp = t_0
else if (kbt <= 9.2d+161) then
tmp = ndchar + t_0
else
tmp = (ndchar / (1.0d0 + exp(((mu + ((vef + edonor) - ec)) / kbt)))) + (nachar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (KbT <= -1.32e+135) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= -3.6e-189) {
tmp = t_0;
} else if (KbT <= 9.2e+161) {
tmp = NdChar + t_0;
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if KbT <= -1.32e+135: tmp = t_0 + (NdChar * 0.5) elif KbT <= -3.6e-189: tmp = t_0 elif KbT <= 9.2e+161: tmp = NdChar + t_0 else: tmp = (NdChar / (1.0 + math.exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (KbT <= -1.32e+135) tmp = Float64(t_0 + Float64(NdChar * 0.5)); elseif (KbT <= -3.6e-189) tmp = t_0; elseif (KbT <= 9.2e+161) tmp = Float64(NdChar + t_0); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(Float64(Vef + EDonor) - Ec)) / KbT)))) + Float64(NaChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (KbT <= -1.32e+135) tmp = t_0 + (NdChar * 0.5); elseif (KbT <= -3.6e-189) tmp = t_0; elseif (KbT <= 9.2e+161) tmp = NdChar + t_0; else tmp = (NdChar / (1.0 + exp(((mu + ((Vef + EDonor) - Ec)) / KbT)))) + (NaChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.32e+135], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -3.6e-189], t$95$0, If[LessEqual[KbT, 9.2e+161], N[(NdChar + t$95$0), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(N[(Vef + EDonor), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;KbT \leq -1.32 \cdot 10^{+135}:\\
\;\;\;\;t_0 + NdChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq -3.6 \cdot 10^{-189}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;KbT \leq 9.2 \cdot 10^{+161}:\\
\;\;\;\;NdChar + t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(\left(Vef + EDonor\right) - Ec\right)}{KbT}}} + \frac{NaChar}{2}\\
\end{array}
\end{array}
if KbT < -1.32e135Initial 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 77.7%
Taylor expanded in KbT around inf 79.8%
if -1.32e135 < KbT < -3.60000000000000017e-189Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 53.6%
Taylor expanded in EDonor around inf 40.4%
associate-/l*38.9%
Simplified38.9%
Taylor expanded in KbT around 0 76.0%
if -3.60000000000000017e-189 < KbT < 9.1999999999999997e161Initial 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 37.7%
Taylor expanded in Ec around inf 44.2%
neg-mul-144.2%
distribute-neg-frac44.2%
Simplified44.2%
Taylor expanded in Ec around 0 69.6%
if 9.1999999999999997e161 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 83.2%
Final simplification74.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= KbT -1.1e+135)
(+ t_0 (* NdChar 0.5))
(if (<= KbT -2.6e-188)
t_0
(if (<= KbT 9.2e+161)
(+ NdChar t_0)
(+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (KbT <= -1.1e+135) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= -2.6e-188) {
tmp = t_0;
} else if (KbT <= 9.2e+161) {
tmp = NdChar + t_0;
} else {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (kbt <= (-1.1d+135)) then
tmp = t_0 + (ndchar * 0.5d0)
else if (kbt <= (-2.6d-188)) then
tmp = t_0
else if (kbt <= 9.2d+161) then
tmp = ndchar + t_0
else
tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + exp((-ec / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (KbT <= -1.1e+135) {
tmp = t_0 + (NdChar * 0.5);
} else if (KbT <= -2.6e-188) {
tmp = t_0;
} else if (KbT <= 9.2e+161) {
tmp = NdChar + t_0;
} else {
tmp = (NaChar / 2.0) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if KbT <= -1.1e+135: tmp = t_0 + (NdChar * 0.5) elif KbT <= -2.6e-188: tmp = t_0 elif KbT <= 9.2e+161: tmp = NdChar + t_0 else: tmp = (NaChar / 2.0) + (NdChar / (1.0 + math.exp((-Ec / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (KbT <= -1.1e+135) tmp = Float64(t_0 + Float64(NdChar * 0.5)); elseif (KbT <= -2.6e-188) tmp = t_0; elseif (KbT <= 9.2e+161) tmp = Float64(NdChar + t_0); else tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (KbT <= -1.1e+135) tmp = t_0 + (NdChar * 0.5); elseif (KbT <= -2.6e-188) tmp = t_0; elseif (KbT <= 9.2e+161) tmp = NdChar + t_0; else tmp = (NaChar / 2.0) + (NdChar / (1.0 + exp((-Ec / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.1e+135], N[(t$95$0 + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, -2.6e-188], t$95$0, If[LessEqual[KbT, 9.2e+161], N[(NdChar + t$95$0), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;KbT \leq -1.1 \cdot 10^{+135}:\\
\;\;\;\;t_0 + NdChar \cdot 0.5\\
\mathbf{elif}\;KbT \leq -2.6 \cdot 10^{-188}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;KbT \leq 9.2 \cdot 10^{+161}:\\
\;\;\;\;NdChar + t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
\end{array}
\end{array}
if KbT < -1.1e135Initial 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 77.7%
Taylor expanded in KbT around inf 79.8%
if -1.1e135 < KbT < -2.6000000000000001e-188Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 53.6%
Taylor expanded in EDonor around inf 40.4%
associate-/l*38.9%
Simplified38.9%
Taylor expanded in KbT around 0 76.0%
if -2.6000000000000001e-188 < KbT < 9.1999999999999997e161Initial 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 37.7%
Taylor expanded in Ec around inf 44.2%
neg-mul-144.2%
distribute-neg-frac44.2%
Simplified44.2%
Taylor expanded in Ec around 0 69.6%
if 9.1999999999999997e161 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 83.2%
Taylor expanded in Ec around inf 81.3%
associate-*r/81.3%
mul-1-neg81.3%
Simplified81.3%
Final simplification74.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))))))
(if (<= mu 5.6e-202)
t_0
(if (<= mu 2e-109)
(+ NdChar (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(if (<= mu 4.6e+178)
t_0
(+ NdChar (/ NaChar (+ 1.0 (exp (- (/ mu KbT)))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (mu <= 5.6e-202) {
tmp = t_0;
} else if (mu <= 2e-109) {
tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT))));
} else if (mu <= 4.6e+178) {
tmp = t_0;
} else {
tmp = NdChar + (NaChar / (1.0 + exp(-(mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (mu <= 5.6d-202) then
tmp = t_0
else if (mu <= 2d-109) then
tmp = ndchar + (nachar / (1.0d0 + exp((eaccept / kbt))))
else if (mu <= 4.6d+178) then
tmp = t_0
else
tmp = ndchar + (nachar / (1.0d0 + exp(-(mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (mu <= 5.6e-202) {
tmp = t_0;
} else if (mu <= 2e-109) {
tmp = NdChar + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else if (mu <= 4.6e+178) {
tmp = t_0;
} else {
tmp = NdChar + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if mu <= 5.6e-202: tmp = t_0 elif mu <= 2e-109: tmp = NdChar + (NaChar / (1.0 + math.exp((EAccept / KbT)))) elif mu <= 4.6e+178: tmp = t_0 else: tmp = NdChar + (NaChar / (1.0 + math.exp(-(mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (mu <= 5.6e-202) tmp = t_0; elseif (mu <= 2e-109) tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); elseif (mu <= 4.6e+178) tmp = t_0; else tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT)))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (mu <= 5.6e-202) tmp = t_0; elseif (mu <= 2e-109) tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT)))); elseif (mu <= 4.6e+178) tmp = t_0; else tmp = NdChar + (NaChar / (1.0 + exp(-(mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, 5.6e-202], t$95$0, If[LessEqual[mu, 2e-109], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 4.6e+178], t$95$0, N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;mu \leq 5.6 \cdot 10^{-202}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;mu \leq 2 \cdot 10^{-109}:\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{elif}\;mu \leq 4.6 \cdot 10^{+178}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\
\end{array}
\end{array}
if mu < 5.6000000000000002e-202 or 2e-109 < mu < 4.6000000000000002e178Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 56.2%
Taylor expanded in EDonor around inf 35.1%
associate-/l*35.6%
Simplified35.6%
Taylor expanded in KbT around 0 67.3%
if 5.6000000000000002e-202 < mu < 2e-109Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 54.3%
Taylor expanded in Ec around inf 61.6%
neg-mul-161.6%
distribute-neg-frac61.6%
Simplified61.6%
Taylor expanded in Ec around 0 79.0%
Taylor expanded in EAccept around inf 68.9%
if 4.6000000000000002e178 < mu Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 40.1%
Taylor expanded in Ec around inf 49.8%
neg-mul-149.8%
distribute-neg-frac49.8%
Simplified49.8%
Taylor expanded in Ec around 0 81.9%
Taylor expanded in mu around inf 77.1%
neg-mul-177.1%
Simplified77.1%
Final simplification68.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (or (<= mu -7.5e+142) (not (<= mu 3.6e+46))) (+ NdChar (/ NaChar (+ 1.0 (exp (- (/ mu KbT)))))) (+ NdChar (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((mu <= -7.5e+142) || !(mu <= 3.6e+46)) {
tmp = NdChar + (NaChar / (1.0 + exp(-(mu / KbT))));
} else {
tmp = NdChar + (NaChar / (1.0 + exp((Vef / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((mu <= (-7.5d+142)) .or. (.not. (mu <= 3.6d+46))) then
tmp = ndchar + (nachar / (1.0d0 + exp(-(mu / kbt))))
else
tmp = ndchar + (nachar / (1.0d0 + exp((vef / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((mu <= -7.5e+142) || !(mu <= 3.6e+46)) {
tmp = NdChar + (NaChar / (1.0 + Math.exp(-(mu / KbT))));
} else {
tmp = NdChar + (NaChar / (1.0 + Math.exp((Vef / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (mu <= -7.5e+142) or not (mu <= 3.6e+46): tmp = NdChar + (NaChar / (1.0 + math.exp(-(mu / KbT)))) else: tmp = NdChar + (NaChar / (1.0 + math.exp((Vef / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((mu <= -7.5e+142) || !(mu <= 3.6e+46)) tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(-Float64(mu / KbT)))))); else tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((mu <= -7.5e+142) || ~((mu <= 3.6e+46))) tmp = NdChar + (NaChar / (1.0 + exp(-(mu / KbT)))); else tmp = NdChar + (NaChar / (1.0 + exp((Vef / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[mu, -7.5e+142], N[Not[LessEqual[mu, 3.6e+46]], $MachinePrecision]], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[(-N[(mu / KbT), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;mu \leq -7.5 \cdot 10^{+142} \lor \neg \left(mu \leq 3.6 \cdot 10^{+46}\right):\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{-\frac{mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\
\end{array}
\end{array}
if mu < -7.5000000000000002e142 or 3.5999999999999999e46 < mu Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 42.3%
Taylor expanded in Ec around inf 54.4%
neg-mul-154.4%
distribute-neg-frac54.4%
Simplified54.4%
Taylor expanded in Ec around 0 74.9%
Taylor expanded in mu around inf 67.8%
neg-mul-167.8%
Simplified67.8%
if -7.5000000000000002e142 < mu < 3.5999999999999999e46Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.4%
Taylor expanded in Ec around inf 51.9%
neg-mul-151.9%
distribute-neg-frac51.9%
Simplified51.9%
Taylor expanded in Ec around 0 60.4%
Taylor expanded in Vef around inf 49.1%
Final simplification55.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= Ev -4e+223)
(+
(/
NdChar
(+
1.0
(- (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ Ec KbT))))
(/
NaChar
(- (+ (/ Ev KbT) (+ (/ EAccept KbT) (+ 2.0 (/ Vef KbT)))) (/ mu KbT))))
(+ NdChar (/ 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 tmp;
if (Ev <= -4e+223) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / (((Ev / KbT) + ((EAccept / KbT) + (2.0 + (Vef / KbT)))) - (mu / KbT)));
} else {
tmp = NdChar + (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) :: tmp
if (ev <= (-4d+223)) then
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))) + (nachar / (((ev / kbt) + ((eaccept / kbt) + (2.0d0 + (vef / kbt)))) - (mu / kbt)))
else
tmp = ndchar + (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 tmp;
if (Ev <= -4e+223) {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / (((Ev / KbT) + ((EAccept / KbT) + (2.0 + (Vef / KbT)))) - (mu / KbT)));
} else {
tmp = NdChar + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if Ev <= -4e+223: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / (((Ev / KbT) + ((EAccept / KbT) + (2.0 + (Vef / KbT)))) - (mu / KbT))) else: tmp = NdChar + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (Ev <= -4e+223) tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT)))) + Float64(NaChar / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(2.0 + Float64(Vef / KbT)))) - Float64(mu / KbT)))); else tmp = Float64(NdChar + 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) tmp = 0.0; if (Ev <= -4e+223) tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / (((Ev / KbT) + ((EAccept / KbT) + (2.0 + (Vef / KbT)))) - (mu / KbT))); else tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -4e+223], N[(N[(NdChar / N[(1.0 + N[(N[(N[(mu / KbT), $MachinePrecision] + N[(1.0 + N[(N[(Vef / KbT), $MachinePrecision] + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(2.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;Ev \leq -4 \cdot 10^{+223}:\\
\;\;\;\;\frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(2 + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\
\mathbf{else}:\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if Ev < -4.00000000000000019e223Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 60.4%
Taylor expanded in KbT around inf 27.8%
if -4.00000000000000019e223 < Ev Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 53.1%
Taylor expanded in Ec around inf 54.5%
neg-mul-154.5%
distribute-neg-frac54.5%
Simplified54.5%
Taylor expanded in Ec around 0 68.3%
Taylor expanded in EAccept around inf 49.0%
Final simplification47.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (<= Ev -9.8e+35) (+ NdChar (/ NaChar (+ 1.0 (exp (/ Ev KbT))))) (+ NdChar (/ 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 tmp;
if (Ev <= -9.8e+35) {
tmp = NdChar + (NaChar / (1.0 + exp((Ev / KbT))));
} else {
tmp = NdChar + (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) :: tmp
if (ev <= (-9.8d+35)) then
tmp = ndchar + (nachar / (1.0d0 + exp((ev / kbt))))
else
tmp = ndchar + (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 tmp;
if (Ev <= -9.8e+35) {
tmp = NdChar + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else {
tmp = NdChar + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if Ev <= -9.8e+35: tmp = NdChar + (NaChar / (1.0 + math.exp((Ev / KbT)))) else: tmp = NdChar + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (Ev <= -9.8e+35) tmp = Float64(NdChar + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); else tmp = Float64(NdChar + 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) tmp = 0.0; if (Ev <= -9.8e+35) tmp = NdChar + (NaChar / (1.0 + exp((Ev / KbT)))); else tmp = NdChar + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Ev, -9.8e+35], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(NdChar + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;Ev \leq -9.8 \cdot 10^{+35}:\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if Ev < -9.8000000000000005e35Initial 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 49.0%
Taylor expanded in Ec around inf 50.6%
neg-mul-150.6%
distribute-neg-frac50.6%
Simplified50.6%
Taylor expanded in Ec around 0 55.1%
Taylor expanded in Ev around inf 46.1%
if -9.8000000000000005e35 < Ev Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 55.3%
Taylor expanded in Ec around inf 53.5%
neg-mul-153.5%
distribute-neg-frac53.5%
Simplified53.5%
Taylor expanded in Ec around 0 68.9%
Taylor expanded in EAccept around inf 50.6%
Final simplification49.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -2.7e+180)
(+ (* NdChar 0.5) (/ NaChar 2.0))
(if (<= KbT 9.2e+161)
(+
NdChar
(/
NaChar
(- (+ (/ Ev KbT) (+ (/ EAccept KbT) (+ 2.0 (/ Vef KbT)))) (/ mu KbT))))
(+ (/ NaChar 2.0) (/ NdChar (+ 2.0 (/ EDonor KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -2.7e+180) {
tmp = (NdChar * 0.5) + (NaChar / 2.0);
} else if (KbT <= 9.2e+161) {
tmp = NdChar + (NaChar / (((Ev / KbT) + ((EAccept / KbT) + (2.0 + (Vef / KbT)))) - (mu / KbT)));
} else {
tmp = (NaChar / 2.0) + (NdChar / (2.0 + (EDonor / KbT)));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-2.7d+180)) then
tmp = (ndchar * 0.5d0) + (nachar / 2.0d0)
else if (kbt <= 9.2d+161) then
tmp = ndchar + (nachar / (((ev / kbt) + ((eaccept / kbt) + (2.0d0 + (vef / kbt)))) - (mu / kbt)))
else
tmp = (nachar / 2.0d0) + (ndchar / (2.0d0 + (edonor / kbt)))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -2.7e+180) {
tmp = (NdChar * 0.5) + (NaChar / 2.0);
} else if (KbT <= 9.2e+161) {
tmp = NdChar + (NaChar / (((Ev / KbT) + ((EAccept / KbT) + (2.0 + (Vef / KbT)))) - (mu / KbT)));
} else {
tmp = (NaChar / 2.0) + (NdChar / (2.0 + (EDonor / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -2.7e+180: tmp = (NdChar * 0.5) + (NaChar / 2.0) elif KbT <= 9.2e+161: tmp = NdChar + (NaChar / (((Ev / KbT) + ((EAccept / KbT) + (2.0 + (Vef / KbT)))) - (mu / KbT))) else: tmp = (NaChar / 2.0) + (NdChar / (2.0 + (EDonor / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -2.7e+180) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / 2.0)); elseif (KbT <= 9.2e+161) tmp = Float64(NdChar + Float64(NaChar / Float64(Float64(Float64(Ev / KbT) + Float64(Float64(EAccept / KbT) + Float64(2.0 + Float64(Vef / KbT)))) - Float64(mu / KbT)))); else tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(2.0 + Float64(EDonor / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -2.7e+180) tmp = (NdChar * 0.5) + (NaChar / 2.0); elseif (KbT <= 9.2e+161) tmp = NdChar + (NaChar / (((Ev / KbT) + ((EAccept / KbT) + (2.0 + (Vef / KbT)))) - (mu / KbT))); else tmp = (NaChar / 2.0) + (NdChar / (2.0 + (EDonor / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.7e+180], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 9.2e+161], N[(NdChar + N[(NaChar / N[(N[(N[(Ev / KbT), $MachinePrecision] + N[(N[(EAccept / KbT), $MachinePrecision] + N[(2.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -2.7 \cdot 10^{+180}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\
\mathbf{elif}\;KbT \leq 9.2 \cdot 10^{+161}:\\
\;\;\;\;NdChar + \frac{NaChar}{\left(\frac{Ev}{KbT} + \left(\frac{EAccept}{KbT} + \left(2 + \frac{Vef}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{2 + \frac{EDonor}{KbT}}\\
\end{array}
\end{array}
if KbT < -2.70000000000000016e180Initial 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 75.6%
Taylor expanded in KbT around inf 56.7%
Taylor expanded in KbT around inf 58.7%
if -2.70000000000000016e180 < KbT < 9.1999999999999997e161Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 45.8%
Taylor expanded in Ec around inf 51.3%
neg-mul-151.3%
distribute-neg-frac51.3%
Simplified51.3%
Taylor expanded in Ec around 0 67.3%
Taylor expanded in KbT around inf 34.9%
if 9.1999999999999997e161 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EDonor around inf 82.5%
Taylor expanded in KbT around inf 72.9%
Taylor expanded in EDonor around 0 72.4%
+-commutative72.4%
Simplified72.4%
Final simplification42.2%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= KbT -2.2e+186)
(+ (* NdChar 0.5) (/ NaChar 2.0))
(if (<= KbT 1.45e+147)
(+ NdChar (/ NaChar 2.0))
(+ (/ NaChar 2.0) (/ NdChar (+ 2.0 (/ EDonor KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -2.2e+186) {
tmp = (NdChar * 0.5) + (NaChar / 2.0);
} else if (KbT <= 1.45e+147) {
tmp = NdChar + (NaChar / 2.0);
} else {
tmp = (NaChar / 2.0) + (NdChar / (2.0 + (EDonor / KbT)));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= (-2.2d+186)) then
tmp = (ndchar * 0.5d0) + (nachar / 2.0d0)
else if (kbt <= 1.45d+147) then
tmp = ndchar + (nachar / 2.0d0)
else
tmp = (nachar / 2.0d0) + (ndchar / (2.0d0 + (edonor / kbt)))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= -2.2e+186) {
tmp = (NdChar * 0.5) + (NaChar / 2.0);
} else if (KbT <= 1.45e+147) {
tmp = NdChar + (NaChar / 2.0);
} else {
tmp = (NaChar / 2.0) + (NdChar / (2.0 + (EDonor / KbT)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= -2.2e+186: tmp = (NdChar * 0.5) + (NaChar / 2.0) elif KbT <= 1.45e+147: tmp = NdChar + (NaChar / 2.0) else: tmp = (NaChar / 2.0) + (NdChar / (2.0 + (EDonor / KbT))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= -2.2e+186) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / 2.0)); elseif (KbT <= 1.45e+147) tmp = Float64(NdChar + Float64(NaChar / 2.0)); else tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(2.0 + Float64(EDonor / KbT)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= -2.2e+186) tmp = (NdChar * 0.5) + (NaChar / 2.0); elseif (KbT <= 1.45e+147) tmp = NdChar + (NaChar / 2.0); else tmp = (NaChar / 2.0) + (NdChar / (2.0 + (EDonor / KbT))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -2.2e+186], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.45e+147], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(2.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -2.2 \cdot 10^{+186}:\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\
\mathbf{elif}\;KbT \leq 1.45 \cdot 10^{+147}:\\
\;\;\;\;NdChar + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{2 + \frac{EDonor}{KbT}}\\
\end{array}
\end{array}
if KbT < -2.1999999999999998e186Initial 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 74.9%
Taylor expanded in KbT around inf 57.8%
Taylor expanded in KbT around inf 59.8%
if -2.1999999999999998e186 < KbT < 1.4499999999999999e147Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 46.8%
Taylor expanded in KbT around inf 12.0%
Taylor expanded in mu around inf 19.3%
Taylor expanded in mu around 0 34.6%
if 1.4499999999999999e147 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EDonor around inf 78.3%
Taylor expanded in KbT around inf 65.9%
Taylor expanded in EDonor around 0 65.5%
+-commutative65.5%
Simplified65.5%
Final simplification41.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (or (<= KbT -6.5e+185) (not (<= KbT 8e+146))) (+ (* NdChar 0.5) (/ NaChar 2.0)) (+ NdChar (/ NaChar 2.0))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((KbT <= -6.5e+185) || !(KbT <= 8e+146)) {
tmp = (NdChar * 0.5) + (NaChar / 2.0);
} else {
tmp = NdChar + (NaChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((kbt <= (-6.5d+185)) .or. (.not. (kbt <= 8d+146))) then
tmp = (ndchar * 0.5d0) + (nachar / 2.0d0)
else
tmp = ndchar + (nachar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((KbT <= -6.5e+185) || !(KbT <= 8e+146)) {
tmp = (NdChar * 0.5) + (NaChar / 2.0);
} else {
tmp = NdChar + (NaChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (KbT <= -6.5e+185) or not (KbT <= 8e+146): tmp = (NdChar * 0.5) + (NaChar / 2.0) else: tmp = NdChar + (NaChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((KbT <= -6.5e+185) || !(KbT <= 8e+146)) tmp = Float64(Float64(NdChar * 0.5) + Float64(NaChar / 2.0)); else tmp = Float64(NdChar + Float64(NaChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((KbT <= -6.5e+185) || ~((KbT <= 8e+146))) tmp = (NdChar * 0.5) + (NaChar / 2.0); else tmp = NdChar + (NaChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -6.5e+185], N[Not[LessEqual[KbT, 8e+146]], $MachinePrecision]], N[(N[(NdChar * 0.5), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq -6.5 \cdot 10^{+185} \lor \neg \left(KbT \leq 8 \cdot 10^{+146}\right):\\
\;\;\;\;NdChar \cdot 0.5 + \frac{NaChar}{2}\\
\mathbf{else}:\\
\;\;\;\;NdChar + \frac{NaChar}{2}\\
\end{array}
\end{array}
if KbT < -6.5000000000000002e185 or 7.99999999999999947e146 < KbT Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 74.4%
Taylor expanded in KbT around inf 61.1%
Taylor expanded in KbT around inf 61.9%
if -6.5000000000000002e185 < KbT < 7.99999999999999947e146Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 46.8%
Taylor expanded in KbT around inf 12.0%
Taylor expanded in mu around inf 19.3%
Taylor expanded in mu around 0 34.6%
Final simplification41.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ NdChar (/ NaChar 2.0)))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NdChar + (NaChar / 2.0);
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = ndchar + (nachar / 2.0d0)
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NdChar + (NaChar / 2.0);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return NdChar + (NaChar / 2.0)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(NdChar + Float64(NaChar / 2.0)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = NdChar + (NaChar / 2.0); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
NdChar + \frac{NaChar}{2}
\end{array}
Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 53.8%
Taylor expanded in KbT around inf 24.5%
Taylor expanded in mu around inf 25.5%
Taylor expanded in mu around 0 37.3%
Final simplification37.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (* NaChar 0.5))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NaChar * 0.5;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = nachar * 0.5d0
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return NaChar * 0.5;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return NaChar * 0.5
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(NaChar * 0.5) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = NaChar * 0.5; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NaChar * 0.5), $MachinePrecision]
\begin{array}{l}
\\
NaChar \cdot 0.5
\end{array}
Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 53.8%
Taylor expanded in KbT around inf 24.5%
Taylor expanded in mu around inf 25.5%
Taylor expanded in NdChar around 0 19.2%
Final simplification19.2%
herbie shell --seed 2023238
(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))))))