
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 27 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT))))) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT)))); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}}
\end{array}
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) 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 - (Ec - (Vef + EDonor))) / 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 - (ec - (vef + edonor))) / 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 - (Ec - (Vef + EDonor))) / 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 - (Ec - (Vef + EDonor))) / 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(Ec - Float64(Vef + EDonor))) / 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 - (Ec - (Vef + EDonor))) / 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[(Ec - N[(Vef + EDonor), $MachinePrecision]), $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(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))))
(t_1 (/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT)))))
(t_2
(+
(/ NdChar (+ 1.0 (exp (/ Vef KbT))))
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))))
(if (<= Vef -3.1e+32)
t_2
(if (<= Vef -28.5)
(+ t_1 (* NaChar 0.5))
(if (<= Vef -1.36e-43)
t_0
(if (<= Vef -1e-87)
(+
t_1
(/
NaChar
(+
1.0
(+
(* 0.5 (/ (* EAccept EAccept) (* KbT KbT)))
(+ 1.0 (/ EAccept KbT))))))
(if (<= Vef -2.9e-302)
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT)))))
(if (<= Vef 1.5e-275)
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(if (<= Vef 1.95e-131) t_0 t_2)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
double t_1 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_2 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
double tmp;
if (Vef <= -3.1e+32) {
tmp = t_2;
} else if (Vef <= -28.5) {
tmp = t_1 + (NaChar * 0.5);
} else if (Vef <= -1.36e-43) {
tmp = t_0;
} else if (Vef <= -1e-87) {
tmp = t_1 + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT)))));
} else if (Vef <= -2.9e-302) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else if (Vef <= 1.5e-275) {
tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
} else if (Vef <= 1.95e-131) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((-ec / kbt))))
t_1 = ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))
t_2 = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
if (vef <= (-3.1d+32)) then
tmp = t_2
else if (vef <= (-28.5d0)) then
tmp = t_1 + (nachar * 0.5d0)
else if (vef <= (-1.36d-43)) then
tmp = t_0
else if (vef <= (-1d-87)) then
tmp = t_1 + (nachar / (1.0d0 + ((0.5d0 * ((eaccept * eaccept) / (kbt * kbt))) + (1.0d0 + (eaccept / kbt)))))
else if (vef <= (-2.9d-302)) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
else if (vef <= 1.5d-275) then
tmp = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
else if (vef <= 1.95d-131) then
tmp = t_0
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
double t_1 = NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_2 = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
double tmp;
if (Vef <= -3.1e+32) {
tmp = t_2;
} else if (Vef <= -28.5) {
tmp = t_1 + (NaChar * 0.5);
} else if (Vef <= -1.36e-43) {
tmp = t_0;
} else if (Vef <= -1e-87) {
tmp = t_1 + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT)))));
} else if (Vef <= -2.9e-302) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else if (Vef <= 1.5e-275) {
tmp = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
} else if (Vef <= 1.95e-131) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((-Ec / KbT)))) t_1 = NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT))) t_2 = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT)))) tmp = 0 if Vef <= -3.1e+32: tmp = t_2 elif Vef <= -28.5: tmp = t_1 + (NaChar * 0.5) elif Vef <= -1.36e-43: tmp = t_0 elif Vef <= -1e-87: tmp = t_1 + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT))))) elif Vef <= -2.9e-302: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) elif Vef <= 1.5e-275: tmp = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) elif Vef <= 1.95e-131: tmp = t_0 else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT))))) t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) t_2 = 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+32) tmp = t_2; elseif (Vef <= -28.5) tmp = Float64(t_1 + Float64(NaChar * 0.5)); elseif (Vef <= -1.36e-43) tmp = t_0; elseif (Vef <= -1e-87) tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + Float64(Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT))) + Float64(1.0 + Float64(EAccept / KbT)))))); elseif (Vef <= -2.9e-302) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))))); elseif (Vef <= 1.5e-275) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); elseif (Vef <= 1.95e-131) tmp = t_0; else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT)))); t_1 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT))); t_2 = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT)))); tmp = 0.0; if (Vef <= -3.1e+32) tmp = t_2; elseif (Vef <= -28.5) tmp = t_1 + (NaChar * 0.5); elseif (Vef <= -1.36e-43) tmp = t_0; elseif (Vef <= -1e-87) tmp = t_1 + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT))))); elseif (Vef <= -2.9e-302) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))); elseif (Vef <= 1.5e-275) tmp = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); elseif (Vef <= 1.95e-131) tmp = t_0; else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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+32], t$95$2, If[LessEqual[Vef, -28.5], N[(t$95$1 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -1.36e-43], t$95$0, If[LessEqual[Vef, -1e-87], N[(t$95$1 + N[(NaChar / N[(1.0 + N[(N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, -2.9e-302], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(N[(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]), $MachinePrecision], If[LessEqual[Vef, 1.5e-275], N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 1.95e-131], t$95$0, t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\
t_1 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}}\\
t_2 := \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^{+32}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;Vef \leq -28.5:\\
\;\;\;\;t_1 + NaChar \cdot 0.5\\
\mathbf{elif}\;Vef \leq -1.36 \cdot 10^{-43}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;Vef \leq -1 \cdot 10^{-87}:\\
\;\;\;\;t_1 + \frac{NaChar}{1 + \left(0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT} + \left(1 + \frac{EAccept}{KbT}\right)\right)}\\
\mathbf{elif}\;Vef \leq -2.9 \cdot 10^{-302}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\
\mathbf{elif}\;Vef \leq 1.5 \cdot 10^{-275}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{elif}\;Vef \leq 1.95 \cdot 10^{-131}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if Vef < -3.09999999999999993e32 or 1.9500000000000001e-131 < 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 82.4%
Taylor expanded in EAccept around 0 79.1%
if -3.09999999999999993e32 < Vef < -28.5Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in KbT around inf 82.0%
*-commutative82.0%
Simplified82.0%
if -28.5 < Vef < -1.36000000000000007e-43 or 1.5e-275 < Vef < 1.9500000000000001e-131Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 73.7%
Taylor expanded in Ec around inf 68.0%
associate-*r/68.0%
mul-1-neg68.0%
Simplified68.0%
if -1.36000000000000007e-43 < Vef < -1.00000000000000002e-87Initial program 99.4%
neg-sub099.4%
associate--r-99.4%
+-commutative99.4%
neg-sub099.4%
sub-neg99.4%
associate--l-99.4%
unsub-neg99.4%
+-commutative99.4%
associate-+l+99.4%
Simplified99.4%
Taylor expanded in EAccept around inf 73.7%
Taylor expanded in EAccept around 0 53.7%
associate-+r+53.7%
+-commutative53.7%
unpow253.7%
unpow253.7%
Simplified53.7%
if -1.00000000000000002e-87 < Vef < -2.89999999999999994e-302Initial 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 70.2%
if -2.89999999999999994e-302 < Vef < 1.5e-275Initial 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 mu around inf 83.8%
Taylor expanded in mu around inf 76.4%
neg-mul-176.4%
distribute-neg-frac76.4%
Simplified76.4%
Final simplification74.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT))))))
(t_1
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
(if (<= mu -6.5e+164)
t_0
(if (<= mu -5.2e-162)
t_1
(if (<= mu -5.8e-209)
(+
(/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))
(/
NaChar
(+
1.0
(+
(* 0.5 (/ (* EAccept EAccept) (* KbT KbT)))
(+ 1.0 (/ EAccept KbT))))))
(if (<= mu 1.8e-46)
t_1
(if (<= mu 6.8e+22)
(+
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= mu 2.3e+139) t_1 t_0))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
double t_1 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((Vef / KbT))));
double tmp;
if (mu <= -6.5e+164) {
tmp = t_0;
} else if (mu <= -5.2e-162) {
tmp = t_1;
} else if (mu <= -5.8e-209) {
tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT)))));
} else if (mu <= 1.8e-46) {
tmp = t_1;
} else if (mu <= 6.8e+22) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (mu <= 2.3e+139) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
t_1 = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (1.0d0 + exp((vef / kbt))))
if (mu <= (-6.5d+164)) then
tmp = t_0
else if (mu <= (-5.2d-162)) then
tmp = t_1
else if (mu <= (-5.8d-209)) then
tmp = (ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))) + (nachar / (1.0d0 + ((0.5d0 * ((eaccept * eaccept) / (kbt * kbt))) + (1.0d0 + (eaccept / kbt)))))
else if (mu <= 1.8d-46) then
tmp = t_1
else if (mu <= 6.8d+22) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (mu <= 2.3d+139) then
tmp = t_1
else
tmp = t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
double t_1 = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp((Vef / KbT))));
double tmp;
if (mu <= -6.5e+164) {
tmp = t_0;
} else if (mu <= -5.2e-162) {
tmp = t_1;
} else if (mu <= -5.8e-209) {
tmp = (NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT)))));
} else if (mu <= 1.8e-46) {
tmp = t_1;
} else if (mu <= 6.8e+22) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (mu <= 2.3e+139) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) t_1 = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp((Vef / KbT)))) tmp = 0 if mu <= -6.5e+164: tmp = t_0 elif mu <= -5.2e-162: tmp = t_1 elif mu <= -5.8e-209: tmp = (NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT))))) elif mu <= 1.8e-46: tmp = t_1 elif mu <= 6.8e+22: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif mu <= 2.3e+139: tmp = t_1 else: tmp = t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))) t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))) tmp = 0.0 if (mu <= -6.5e+164) tmp = t_0; elseif (mu <= -5.2e-162) tmp = t_1; elseif (mu <= -5.8e-209) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT))) + Float64(1.0 + Float64(EAccept / KbT)))))); elseif (mu <= 1.8e-46) tmp = t_1; elseif (mu <= 6.8e+22) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (mu <= 2.3e+139) tmp = t_1; else tmp = t_0; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); t_1 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + exp((Vef / KbT)))); tmp = 0.0; if (mu <= -6.5e+164) tmp = t_0; elseif (mu <= -5.2e-162) tmp = t_1; elseif (mu <= -5.8e-209) tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT))))); elseif (mu <= 1.8e-46) tmp = t_1; elseif (mu <= 6.8e+22) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (mu <= 2.3e+139) tmp = t_1; else tmp = t_0; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -6.5e+164], t$95$0, If[LessEqual[mu, -5.2e-162], t$95$1, If[LessEqual[mu, -5.8e-209], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.8e-46], t$95$1, If[LessEqual[mu, 6.8e+22], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.3e+139], t$95$1, t$95$0]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;mu \leq -6.5 \cdot 10^{+164}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;mu \leq -5.2 \cdot 10^{-162}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;mu \leq -5.8 \cdot 10^{-209}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT} + \left(1 + \frac{EAccept}{KbT}\right)\right)}\\
\mathbf{elif}\;mu \leq 1.8 \cdot 10^{-46}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;mu \leq 6.8 \cdot 10^{+22}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;mu \leq 2.3 \cdot 10^{+139}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if mu < -6.5000000000000003e164 or 2.3e139 < 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 92.8%
Taylor expanded in mu around inf 86.0%
neg-mul-186.0%
distribute-neg-frac86.0%
Simplified86.0%
if -6.5000000000000003e164 < mu < -5.1999999999999999e-162 or -5.80000000000000052e-209 < mu < 1.8e-46 or 6.8e22 < mu < 2.3e139Initial 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 76.9%
if -5.1999999999999999e-162 < mu < -5.80000000000000052e-209Initial 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 87.1%
Taylor expanded in EAccept around 0 78.0%
associate-+r+78.0%
+-commutative78.0%
unpow278.0%
unpow278.0%
Simplified78.0%
if 1.8e-46 < mu < 6.8e22Initial program 99.7%
neg-sub099.7%
associate--r-99.7%
+-commutative99.7%
neg-sub099.7%
sub-neg99.7%
associate--l-99.7%
unsub-neg99.7%
+-commutative99.7%
associate-+l+99.7%
Simplified99.7%
Taylor expanded in Ev around inf 83.4%
Taylor expanded in EDonor around inf 74.4%
Final simplification78.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT)))))
(t_1
(+
(/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
(/ NdChar (+ 1.0 (exp (/ mu KbT))))))
(t_2 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_3
(+
t_2
(/
NdChar
(+ 1.0 (+ (+ 1.0 (/ mu KbT)) (/ (* 0.5 (* mu mu)) (* KbT KbT))))))))
(if (<= mu -1.25e+68)
t_1
(if (<= mu -1.75e-161)
t_3
(if (<= mu -4.8e-257)
(+
t_0
(/
NaChar
(+
1.0
(+
(* 0.5 (/ (* EAccept EAccept) (* KbT KbT)))
(+ 1.0 (/ EAccept KbT))))))
(if (<= mu 2.4e-244)
(+
t_2
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT)))))
(if (<= mu 3.95e-162)
(+
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= mu 1.4e-52)
(+ t_2 (/ NdChar (+ (/ Vef KbT) 2.0)))
(if (<= mu 5.6e+34)
(+ t_0 (* NaChar (/ 1.0 (+ (/ Ev KbT) 2.0))))
(if (<= mu 4.4e+176) t_3 t_1))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_1 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
double t_2 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_3 = t_2 + (NdChar / (1.0 + ((1.0 + (mu / KbT)) + ((0.5 * (mu * mu)) / (KbT * KbT)))));
double tmp;
if (mu <= -1.25e+68) {
tmp = t_1;
} else if (mu <= -1.75e-161) {
tmp = t_3;
} else if (mu <= -4.8e-257) {
tmp = t_0 + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT)))));
} else if (mu <= 2.4e-244) {
tmp = t_2 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else if (mu <= 3.95e-162) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (mu <= 1.4e-52) {
tmp = t_2 + (NdChar / ((Vef / KbT) + 2.0));
} else if (mu <= 5.6e+34) {
tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0)));
} else if (mu <= 4.4e+176) {
tmp = t_3;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))
t_1 = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
t_2 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_3 = t_2 + (ndchar / (1.0d0 + ((1.0d0 + (mu / kbt)) + ((0.5d0 * (mu * mu)) / (kbt * kbt)))))
if (mu <= (-1.25d+68)) then
tmp = t_1
else if (mu <= (-1.75d-161)) then
tmp = t_3
else if (mu <= (-4.8d-257)) then
tmp = t_0 + (nachar / (1.0d0 + ((0.5d0 * ((eaccept * eaccept) / (kbt * kbt))) + (1.0d0 + (eaccept / kbt)))))
else if (mu <= 2.4d-244) then
tmp = t_2 + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
else if (mu <= 3.95d-162) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (mu <= 1.4d-52) then
tmp = t_2 + (ndchar / ((vef / kbt) + 2.0d0))
else if (mu <= 5.6d+34) then
tmp = t_0 + (nachar * (1.0d0 / ((ev / kbt) + 2.0d0)))
else if (mu <= 4.4d+176) then
tmp = t_3
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 = NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_1 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
double t_2 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_3 = t_2 + (NdChar / (1.0 + ((1.0 + (mu / KbT)) + ((0.5 * (mu * mu)) / (KbT * KbT)))));
double tmp;
if (mu <= -1.25e+68) {
tmp = t_1;
} else if (mu <= -1.75e-161) {
tmp = t_3;
} else if (mu <= -4.8e-257) {
tmp = t_0 + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT)))));
} else if (mu <= 2.4e-244) {
tmp = t_2 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else if (mu <= 3.95e-162) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (mu <= 1.4e-52) {
tmp = t_2 + (NdChar / ((Vef / KbT) + 2.0));
} else if (mu <= 5.6e+34) {
tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0)));
} else if (mu <= 4.4e+176) {
tmp = t_3;
} else {
tmp = t_1;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT))) t_1 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) t_2 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_3 = t_2 + (NdChar / (1.0 + ((1.0 + (mu / KbT)) + ((0.5 * (mu * mu)) / (KbT * KbT))))) tmp = 0 if mu <= -1.25e+68: tmp = t_1 elif mu <= -1.75e-161: tmp = t_3 elif mu <= -4.8e-257: tmp = t_0 + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT))))) elif mu <= 2.4e-244: tmp = t_2 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) elif mu <= 3.95e-162: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif mu <= 1.4e-52: tmp = t_2 + (NdChar / ((Vef / KbT) + 2.0)) elif mu <= 5.6e+34: tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0))) elif mu <= 4.4e+176: tmp = t_3 else: tmp = t_1 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))) t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_3 = Float64(t_2 + Float64(NdChar / Float64(1.0 + Float64(Float64(1.0 + Float64(mu / KbT)) + Float64(Float64(0.5 * Float64(mu * mu)) / Float64(KbT * KbT)))))) tmp = 0.0 if (mu <= -1.25e+68) tmp = t_1; elseif (mu <= -1.75e-161) tmp = t_3; elseif (mu <= -4.8e-257) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(Float64(0.5 * Float64(Float64(EAccept * EAccept) / Float64(KbT * KbT))) + Float64(1.0 + Float64(EAccept / KbT)))))); elseif (mu <= 2.4e-244) tmp = Float64(t_2 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))))); elseif (mu <= 3.95e-162) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (mu <= 1.4e-52) tmp = Float64(t_2 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); elseif (mu <= 5.6e+34) tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Ev / KbT) + 2.0)))); elseif (mu <= 4.4e+176) tmp = t_3; else tmp = t_1; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT))); t_1 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT)))); t_2 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_3 = t_2 + (NdChar / (1.0 + ((1.0 + (mu / KbT)) + ((0.5 * (mu * mu)) / (KbT * KbT))))); tmp = 0.0; if (mu <= -1.25e+68) tmp = t_1; elseif (mu <= -1.75e-161) tmp = t_3; elseif (mu <= -4.8e-257) tmp = t_0 + (NaChar / (1.0 + ((0.5 * ((EAccept * EAccept) / (KbT * KbT))) + (1.0 + (EAccept / KbT))))); elseif (mu <= 2.4e-244) tmp = t_2 + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))); elseif (mu <= 3.95e-162) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (mu <= 1.4e-52) tmp = t_2 + (NdChar / ((Vef / KbT) + 2.0)); elseif (mu <= 5.6e+34) tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0))); elseif (mu <= 4.4e+176) tmp = t_3; else tmp = t_1; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NdChar / N[(1.0 + N[(N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(0.5 * N[(mu * mu), $MachinePrecision]), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.25e+68], t$95$1, If[LessEqual[mu, -1.75e-161], t$95$3, If[LessEqual[mu, -4.8e-257], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(N[(0.5 * N[(N[(EAccept * EAccept), $MachinePrecision] / N[(KbT * KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.4e-244], N[(t$95$2 + 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]), $MachinePrecision], If[LessEqual[mu, 3.95e-162], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.4e-52], N[(t$95$2 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 5.6e+34], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 4.4e+176], t$95$3, t$95$1]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
t_2 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_3 := t_2 + \frac{NdChar}{1 + \left(\left(1 + \frac{mu}{KbT}\right) + \frac{0.5 \cdot \left(mu \cdot mu\right)}{KbT \cdot KbT}\right)}\\
\mathbf{if}\;mu \leq -1.25 \cdot 10^{+68}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;mu \leq -1.75 \cdot 10^{-161}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;mu \leq -4.8 \cdot 10^{-257}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(0.5 \cdot \frac{EAccept \cdot EAccept}{KbT \cdot KbT} + \left(1 + \frac{EAccept}{KbT}\right)\right)}\\
\mathbf{elif}\;mu \leq 2.4 \cdot 10^{-244}:\\
\;\;\;\;t_2 + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\
\mathbf{elif}\;mu \leq 3.95 \cdot 10^{-162}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;mu \leq 1.4 \cdot 10^{-52}:\\
\;\;\;\;t_2 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{elif}\;mu \leq 5.6 \cdot 10^{+34}:\\
\;\;\;\;t_0 + NaChar \cdot \frac{1}{\frac{Ev}{KbT} + 2}\\
\mathbf{elif}\;mu \leq 4.4 \cdot 10^{+176}:\\
\;\;\;\;t_3\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if mu < -1.2500000000000001e68 or 4.40000000000000015e176 < 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 90.1%
Taylor expanded in mu around inf 81.7%
neg-mul-181.7%
distribute-neg-frac81.7%
Simplified81.7%
if -1.2500000000000001e68 < mu < -1.7500000000000001e-161 or 5.60000000000000016e34 < mu < 4.40000000000000015e176Initial 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 67.6%
Taylor expanded in mu around 0 67.8%
associate-+r+67.8%
+-commutative67.8%
associate-*r/67.8%
unpow267.8%
unpow267.8%
Simplified67.8%
if -1.7500000000000001e-161 < mu < -4.80000000000000033e-257Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 82.2%
Taylor expanded in EAccept around 0 81.8%
associate-+r+81.8%
+-commutative81.8%
unpow281.8%
unpow281.8%
Simplified81.8%
if -4.80000000000000033e-257 < mu < 2.40000000000000016e-244Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 65.7%
if 2.40000000000000016e-244 < mu < 3.9500000000000001e-162Initial 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 Ev around inf 82.5%
Taylor expanded in EDonor around inf 75.2%
if 3.9500000000000001e-162 < mu < 1.39999999999999997e-52Initial 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 83.5%
Taylor expanded in Vef around 0 78.7%
if 1.39999999999999997e-52 < mu < 5.60000000000000016e34Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in Ev around inf 83.0%
Taylor expanded in Ev around 0 79.2%
clear-num79.2%
associate-/r/79.2%
+-commutative79.2%
associate-+r+79.2%
metadata-eval79.2%
Applied egg-rr79.2%
Final simplification75.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))))
(if (<= EAccept 1.3e-36)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= EAccept 5.1e+51)
(+
(/ NdChar (+ 1.0 (exp (/ Vef KbT))))
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef Ev) mu) KbT)))))
(if (or (<= EAccept 9.2e+72) (not (<= EAccept 4.2e+122)))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ 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 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double tmp;
if (EAccept <= 1.3e-36) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (EAccept <= 5.1e+51) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT))));
} else if ((EAccept <= 9.2e+72) || !(EAccept <= 4.2e+122)) {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
} else {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (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 = ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))
if (eaccept <= 1.3d-36) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (eaccept <= 5.1d+51) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((((vef + ev) - mu) / kbt))))
else if ((eaccept <= 9.2d+72) .or. (.not. (eaccept <= 4.2d+122))) then
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
else
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / (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 = NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double tmp;
if (EAccept <= 1.3e-36) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (EAccept <= 5.1e+51) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((((Vef + Ev) - mu) / KbT))));
} else if ((EAccept <= 9.2e+72) || !(EAccept <= 4.2e+122)) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
} else {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT))) tmp = 0 if EAccept <= 1.3e-36: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif EAccept <= 5.1e+51: tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((((Vef + Ev) - mu) / KbT)))) elif (EAccept <= 9.2e+72) or not (EAccept <= 4.2e+122): tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) else: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) tmp = 0.0 if (EAccept <= 1.3e-36) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (EAccept <= 5.1e+51) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Ev) - mu) / KbT))))); elseif ((EAccept <= 9.2e+72) || !(EAccept <= 4.2e+122)) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT))); tmp = 0.0; if (EAccept <= 1.3e-36) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (EAccept <= 5.1e+51) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((((Vef + Ev) - mu) / KbT)))); elseif ((EAccept <= 9.2e+72) || ~((EAccept <= 4.2e+122))) tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); else tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / (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[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, 1.3e-36], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 5.1e+51], 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[Or[LessEqual[EAccept, 9.2e+72], N[Not[LessEqual[EAccept, 4.2e+122]], $MachinePrecision]], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}}\\
\mathbf{if}\;EAccept \leq 1.3 \cdot 10^{-36}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 5.1 \cdot 10^{+51}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(Vef + Ev\right) - mu}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 9.2 \cdot 10^{+72} \lor \neg \left(EAccept \leq 4.2 \cdot 10^{+122}\right):\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\end{array}
\end{array}
if EAccept < 1.3e-36Initial 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 Ev around inf 73.5%
if 1.3e-36 < EAccept < 5.1000000000000001e51Initial 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 67.0%
Taylor expanded in EAccept around 0 67.0%
if 5.1000000000000001e51 < EAccept < 9.199999999999999e72 or 4.20000000000000032e122 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 97.2%
if 9.199999999999999e72 < EAccept < 4.20000000000000032e122Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 65.5%
Final simplification75.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_2 (+ t_1 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
(if (<= Vef -1.06e+57)
t_2
(if (<= Vef -5.4e-189)
t_0
(if (<= Vef 4.5e-54)
(+ t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
(if (<= Vef 5.1e+64) t_0 t_2))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / (1.0 + exp((Vef / KbT))));
double tmp;
if (Vef <= -1.06e+57) {
tmp = t_2;
} else if (Vef <= -5.4e-189) {
tmp = t_0;
} else if (Vef <= 4.5e-54) {
tmp = t_1 + (NdChar / (1.0 + exp((mu / KbT))));
} else if (Vef <= 5.1e+64) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_2 = t_1 + (ndchar / (1.0d0 + exp((vef / kbt))))
if (vef <= (-1.06d+57)) then
tmp = t_2
else if (vef <= (-5.4d-189)) then
tmp = t_0
else if (vef <= 4.5d-54) then
tmp = t_1 + (ndchar / (1.0d0 + exp((mu / kbt))))
else if (vef <= 5.1d+64) then
tmp = t_0
else
tmp = t_2
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
double tmp;
if (Vef <= -1.06e+57) {
tmp = t_2;
} else if (Vef <= -5.4e-189) {
tmp = t_0;
} else if (Vef <= 4.5e-54) {
tmp = t_1 + (NdChar / (1.0 + Math.exp((mu / KbT))));
} else if (Vef <= 5.1e+64) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT)))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_2 = t_1 + (NdChar / (1.0 + math.exp((Vef / KbT)))) tmp = 0 if Vef <= -1.06e+57: tmp = t_2 elif Vef <= -5.4e-189: tmp = t_0 elif Vef <= 4.5e-54: tmp = t_1 + (NdChar / (1.0 + math.exp((mu / KbT)))) elif Vef <= 5.1e+64: tmp = t_0 else: tmp = t_2 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_2 = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))) tmp = 0.0 if (Vef <= -1.06e+57) tmp = t_2; elseif (Vef <= -5.4e-189) tmp = t_0; elseif (Vef <= 4.5e-54) tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))); elseif (Vef <= 5.1e+64) tmp = t_0; else tmp = t_2; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT)))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_2 = t_1 + (NdChar / (1.0 + exp((Vef / KbT)))); tmp = 0.0; if (Vef <= -1.06e+57) tmp = t_2; elseif (Vef <= -5.4e-189) tmp = t_0; elseif (Vef <= 4.5e-54) tmp = t_1 + (NdChar / (1.0 + exp((mu / KbT)))); elseif (Vef <= 5.1e+64) tmp = t_0; else tmp = t_2; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Vef, -1.06e+57], t$95$2, If[LessEqual[Vef, -5.4e-189], t$95$0, If[LessEqual[Vef, 4.5e-54], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Vef, 5.1e+64], t$95$0, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_2 := t_1 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{if}\;Vef \leq -1.06 \cdot 10^{+57}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;Vef \leq -5.4 \cdot 10^{-189}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;Vef \leq 4.5 \cdot 10^{-54}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\mathbf{elif}\;Vef \leq 5.1 \cdot 10^{+64}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if Vef < -1.06e57 or 5.10000000000000024e64 < 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.8%
if -1.06e57 < Vef < -5.3999999999999999e-189 or 4.4999999999999998e-54 < Vef < 5.10000000000000024e64Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 78.3%
if -5.3999999999999999e-189 < Vef < 4.4999999999999998e-54Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 82.7%
Final simplification83.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))))
(if (<= EAccept 3.1e-26)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
(if (<= EAccept 2.85e+178)
(+ t_0 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
(+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double tmp;
if (EAccept <= 3.1e-26) {
tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
} else if (EAccept <= 2.85e+178) {
tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))
if (eaccept <= 3.1d-26) then
tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
else if (eaccept <= 2.85d+178) then
tmp = t_0 + (nachar / (1.0d0 + exp((-mu / kbt))))
else
tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double tmp;
if (EAccept <= 3.1e-26) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
} else if (EAccept <= 2.85e+178) {
tmp = t_0 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
} else {
tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT))) tmp = 0 if EAccept <= 3.1e-26: tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT)))) elif EAccept <= 2.85e+178: tmp = t_0 + (NaChar / (1.0 + math.exp((-mu / KbT)))) else: tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) tmp = 0.0 if (EAccept <= 3.1e-26) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT))))); elseif (EAccept <= 2.85e+178) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT))))); else tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT))); tmp = 0.0; if (EAccept <= 3.1e-26) tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT)))); elseif (EAccept <= 2.85e+178) tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT)))); else tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, 3.1e-26], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 2.85e+178], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}}\\
\mathbf{if}\;EAccept \leq 3.1 \cdot 10^{-26}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\
\mathbf{elif}\;EAccept \leq 2.85 \cdot 10^{+178}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\
\end{array}
\end{array}
if EAccept < 3.09999999999999983e-26Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in Ev around inf 73.6%
if 3.09999999999999983e-26 < EAccept < 2.85000000000000017e178Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in mu around inf 78.8%
neg-mul-158.3%
distribute-neg-frac58.3%
Simplified78.8%
if 2.85000000000000017e178 < EAccept Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 100.0%
Final simplification76.2%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (or (<= Vef -1.4e-44) (not (<= Vef 13.0)))
(+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))
(+ t_0 (/ NdChar (+ 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 ((Vef <= -1.4e-44) || !(Vef <= 13.0)) {
tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
} else {
tmp = t_0 + (NdChar / (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 ((vef <= (-1.4d-44)) .or. (.not. (vef <= 13.0d0))) then
tmp = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
else
tmp = t_0 + (ndchar / (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 ((Vef <= -1.4e-44) || !(Vef <= 13.0)) {
tmp = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
} else {
tmp = t_0 + (NdChar / (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 (Vef <= -1.4e-44) or not (Vef <= 13.0): tmp = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT)))) else: tmp = t_0 + (NdChar / (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 ((Vef <= -1.4e-44) || !(Vef <= 13.0)) tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))))); else tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(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 ((Vef <= -1.4e-44) || ~((Vef <= 13.0))) tmp = t_0 + (NdChar / (1.0 + exp((Vef / KbT)))); else tmp = t_0 + (NdChar / (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[Or[LessEqual[Vef, -1.4e-44], N[Not[LessEqual[Vef, 13.0]], $MachinePrecision]], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(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}\;Vef \leq -1.4 \cdot 10^{-44} \lor \neg \left(Vef \leq 13\right):\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\
\end{array}
\end{array}
if Vef < -1.4e-44 or 13 < 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 80.3%
if -1.4e-44 < Vef < 13Initial 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 mu around inf 79.4%
Final simplification79.9%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= NaChar -1.8e-98)
(+ t_1 (/ NdChar (+ (/ Vef KbT) 2.0)))
(if (<= NaChar 2.9e-103)
(+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
(if (<= NaChar 2.35e-57)
(+
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
(if (<= NaChar 1.9e+41)
(+ t_0 (* NaChar (/ 1.0 (+ (/ Ev KbT) 2.0))))
(+ t_1 (/ NdChar (+ 1.0 (+ 1.0 (/ mu KbT)))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -1.8e-98) {
tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0));
} else if (NaChar <= 2.9e-103) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NaChar <= 2.35e-57) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
} else if (NaChar <= 1.9e+41) {
tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0)));
} else {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-1.8d-98)) then
tmp = t_1 + (ndchar / ((vef / kbt) + 2.0d0))
else if (nachar <= 2.9d-103) then
tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
else if (nachar <= 2.35d-57) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
else if (nachar <= 1.9d+41) then
tmp = t_0 + (nachar * (1.0d0 / ((ev / kbt) + 2.0d0)))
else
tmp = t_1 + (ndchar / (1.0d0 + (1.0d0 + (mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -1.8e-98) {
tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0));
} else if (NaChar <= 2.9e-103) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NaChar <= 2.35e-57) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
} else if (NaChar <= 1.9e+41) {
tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0)));
} else {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if NaChar <= -1.8e-98: tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0)) elif NaChar <= 2.9e-103: tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) elif NaChar <= 2.35e-57: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT)))) elif NaChar <= 1.9e+41: tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0))) else: tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (NaChar <= -1.8e-98) tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); elseif (NaChar <= 2.9e-103) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); elseif (NaChar <= 2.35e-57) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT))))); elseif (NaChar <= 1.9e+41) tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Ev / KbT) + 2.0)))); else tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -1.8e-98) tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0)); elseif (NaChar <= 2.9e-103) tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); elseif (NaChar <= 2.35e-57) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT)))); elseif (NaChar <= 1.9e+41) tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0))); else tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.8e-98], N[(t$95$1 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.9e-103], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2.35e-57], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 1.9e+41], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -1.8 \cdot 10^{-98}:\\
\;\;\;\;t_1 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{elif}\;NaChar \leq 2.9 \cdot 10^{-103}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\mathbf{elif}\;NaChar \leq 2.35 \cdot 10^{-57}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\
\mathbf{elif}\;NaChar \leq 1.9 \cdot 10^{+41}:\\
\;\;\;\;t_0 + NaChar \cdot \frac{1}{\frac{Ev}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \left(1 + \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NaChar < -1.8000000000000001e-98Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 77.4%
Taylor expanded in Vef around 0 66.8%
if -1.8000000000000001e-98 < NaChar < 2.8999999999999999e-103Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 70.3%
Taylor expanded in EAccept around 0 62.7%
if 2.8999999999999999e-103 < NaChar < 2.3499999999999999e-57Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Ev around inf 74.3%
Taylor expanded in EDonor around inf 74.3%
if 2.3499999999999999e-57 < NaChar < 1.9000000000000001e41Initial program 99.7%
neg-sub099.7%
associate--r-99.7%
+-commutative99.7%
neg-sub099.7%
sub-neg99.7%
associate--l-99.7%
unsub-neg99.7%
+-commutative99.7%
associate-+l+99.7%
Simplified99.7%
Taylor expanded in Ev around inf 75.9%
Taylor expanded in Ev around 0 80.1%
clear-num80.1%
associate-/r/80.1%
+-commutative80.1%
associate-+r+80.1%
metadata-eval80.1%
Applied egg-rr80.1%
if 1.9000000000000001e41 < 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 mu around inf 81.7%
Taylor expanded in mu around 0 68.2%
Final simplification67.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT)))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))))
(if (<= NaChar -3.05e-99)
(+ t_1 (/ NdChar (+ (/ Vef KbT) 2.0)))
(if (<= NaChar 5e-102)
(+ t_0 (/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
(if (<= NaChar 8.5e-58)
(+
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(/
NdChar
(+
1.0
(-
(+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT))))
(/ Ec KbT)))))
(if (<= NaChar 4.5e+46)
(+ t_0 (* NaChar (/ 1.0 (+ (/ Ev KbT) 2.0))))
(+ t_1 (/ NdChar (+ 1.0 (+ 1.0 (/ mu KbT)))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -3.05e-99) {
tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0));
} else if (NaChar <= 5e-102) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NaChar <= 8.5e-58) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else if (NaChar <= 4.5e+46) {
tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0)));
} else {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
if (nachar <= (-3.05d-99)) then
tmp = t_1 + (ndchar / ((vef / kbt) + 2.0d0))
else if (nachar <= 5d-102) then
tmp = t_0 + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
else if (nachar <= 8.5d-58) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt))))
else if (nachar <= 4.5d+46) then
tmp = t_0 + (nachar * (1.0d0 / ((ev / kbt) + 2.0d0)))
else
tmp = t_1 + (ndchar / (1.0d0 + (1.0d0 + (mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double tmp;
if (NaChar <= -3.05e-99) {
tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0));
} else if (NaChar <= 5e-102) {
tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NaChar <= 8.5e-58) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT))));
} else if (NaChar <= 4.5e+46) {
tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0)));
} else {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) tmp = 0 if NaChar <= -3.05e-99: tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0)) elif NaChar <= 5e-102: tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) elif NaChar <= 8.5e-58: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) elif NaChar <= 4.5e+46: tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0))) else: tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) tmp = 0.0 if (NaChar <= -3.05e-99) tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); elseif (NaChar <= 5e-102) tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); elseif (NaChar <= 8.5e-58) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(mu / KbT) + Float64(1.0 + Float64(Float64(Vef / KbT) + Float64(EDonor / KbT)))) - Float64(Ec / KbT))))); elseif (NaChar <= 4.5e+46) tmp = Float64(t_0 + Float64(NaChar * Float64(1.0 / Float64(Float64(Ev / KbT) + 2.0)))); else tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); tmp = 0.0; if (NaChar <= -3.05e-99) tmp = t_1 + (NdChar / ((Vef / KbT) + 2.0)); elseif (NaChar <= 5e-102) tmp = t_0 + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); elseif (NaChar <= 8.5e-58) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))); elseif (NaChar <= 4.5e+46) tmp = t_0 + (NaChar * (1.0 / ((Ev / KbT) + 2.0))); else tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -3.05e-99], N[(t$95$1 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 5e-102], N[(t$95$0 + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 8.5e-58], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 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]), $MachinePrecision], If[LessEqual[NaChar, 4.5e+46], N[(t$95$0 + N[(NaChar * N[(1.0 / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
\mathbf{if}\;NaChar \leq -3.05 \cdot 10^{-99}:\\
\;\;\;\;t_1 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{elif}\;NaChar \leq 5 \cdot 10^{-102}:\\
\;\;\;\;t_0 + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\mathbf{elif}\;NaChar \leq 8.5 \cdot 10^{-58}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + \left(\left(\frac{mu}{KbT} + \left(1 + \left(\frac{Vef}{KbT} + \frac{EDonor}{KbT}\right)\right)\right) - \frac{Ec}{KbT}\right)}\\
\mathbf{elif}\;NaChar \leq 4.5 \cdot 10^{+46}:\\
\;\;\;\;t_0 + NaChar \cdot \frac{1}{\frac{Ev}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \left(1 + \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NaChar < -3.0500000000000002e-99Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 77.4%
Taylor expanded in Vef around 0 66.8%
if -3.0500000000000002e-99 < NaChar < 5.00000000000000026e-102Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in EAccept around inf 70.6%
Taylor expanded in EAccept around 0 63.2%
if 5.00000000000000026e-102 < NaChar < 8.5000000000000004e-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 70.5%
Taylor expanded in KbT around inf 70.5%
if 8.5000000000000004e-58 < NaChar < 4.5000000000000001e46Initial program 99.7%
neg-sub099.7%
associate--r-99.7%
+-commutative99.7%
neg-sub099.7%
sub-neg99.7%
associate--l-99.7%
unsub-neg99.7%
+-commutative99.7%
associate-+l+99.7%
Simplified99.7%
Taylor expanded in Ev around inf 75.9%
Taylor expanded in Ev around 0 80.1%
clear-num80.1%
associate-/r/80.1%
+-commutative80.1%
associate-+r+80.1%
metadata-eval80.1%
Applied egg-rr80.1%
if 4.5000000000000001e46 < 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 mu around inf 81.7%
Taylor expanded in mu around 0 68.2%
Final simplification67.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -9.5e-99)
(and (not (<= NaChar 5e-102))
(or (<= NaChar 3.7e-47) (not (<= NaChar 6.2e+51)))))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ (/ Vef KbT) 2.0)))
(+
(/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -9.5e-99) || (!(NaChar <= 5e-102) && ((NaChar <= 3.7e-47) || !(NaChar <= 6.2e+51)))) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
} else {
tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((nachar <= (-9.5d-99)) .or. (.not. (nachar <= 5d-102)) .and. (nachar <= 3.7d-47) .or. (.not. (nachar <= 6.2d+51))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / ((vef / kbt) + 2.0d0))
else
tmp = (ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -9.5e-99) || (!(NaChar <= 5e-102) && ((NaChar <= 3.7e-47) || !(NaChar <= 6.2e+51)))) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -9.5e-99) or (not (NaChar <= 5e-102) and ((NaChar <= 3.7e-47) or not (NaChar <= 6.2e+51))): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)) else: tmp = (NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -9.5e-99) || (!(NaChar <= 5e-102) && ((NaChar <= 3.7e-47) || !(NaChar <= 6.2e+51)))) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -9.5e-99) || (~((NaChar <= 5e-102)) && ((NaChar <= 3.7e-47) || ~((NaChar <= 6.2e+51))))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)); else tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -9.5e-99], And[N[Not[LessEqual[NaChar, 5e-102]], $MachinePrecision], Or[LessEqual[NaChar, 3.7e-47], N[Not[LessEqual[NaChar, 6.2e+51]], $MachinePrecision]]]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -9.5 \cdot 10^{-99} \lor \neg \left(NaChar \leq 5 \cdot 10^{-102}\right) \land \left(NaChar \leq 3.7 \cdot 10^{-47} \lor \neg \left(NaChar \leq 6.2 \cdot 10^{+51}\right)\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\end{array}
\end{array}
if NaChar < -9.5000000000000008e-99 or 5.00000000000000026e-102 < NaChar < 3.7e-47 or 6.20000000000000022e51 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 77.9%
Taylor expanded in Vef around 0 67.2%
if -9.5000000000000008e-99 < NaChar < 5.00000000000000026e-102 or 3.7e-47 < NaChar < 6.20000000000000022e51Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 74.2%
Taylor expanded in EAccept around 0 67.1%
Final simplification67.2%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT))))))
(t_1 (/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT)))))
(t_2 (+ t_1 (/ NdChar (+ (/ Vef KbT) 2.0)))))
(if (<= NaChar -6.2e-100)
t_2
(if (<= NaChar 5e-102)
t_0
(if (<= NaChar 3.7e-47)
t_2
(if (<= NaChar 1.6e+55)
t_0
(+ t_1 (/ NdChar (+ 1.0 (+ 1.0 (/ mu KbT)))))))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
double t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / ((Vef / KbT) + 2.0));
double tmp;
if (NaChar <= -6.2e-100) {
tmp = t_2;
} else if (NaChar <= 5e-102) {
tmp = t_0;
} else if (NaChar <= 3.7e-47) {
tmp = t_2;
} else if (NaChar <= 1.6e+55) {
tmp = t_0;
} else {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = (ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
t_1 = nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))
t_2 = t_1 + (ndchar / ((vef / kbt) + 2.0d0))
if (nachar <= (-6.2d-100)) then
tmp = t_2
else if (nachar <= 5d-102) then
tmp = t_0
else if (nachar <= 3.7d-47) then
tmp = t_2
else if (nachar <= 1.6d+55) then
tmp = t_0
else
tmp = t_1 + (ndchar / (1.0d0 + (1.0d0 + (mu / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
double t_1 = NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)));
double t_2 = t_1 + (NdChar / ((Vef / KbT) + 2.0));
double tmp;
if (NaChar <= -6.2e-100) {
tmp = t_2;
} else if (NaChar <= 5e-102) {
tmp = t_0;
} else if (NaChar <= 3.7e-47) {
tmp = t_2;
} else if (NaChar <= 1.6e+55) {
tmp = t_0;
} else {
tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) t_1 = NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT))) t_2 = t_1 + (NdChar / ((Vef / KbT) + 2.0)) tmp = 0 if NaChar <= -6.2e-100: tmp = t_2 elif NaChar <= 5e-102: tmp = t_0 elif NaChar <= 3.7e-47: tmp = t_2 elif NaChar <= 1.6e+55: tmp = t_0 else: tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))) t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) t_2 = Float64(t_1 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))) tmp = 0.0 if (NaChar <= -6.2e-100) tmp = t_2; elseif (NaChar <= 5e-102) tmp = t_0; elseif (NaChar <= 3.7e-47) tmp = t_2; elseif (NaChar <= 1.6e+55) tmp = t_0; else tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(mu / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); t_1 = NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT))); t_2 = t_1 + (NdChar / ((Vef / KbT) + 2.0)); tmp = 0.0; if (NaChar <= -6.2e-100) tmp = t_2; elseif (NaChar <= 5e-102) tmp = t_0; elseif (NaChar <= 3.7e-47) tmp = t_2; elseif (NaChar <= 1.6e+55) tmp = t_0; else tmp = t_1 + (NdChar / (1.0 + (1.0 + (mu / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -6.2e-100], t$95$2, If[LessEqual[NaChar, 5e-102], t$95$0, If[LessEqual[NaChar, 3.7e-47], t$95$2, If[LessEqual[NaChar, 1.6e+55], t$95$0, N[(t$95$1 + N[(NdChar / N[(1.0 + N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}}\\
t_2 := t_1 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{if}\;NaChar \leq -6.2 \cdot 10^{-100}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;NaChar \leq 5 \cdot 10^{-102}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq 3.7 \cdot 10^{-47}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;NaChar \leq 1.6 \cdot 10^{+55}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;t_1 + \frac{NdChar}{1 + \left(1 + \frac{mu}{KbT}\right)}\\
\end{array}
\end{array}
if NaChar < -6.1999999999999997e-100 or 5.00000000000000026e-102 < NaChar < 3.7e-47Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 77.7%
Taylor expanded in Vef around 0 67.3%
if -6.1999999999999997e-100 < NaChar < 5.00000000000000026e-102 or 3.7e-47 < NaChar < 1.6000000000000001e55Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in EAccept around inf 74.2%
Taylor expanded in EAccept around 0 67.1%
if 1.6000000000000001e55 < 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 mu around inf 81.7%
Taylor expanded in mu around 0 68.2%
Final simplification67.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT)))))
(t_1
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ (/ Vef KbT) 2.0)))))
(if (<= NaChar -3.2e-101)
t_1
(if (<= NaChar 3.7e-101)
(+ t_0 (/ (* KbT NaChar) Ev))
(if (or (<= NaChar 9.2e-47) (not (<= NaChar 1.6e+51)))
t_1
(+ t_0 (* NaChar 0.5)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_1 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
double tmp;
if (NaChar <= -3.2e-101) {
tmp = t_1;
} else if (NaChar <= 3.7e-101) {
tmp = t_0 + ((KbT * NaChar) / Ev);
} else if ((NaChar <= 9.2e-47) || !(NaChar <= 1.6e+51)) {
tmp = t_1;
} else {
tmp = t_0 + (NaChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))
t_1 = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / ((vef / kbt) + 2.0d0))
if (nachar <= (-3.2d-101)) then
tmp = t_1
else if (nachar <= 3.7d-101) then
tmp = t_0 + ((kbt * nachar) / ev)
else if ((nachar <= 9.2d-47) .or. (.not. (nachar <= 1.6d+51))) then
tmp = t_1
else
tmp = t_0 + (nachar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)));
double t_1 = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
double tmp;
if (NaChar <= -3.2e-101) {
tmp = t_1;
} else if (NaChar <= 3.7e-101) {
tmp = t_0 + ((KbT * NaChar) / Ev);
} else if ((NaChar <= 9.2e-47) || !(NaChar <= 1.6e+51)) {
tmp = t_1;
} else {
tmp = t_0 + (NaChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT))) t_1 = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)) tmp = 0 if NaChar <= -3.2e-101: tmp = t_1 elif NaChar <= 3.7e-101: tmp = t_0 + ((KbT * NaChar) / Ev) elif (NaChar <= 9.2e-47) or not (NaChar <= 1.6e+51): tmp = t_1 else: tmp = t_0 + (NaChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))) tmp = 0.0 if (NaChar <= -3.2e-101) tmp = t_1; elseif (NaChar <= 3.7e-101) tmp = Float64(t_0 + Float64(Float64(KbT * NaChar) / Ev)); elseif ((NaChar <= 9.2e-47) || !(NaChar <= 1.6e+51)) tmp = t_1; else tmp = Float64(t_0 + Float64(NaChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT))); t_1 = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)); tmp = 0.0; if (NaChar <= -3.2e-101) tmp = t_1; elseif (NaChar <= 3.7e-101) tmp = t_0 + ((KbT * NaChar) / Ev); elseif ((NaChar <= 9.2e-47) || ~((NaChar <= 1.6e+51))) tmp = t_1; else tmp = t_0 + (NaChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -3.2e-101], t$95$1, If[LessEqual[NaChar, 3.7e-101], N[(t$95$0 + N[(N[(KbT * NaChar), $MachinePrecision] / Ev), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NaChar, 9.2e-47], N[Not[LessEqual[NaChar, 1.6e+51]], $MachinePrecision]], t$95$1, N[(t$95$0 + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}}\\
t_1 := \frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{if}\;NaChar \leq -3.2 \cdot 10^{-101}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;NaChar \leq 3.7 \cdot 10^{-101}:\\
\;\;\;\;t_0 + \frac{KbT \cdot NaChar}{Ev}\\
\mathbf{elif}\;NaChar \leq 9.2 \cdot 10^{-47} \lor \neg \left(NaChar \leq 1.6 \cdot 10^{+51}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_0 + NaChar \cdot 0.5\\
\end{array}
\end{array}
if NaChar < -3.19999999999999978e-101 or 3.70000000000000005e-101 < NaChar < 9.19999999999999928e-47 or 1.6000000000000001e51 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 78.4%
Taylor expanded in Vef around 0 67.6%
if -3.19999999999999978e-101 < NaChar < 3.70000000000000005e-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 Ev around inf 73.3%
Taylor expanded in Ev around 0 67.9%
Taylor expanded in Ev around inf 57.7%
if 9.19999999999999928e-47 < NaChar < 1.6000000000000001e51Initial program 99.6%
neg-sub099.6%
associate--r-99.6%
+-commutative99.6%
neg-sub099.6%
sub-neg99.6%
associate--l-99.6%
unsub-neg99.6%
+-commutative99.6%
associate-+l+99.6%
Simplified99.6%
Taylor expanded in KbT around inf 81.0%
*-commutative81.0%
Simplified81.0%
Final simplification65.2%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -1.9e-98) (not (<= NaChar 7.5e+41)))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar (+ (/ Vef KbT) 2.0)))
(+
(/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))
(* NaChar (/ 1.0 (+ (/ Ev KbT) 2.0))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -1.9e-98) || !(NaChar <= 7.5e+41)) {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
} else {
tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * (1.0 / ((Ev / KbT) + 2.0)));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((nachar <= (-1.9d-98)) .or. (.not. (nachar <= 7.5d+41))) then
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / ((vef / kbt) + 2.0d0))
else
tmp = (ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))) + (nachar * (1.0d0 / ((ev / kbt) + 2.0d0)))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -1.9e-98) || !(NaChar <= 7.5e+41)) {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
} else {
tmp = (NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * (1.0 / ((Ev / KbT) + 2.0)));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -1.9e-98) or not (NaChar <= 7.5e+41): tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)) else: tmp = (NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * (1.0 / ((Ev / KbT) + 2.0))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -1.9e-98) || !(NaChar <= 7.5e+41)) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) + Float64(NaChar * Float64(1.0 / Float64(Float64(Ev / KbT) + 2.0)))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -1.9e-98) || ~((NaChar <= 7.5e+41))) tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)); else tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * (1.0 / ((Ev / KbT) + 2.0))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.9e-98], N[Not[LessEqual[NaChar, 7.5e+41]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * N[(1.0 / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -1.9 \cdot 10^{-98} \lor \neg \left(NaChar \leq 7.5 \cdot 10^{+41}\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + NaChar \cdot \frac{1}{\frac{Ev}{KbT} + 2}\\
\end{array}
\end{array}
if NaChar < -1.9000000000000002e-98 or 7.50000000000000072e41 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 77.7%
Taylor expanded in Vef around 0 66.9%
if -1.9000000000000002e-98 < NaChar < 7.50000000000000072e41Initial 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 Ev around inf 74.3%
Taylor expanded in Ev around 0 68.5%
clear-num68.7%
associate-/r/68.5%
+-commutative68.5%
associate-+r+68.5%
metadata-eval68.5%
Applied egg-rr68.5%
Final simplification67.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(let* ((t_0
(+
(/ NaChar (+ 1.0 (exp (/ Ev KbT))))
(/ NdChar (+ (/ Vef KbT) 2.0)))))
(if (<= NaChar -5.8e-109)
t_0
(if (<= NaChar 4.2e-103)
(+
(/ NdChar (+ 1.0 (exp (/ mu KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ EAccept KbT)))))
(if (<= NaChar 2e+37)
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ Ev KbT)))))
t_0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
double tmp;
if (NaChar <= -5.8e-109) {
tmp = t_0;
} else if (NaChar <= 4.2e-103) {
tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NaChar <= 2e+37) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: t_0
real(8) :: tmp
t_0 = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / ((vef / kbt) + 2.0d0))
if (nachar <= (-5.8d-109)) then
tmp = t_0
else if (nachar <= 4.2d-103) then
tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (eaccept / kbt))))
else if (nachar <= 2d+37) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (ev / kbt))))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double t_0 = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
double tmp;
if (NaChar <= -5.8e-109) {
tmp = t_0;
} else if (NaChar <= 4.2e-103) {
tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT))));
} else if (NaChar <= 2e+37) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
} else {
tmp = t_0;
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): t_0 = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)) tmp = 0 if NaChar <= -5.8e-109: tmp = t_0 elif NaChar <= 4.2e-103: tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))) elif NaChar <= 2e+37: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT)))) else: tmp = t_0 return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))) tmp = 0.0 if (NaChar <= -5.8e-109) tmp = t_0; elseif (NaChar <= 4.2e-103) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(EAccept / KbT))))); elseif (NaChar <= 2e+37) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Ev / KbT))))); else tmp = t_0; end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) t_0 = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)); tmp = 0.0; if (NaChar <= -5.8e-109) tmp = t_0; elseif (NaChar <= 4.2e-103) tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + (1.0 + (EAccept / KbT)))); elseif (NaChar <= 2e+37) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT)))); else tmp = t_0; end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -5.8e-109], t$95$0, If[LessEqual[NaChar, 4.2e-103], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(EAccept / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2e+37], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{if}\;NaChar \leq -5.8 \cdot 10^{-109}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;NaChar \leq 4.2 \cdot 10^{-103}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{EAccept}{KbT}\right)}\\
\mathbf{elif}\;NaChar \leq 2 \cdot 10^{+37}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Ev}{KbT}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if NaChar < -5.8e-109 or 1.99999999999999991e37 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 76.8%
Taylor expanded in Ev around inf 57.1%
Taylor expanded in Vef around 0 50.4%
if -5.8e-109 < NaChar < 4.20000000000000009e-103Initial 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 69.6%
Taylor expanded in mu around inf 50.4%
Taylor expanded in EAccept around 0 43.7%
if 4.20000000000000009e-103 < NaChar < 1.99999999999999991e37Initial program 99.8%
neg-sub099.8%
associate--r-99.8%
+-commutative99.8%
neg-sub099.8%
sub-neg99.8%
associate--l-99.8%
unsub-neg99.8%
+-commutative99.8%
associate-+l+99.8%
Simplified99.8%
Taylor expanded in Ev around inf 74.7%
Taylor expanded in Ev around 0 67.9%
Taylor expanded in EDonor around inf 56.3%
Final simplification49.0%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NaChar -5.1e-107) (not (<= NaChar 9.5e+37)))
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar (+ (/ Vef KbT) 2.0)))
(+
(/ NdChar (+ 1.0 (exp (/ EDonor KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ Ev KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -5.1e-107) || !(NaChar <= 9.5e+37)) {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
} else {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((nachar <= (-5.1d-107)) .or. (.not. (nachar <= 9.5d+37))) then
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / ((vef / kbt) + 2.0d0))
else
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (ev / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NaChar <= -5.1e-107) || !(NaChar <= 9.5e+37)) {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
} else {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NaChar <= -5.1e-107) or not (NaChar <= 9.5e+37): tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)) else: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NaChar <= -5.1e-107) || !(NaChar <= 9.5e+37)) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); else tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / Float64(1.0 + Float64(1.0 + Float64(Ev / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NaChar <= -5.1e-107) || ~((NaChar <= 9.5e+37))) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)); else tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -5.1e-107], N[Not[LessEqual[NaChar, 9.5e+37]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -5.1 \cdot 10^{-107} \lor \neg \left(NaChar \leq 9.5 \cdot 10^{+37}\right):\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{1 + \left(1 + \frac{Ev}{KbT}\right)}\\
\end{array}
\end{array}
if NaChar < -5.1000000000000002e-107 or 9.4999999999999995e37 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 76.8%
Taylor expanded in Ev around inf 57.1%
Taylor expanded in Vef around 0 50.4%
if -5.1000000000000002e-107 < NaChar < 9.4999999999999995e37Initial 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 Ev around inf 74.6%
Taylor expanded in Ev around 0 68.5%
Taylor expanded in EDonor around inf 45.6%
Final simplification48.3%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (or (<= NdChar -2.4e-20) (not (<= NdChar 1.2e-37)))
(+
(/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))
(* NaChar 0.5))
(+
(/ NaChar (+ 1.0 (exp (/ (- (+ Vef (+ Ev EAccept)) mu) KbT))))
(/ NdChar 2.0))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -2.4e-20) || !(NdChar <= 1.2e-37)) {
tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((ndchar <= (-2.4d-20)) .or. (.not. (ndchar <= 1.2d-37))) then
tmp = (ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((((vef + (ev + eaccept)) - mu) / kbt)))) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -2.4e-20) || !(NdChar <= 1.2e-37)) {
tmp = (NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -2.4e-20) or not (NdChar <= 1.2e-37): tmp = (NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -2.4e-20) || !(NdChar <= 1.2e-37)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Vef + Float64(Ev + EAccept)) - mu) / KbT)))) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -2.4e-20) || ~((NdChar <= 1.2e-37))) tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp((((Vef + (Ev + EAccept)) - mu) / KbT)))) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -2.4e-20], N[Not[LessEqual[NdChar, 1.2e-37]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(Vef + N[(Ev + EAccept), $MachinePrecision]), $MachinePrecision] - mu), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -2.4 \cdot 10^{-20} \lor \neg \left(NdChar \leq 1.2 \cdot 10^{-37}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{\left(Vef + \left(Ev + EAccept\right)\right) - mu}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if NdChar < -2.39999999999999993e-20 or 1.19999999999999995e-37 < NdChar 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 58.3%
*-commutative58.3%
Simplified58.3%
if -2.39999999999999993e-20 < NdChar < 1.19999999999999995e-37Initial 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.8%
Final simplification59.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NaChar -1.28e+141)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0))
(if (<= NaChar 6.5e+94)
(+
(/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))
(* NaChar 0.5))
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar (+ (/ Vef KbT) 2.0))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -1.28e+141) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
} else if (NaChar <= 6.5e+94) {
tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (nachar <= (-1.28d+141)) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / 2.0d0)
else if (nachar <= 6.5d+94) then
tmp = (ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / ((vef / kbt) + 2.0d0))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -1.28e+141) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
} else if (NaChar <= 6.5e+94) {
tmp = (NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NaChar <= -1.28e+141: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0) elif NaChar <= 6.5e+94: tmp = (NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NaChar <= -1.28e+141) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0)); elseif (NaChar <= 6.5e+94) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NaChar <= -1.28e+141) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0); elseif (NaChar <= 6.5e+94) tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -1.28e+141], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 6.5e+94], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -1.28 \cdot 10^{+141}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{elif}\;NaChar \leq 6.5 \cdot 10^{+94}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\end{array}
\end{array}
if NaChar < -1.28000000000000004e141Initial 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 69.0%
Taylor expanded in KbT around inf 45.8%
if -1.28000000000000004e141 < NaChar < 6.49999999999999976e94Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 53.5%
*-commutative53.5%
Simplified53.5%
if 6.49999999999999976e94 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 79.3%
Taylor expanded in Ev around inf 61.7%
Taylor expanded in Vef around 0 54.7%
Final simplification52.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NaChar -3.5e+140)
(+
(/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
(/ NdChar (+ 1.0 (+ 1.0 (/ mu KbT)))))
(if (<= NaChar 5.6e+94)
(+
(/ NdChar (+ 1.0 (exp (/ (- mu (- Ec (+ Vef EDonor))) KbT))))
(* NaChar 0.5))
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar (+ (/ Vef KbT) 2.0))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -3.5e+140) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + (1.0 + (mu / KbT))));
} else if (NaChar <= 5.6e+94) {
tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (nachar <= (-3.5d+140)) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + (1.0d0 + (mu / kbt))))
else if (nachar <= 5.6d+94) then
tmp = (ndchar / (1.0d0 + exp(((mu - (ec - (vef + edonor))) / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / ((vef / kbt) + 2.0d0))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -3.5e+140) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + (1.0 + (mu / KbT))));
} else if (NaChar <= 5.6e+94) {
tmp = (NdChar / (1.0 + Math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NaChar <= -3.5e+140: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + (1.0 + (mu / KbT)))) elif NaChar <= 5.6e+94: tmp = (NdChar / (1.0 + math.exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NaChar <= -3.5e+140) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(mu / KbT))))); elseif (NaChar <= 5.6e+94) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Ec - Float64(Vef + EDonor))) / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NaChar <= -3.5e+140) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + (1.0 + (mu / KbT)))); elseif (NaChar <= 5.6e+94) tmp = (NdChar / (1.0 + exp(((mu - (Ec - (Vef + EDonor))) / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -3.5e+140], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 5.6e+94], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(Ec - N[(Vef + EDonor), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -3.5 \cdot 10^{+140}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + \left(1 + \frac{mu}{KbT}\right)}\\
\mathbf{elif}\;NaChar \leq 5.6 \cdot 10^{+94}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(Ec - \left(Vef + EDonor\right)\right)}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\end{array}
\end{array}
if NaChar < -3.49999999999999989e140Initial 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 69.0%
Taylor expanded in mu around inf 51.6%
Taylor expanded in mu around 0 46.9%
if -3.49999999999999989e140 < NaChar < 5.59999999999999997e94Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 53.5%
*-commutative53.5%
Simplified53.5%
if 5.59999999999999997e94 < NaChar Initial program 100.0%
neg-sub0100.0%
associate--r-100.0%
+-commutative100.0%
neg-sub0100.0%
sub-neg100.0%
associate--l-100.0%
unsub-neg100.0%
+-commutative100.0%
associate-+l+100.0%
Simplified100.0%
Taylor expanded in Vef around inf 79.3%
Taylor expanded in Ev around inf 61.7%
Taylor expanded in Vef around 0 54.7%
Final simplification52.6%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (or (<= NdChar -1.02e-142) (not (<= NdChar 4.2e+111))) (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (/ NaChar (+ (/ Ev KbT) 2.0))) (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -1.02e-142) || !(NdChar <= 4.2e+111)) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((ndchar <= (-1.02d-142)) .or. (.not. (ndchar <= 4.2d+111))) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / ((ev / kbt) + 2.0d0))
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -1.02e-142) || !(NdChar <= 4.2e+111)) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -1.02e-142) or not (NdChar <= 4.2e+111): tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / ((Ev / KbT) + 2.0)) else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -1.02e-142) || !(NdChar <= 4.2e+111)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -1.02e-142) || ~((NdChar <= 4.2e+111))) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / ((Ev / KbT) + 2.0)); else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.02e-142], N[Not[LessEqual[NdChar, 4.2e+111]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -1.02 \cdot 10^{-142} \lor \neg \left(NdChar \leq 4.2 \cdot 10^{+111}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if NdChar < -1.0200000000000001e-142 or 4.1999999999999999e111 < NdChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in Vef around inf 68.8%
Taylor expanded in Ev around inf 53.3%
Taylor expanded in Ev around 0 47.3%
if -1.0200000000000001e-142 < NdChar < 4.1999999999999999e111Initial 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 61.4%
Taylor expanded in KbT around inf 40.4%
Final simplification44.1%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (or (<= NdChar -9.2e+77) (not (<= NdChar 5.5e+111))) (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (/ NaChar (+ (/ Ev KbT) 2.0))) (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (/ NdChar (+ (/ Vef KbT) 2.0)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -9.2e+77) || !(NdChar <= 5.5e+111)) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
} else {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((ndchar <= (-9.2d+77)) .or. (.not. (ndchar <= 5.5d+111))) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / ((ev / kbt) + 2.0d0))
else
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / ((vef / kbt) + 2.0d0))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -9.2e+77) || !(NdChar <= 5.5e+111)) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / ((Ev / KbT) + 2.0));
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -9.2e+77) or not (NdChar <= 5.5e+111): tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / ((Ev / KbT) + 2.0)) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -9.2e+77) || !(NdChar <= 5.5e+111)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(Float64(Ev / KbT) + 2.0))); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -9.2e+77) || ~((NdChar <= 5.5e+111))) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / ((Ev / KbT) + 2.0)); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / ((Vef / KbT) + 2.0)); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -9.2e+77], N[Not[LessEqual[NdChar, 5.5e+111]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(Ev / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -9.2 \cdot 10^{+77} \lor \neg \left(NdChar \leq 5.5 \cdot 10^{+111}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{\frac{Ev}{KbT} + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\
\end{array}
\end{array}
if NdChar < -9.19999999999999979e77 or 5.4999999999999998e111 < NdChar Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in Vef around inf 61.8%
Taylor expanded in Ev around inf 50.8%
Taylor expanded in Ev around 0 44.9%
if -9.19999999999999979e77 < NdChar < 5.4999999999999998e111Initial 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 74.8%
Taylor expanded in Ev around inf 53.5%
Taylor expanded in Vef around 0 49.3%
Final simplification47.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (or (<= NdChar -6.5e-55) (not (<= NdChar 4.2e+111))) (+ (/ NdChar (+ 1.0 (exp (/ Vef KbT)))) (* NaChar 0.5)) (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -6.5e-55) || !(NdChar <= 4.2e+111)) {
tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if ((ndchar <= (-6.5d-55)) .or. (.not. (ndchar <= 4.2d+111))) then
tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / 2.0d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if ((NdChar <= -6.5e-55) || !(NdChar <= 4.2e+111)) {
tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if (NdChar <= -6.5e-55) or not (NdChar <= 4.2e+111): tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if ((NdChar <= -6.5e-55) || !(NdChar <= 4.2e+111)) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if ((NdChar <= -6.5e-55) || ~((NdChar <= 4.2e+111))) tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -6.5e-55], N[Not[LessEqual[NdChar, 4.2e+111]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NdChar \leq -6.5 \cdot 10^{-55} \lor \neg \left(NdChar \leq 4.2 \cdot 10^{+111}\right):\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\
\end{array}
\end{array}
if NdChar < -6.50000000000000006e-55 or 4.1999999999999999e111 < NdChar 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.1%
*-commutative60.1%
Simplified60.1%
Taylor expanded in Vef around inf 43.6%
if -6.50000000000000006e-55 < NdChar < 4.1999999999999999e111Initial 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 63.7%
Taylor expanded in KbT around inf 42.0%
Final simplification42.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= NaChar -4.8e-99)
(+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0))
(if (<= NaChar 9.2e+38)
(+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (* NaChar 0.5))
(+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5)))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -4.8e-99) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
} else if (NaChar <= 9.2e+38) {
tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (nachar <= (-4.8d-99)) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / 2.0d0)
else if (nachar <= 9.2d+38) then
tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar * 0.5d0)
else
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (NaChar <= -4.8e-99) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
} else if (NaChar <= 9.2e+38) {
tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar * 0.5);
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if NaChar <= -4.8e-99: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0) elif NaChar <= 9.2e+38: tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar * 0.5) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (NaChar <= -4.8e-99) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0)); elseif (NaChar <= 9.2e+38) tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar * 0.5)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (NaChar <= -4.8e-99) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0); elseif (NaChar <= 9.2e+38) tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar * 0.5); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -4.8e-99], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 9.2e+38], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;NaChar \leq -4.8 \cdot 10^{-99}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{elif}\;NaChar \leq 9.2 \cdot 10^{+38}:\\
\;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + NaChar \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if NaChar < -4.8000000000000001e-99Initial 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 68.4%
Taylor expanded in KbT around inf 41.4%
if -4.8000000000000001e-99 < NaChar < 9.2000000000000005e38Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in KbT around inf 56.9%
*-commutative56.9%
Simplified56.9%
Taylor expanded in EDonor around inf 37.4%
if 9.2000000000000005e38 < 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 Ev around inf 76.1%
Taylor expanded in KbT around inf 51.5%
Final simplification41.8%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (if (<= KbT 1.2e-299) (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) (/ NdChar 2.0)) (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= 1.2e-299) {
tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0);
} else {
tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (kbt <= 1.2d-299) then
tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / 2.0d0)
else
tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (KbT <= 1.2e-299) {
tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / 2.0);
} else {
tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if KbT <= 1.2e-299: tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / 2.0) else: tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (KbT <= 1.2e-299) tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / 2.0)); else tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (KbT <= 1.2e-299) tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / 2.0); else tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, 1.2e-299], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;KbT \leq 1.2 \cdot 10^{-299}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5\\
\end{array}
\end{array}
if KbT < 1.2000000000000001e-299Initial 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 69.1%
Taylor expanded in KbT around inf 33.6%
if 1.2000000000000001e-299 < 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 Ev around inf 71.2%
Taylor expanded in KbT around inf 37.6%
Final simplification35.5%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) (* NdChar 0.5)))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5);
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar * 0.5d0)
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar * 0.5);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar * 0.5)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar * 0.5)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar * 0.5); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + NdChar \cdot 0.5
\end{array}
Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in Ev around inf 73.3%
Taylor expanded in KbT around inf 38.4%
Final simplification38.4%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
:precision binary64
(if (<= Vef -2.25e-270)
(+ (* NaChar 0.5) (/ NdChar 2.0))
(+
(/
NdChar
(+
1.0
(- (+ (/ mu KbT) (+ 1.0 (+ (/ Vef KbT) (/ EDonor KbT)))) (/ Ec KbT))))
(/ NaChar (+ 1.0 (+ 1.0 (/ Ev KbT)))))))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (Vef <= -2.25e-270) {
tmp = (NaChar * 0.5) + (NdChar / 2.0);
} else {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
}
return tmp;
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
real(8) :: tmp
if (vef <= (-2.25d-270)) then
tmp = (nachar * 0.5d0) + (ndchar / 2.0d0)
else
tmp = (ndchar / (1.0d0 + (((mu / kbt) + (1.0d0 + ((vef / kbt) + (edonor / kbt)))) - (ec / kbt)))) + (nachar / (1.0d0 + (1.0d0 + (ev / kbt))))
end if
code = tmp
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
double tmp;
if (Vef <= -2.25e-270) {
tmp = (NaChar * 0.5) + (NdChar / 2.0);
} else {
tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT))));
}
return tmp;
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): tmp = 0 if Vef <= -2.25e-270: tmp = (NaChar * 0.5) + (NdChar / 2.0) else: tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT)))) return tmp
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0 if (Vef <= -2.25e-270) tmp = Float64(Float64(NaChar * 0.5) + Float64(NdChar / 2.0)); else 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(1.0 + Float64(1.0 + Float64(Ev / KbT))))); end return tmp end
function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = 0.0; if (Vef <= -2.25e-270) tmp = (NaChar * 0.5) + (NdChar / 2.0); else tmp = (NdChar / (1.0 + (((mu / KbT) + (1.0 + ((Vef / KbT) + (EDonor / KbT)))) - (Ec / KbT)))) + (NaChar / (1.0 + (1.0 + (Ev / KbT)))); end tmp_2 = tmp; end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[Vef, -2.25e-270], N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], 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[(1.0 + N[(1.0 + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;Vef \leq -2.25 \cdot 10^{-270}:\\
\;\;\;\;NaChar \cdot 0.5 + \frac{NdChar}{2}\\
\mathbf{else}:\\
\;\;\;\;\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}{1 + \left(1 + \frac{Ev}{KbT}\right)}\\
\end{array}
\end{array}
if Vef < -2.24999999999999999e-270Initial 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.9%
*-commutative46.9%
Simplified46.9%
Taylor expanded in KbT around inf 26.6%
if -2.24999999999999999e-270 < Vef Initial program 99.9%
neg-sub099.9%
associate--r-99.9%
+-commutative99.9%
neg-sub099.9%
sub-neg99.9%
associate--l-99.9%
unsub-neg99.9%
+-commutative99.9%
associate-+l+99.9%
Simplified99.9%
Taylor expanded in Ev around inf 75.0%
Taylor expanded in Ev around 0 58.9%
Taylor expanded in KbT around inf 32.9%
Final simplification29.7%
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept) :precision binary64 (+ (* NaChar 0.5) (/ NdChar 2.0)))
double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar * 0.5) + (NdChar / 2.0);
}
real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
real(8), intent (in) :: ndchar
real(8), intent (in) :: ec
real(8), intent (in) :: vef
real(8), intent (in) :: edonor
real(8), intent (in) :: mu
real(8), intent (in) :: kbt
real(8), intent (in) :: nachar
real(8), intent (in) :: ev
real(8), intent (in) :: eaccept
code = (nachar * 0.5d0) + (ndchar / 2.0d0)
end function
public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
return (NaChar * 0.5) + (NdChar / 2.0);
}
def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept): return (NaChar * 0.5) + (NdChar / 2.0)
function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) return Float64(Float64(NaChar * 0.5) + Float64(NdChar / 2.0)) end
function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept) tmp = (NaChar * 0.5) + (NdChar / 2.0); end
code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NaChar * 0.5), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
NaChar \cdot 0.5 + \frac{NdChar}{2}
\end{array}
Initial program 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 48.2%
*-commutative48.2%
Simplified48.2%
Taylor expanded in KbT around inf 28.5%
Final simplification28.5%
herbie shell --seed 2023187
(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))))))