def CalculateCH4ForcingEquivalent(llcp_time_series):
ch4fe_time_series = llcp_time_series.copy()
# Create the output DataFrame and add Columns for CO2fe(t) and CO2we(t) emissions and R(t) and S(t) intermediaries.
ch4fe_time_series = llcp_time_series
BlankEmissions = np.zeros(len(llcp_time_series))
FourColumnBlankEmissions = pd.DataFrame(
np.array([BlankEmissions, BlankEmissions, BlankEmissions, BlankEmissions]).transpose())
# Make Data-frames for R and S
R = pd.concat([llcp_time_series[{'Year', 'SLCP'}], pd.DataFrame(FourColumnBlankEmissions)], axis=1)
R['Total'] = BlankEmissions
S = pd.concat([llcp_time_series[{'Year', 'SLCP'}], pd.DataFrame(FourColumnBlankEmissions)], axis=1)
S['Total'] = BlankEmissions
# Compute the CH4fe values for each year
for i in ch4fe_time_series.index:
for k in Constants.DECAY_CONSTANTS.index:
# Compute S(i) and enter that value for the current i (Year)
S.loc[i, k] = mp.nsum(lambda j: ch4fe_time_series.loc[int(j), 'SLCP'] * Dco2(k, i - j), [0, i])
# Compute R(i) given S(i) and existing values of R(i)
R.loc[i, k] = mp.nsum(lambda j: (S.loc[int(j), 'Total'] - R.loc[int(j), 'Total']) * Dch4(k, i - j),
[0, i - 1])
S.loc[i, 'Total'] = mp.nsum(lambda k: S.loc[i, k], [0, len(Constants.DECAY_CONSTANTS.index) - 1])
R.loc[i, 'Total'] = mp.nsum(lambda k: R.loc[i, k], [0, len(Constants.DECAY_CONSTANTS.index) - 1])
# Compute CO2fe(i) from these values of S(i) and R(i)
ch4fe_time_series.loc[i, 'CH4fe'] = (S.loc[i, 'Total'] - R.loc[i, 'Total'])
return ch4fe_time_series
def compound_interest_fnc_mpmath_with_infinite_series_definition_of_e(
initial_investment, percent1, percent2, percent3, percent4, percent5,
compounding_frequency):
#converting the float values to numbers that have 100 decimal places
initial_investment = mpmath.mpmathify(initial_investment)
percent1 = mpmath.mpmathify(percent1)
percent2 = mpmath.mpmathify(percent2)
percent3 = mpmath.mpmathify(percent3)
percent4 = mpmath.mpmathify(percent4)
percent5 = mpmath.mpmathify(percent5)
# infinite series definition: e^x = inf(x^k/K!) taken from wikipedia
principal = initial_investment
x = percent1 * compounding_frequency
principal = mpmath.nsum(lambda n: principal * ((x**n) / mpmath.fac(n)),
[0, mpmath.inf])
x = percent2 * compounding_frequency
principal = mpmath.nsum(lambda n: principal * ((x**n) / mpmath.fac(n)),
[0, mpmath.inf])
x = percent3 * compounding_frequency
principal = mpmath.nsum(lambda n: principal * ((x**n) / mpmath.fac(n)),
[0, mpmath.inf])
x = percent4 * compounding_frequency
principal = mpmath.nsum(lambda n: principal * ((x**n) / mpmath.fac(n)),
[0, mpmath.inf])
x = percent5 * compounding_frequency
principal = mpmath.nsum(lambda n: principal * ((x**n) / mpmath.fac(n)),
[0, mpmath.inf])
return principal
def CalculateCO2ForcingEquivalent(slcpTimeSeries):
CO2feTimeSeries = slcpTimeSeries.copy()
# Create the output DataFrame and add Columns for CO2fe(t) and CO2we(t) emissions and R(t) and S(t) intermediaries.
CO2feTimeSeries = slcpTimeSeries
BlankEmissions = np.zeros(len(slcpTimeSeries))
FourColumnBlankEmissions = pd.DataFrame(
np.array(
[BlankEmissions, BlankEmissions, BlankEmissions,
BlankEmissions]).transpose())
# Make Data-frames for R and S
R = pd.concat([
slcpTimeSeries[{'Year', 'SLCP'}],
pd.DataFrame(FourColumnBlankEmissions)
],
axis=1)
R['Total'] = BlankEmissions
S = pd.concat([
slcpTimeSeries[{'Year', 'SLCP'}],
pd.DataFrame(FourColumnBlankEmissions)
],
axis=1)
S['Total'] = BlankEmissions
# Compute the CO2fe values for each year
for i in CO2feTimeSeries.index:
for k in Constants.DECAY_CONSTANTS.index:
# Compute S(i) and enter that value for the current i (Year)
S.loc[i, k] = mp.nsum(
lambda j: CO2feTimeSeries.loc[int(j), 'SLCP'] * Dch4(k, i - j),
[0, i])
# Compute R(i) given S(i) and existing values of R(i)
R.loc[i, k] = mp.nsum(
lambda j:
(S.loc[int(j), 'Total'] - R.loc[int(j), 'Total']) * Dco2(
k, i - j), [0, i - 1])
S.loc[i, 'Total'] = mp.nsum(
lambda k: S.loc[i, k],
[0, len(Constants.DECAY_CONSTANTS.index) - 1])
R.loc[i, 'Total'] = mp.nsum(
lambda k: R.loc[i, k],
[0, len(Constants.DECAY_CONSTANTS.index) - 1])
# Compute CO2fe(i) from these values of S(i) and R(i)
CO2feTimeSeries.loc[i,
'CO2fe'] = (S.loc[i, 'Total'] - R.loc[i, 'Total'])
# # Compute CO2we
# Et = CO2feTimeSeries.loc[i, 'SLCP']
# EtMinusdt = 0
# if i > 19:
# EtMinusdt = CO2feTimeSeries.loc[int(i - 20), 'SLCP']
# CO2feTimeSeries.loc[i, 'CO2we'] = GWPH * ((r * H) / dt * (Et - EtMinusdt) + s * Et)
return CO2feTimeSeries
def _Q(n,i,k,s):
"""
Procedure Name: _Q
Purpose: Computes the single probability Pk(n,i) for an M/M/s
queue recursively.
Arguments: 1. n: The total number of customers in the system
2. i: An integer value
3. k: The number of customers in the system at time 0
4. s: The number of parallel servers
Output: 1. Pk: A single probability for an M/M/s queue
"""
rho=Symbol('rho')
if k>=1 and i==k+n:
if k>=s:
p=(rho/(rho+1))**n
elif k+n<=s:
p=(rho**n)/(nprod(lambda j: rho+(k+j-1)/s,[1,n]))
elif k<s and s<k+n:
p=(rho**n)/((rho+1)**(n-s+k)*
(nprod(lambda j: rho+(k+j-1)/s,[1,s-k])))
if k==0 and i==n:
if n<=s:
p=(rho**n)/nprod(lambda j: rho+(j-1)/s,[1,n])
elif n>s:
p=(rho**n)/((rho+1)**(n-s)*
nprod(lambda j: rho+(j-1)/s,[1,s]))
if i==1:
p=1-nsum(lambda j: _Q(n,j,k,s),[2,n+k])
if k>=1 and i>=2 and i<=k and n==1:
if k<=s:
p=rho/(rho+(i-1)/s)*nprod(lambda j:
1-rho/(rho+(k-j+1)/s),[1,k-i+1])
elif k>s and i>s:
p=rho/(rho+1)**(k-i+2)
elif i<=s and s<k:
p=rho/((rho+1)**(k-s+1)*(rho+(i-1/s))*
nprod(lambda j: 1-rho/(rho(s-j)/s),[1,s-i]))
if n>=2 and i>=2 and i<=k+n-1:
if i>s:
p=rho/(rho+1)*nsum(lambda j:
(1/(rho+1)**(j-i+1)*_Q(n-1,j,k,s)),
[i-1,k+n-1])
elif i<=s:
p=rho/(rho+(i-1)/s)*(
nsum(lambda j:
nprod(lambda h: 1-rho/(rho+(j-h+1)/s),[1,j-i+1])*
_Q(n-1,j,k,s),[i-1,s-1]) +
nprod(lambda h: 1-rho/(rho+(s-h)/s),[1,s-i]) *
nsum(lambda j: (1/(rho+1))**(j-s+1)*_Q(n-1,j,k,s),[s,k+n-1]))
return simplify(p)
def evalAllF2(x):
if spn.config["families"][f2] == "poisson":
return nsum(lambda f2val: evspn(x, f2val), [0, inf],
verbose=False,
method="d")
if spn.config["families"][f2] == "isotonic":
return sum(map(lambda f2val: evspn(x, f2val), f2range))
global inner
if spn.config["featureTypes"][f2] == "continuous":
minv = numpy.min(f2domains)
maxv = numpy.max(f2domains)
integral = integrate.quad(lambda f2val: evspn(x, f2val),
minv,
maxv,
limit=30,
maxp1=30,
limlst=30)
print(outer, inner, x, integral)
inner += 1
return integral[0]
#return nsum(lambda f2val: evspn(x,f2val), [minv, maxv], verbose=False, method="d", tol=10 ** (-10))
else:
return sum(map(lambda f2val: evspn(x, f2val), f2domains))
def pdf(x, df, nc):
"""
Probability density function of the noncentral t distribution.
The infinite series is estimated with `mpmath.nsum`.
"""
with mpmath.extradps(5):
x = mpmath.mpf(x)
df = mpmath.mpf(df)
nc = mpmath.mpf(nc)
if x == 0:
logp = (-nc**2 / 2 - mpmath.log(mpmath.pi) / 2 -
mpmath.log(df) / 2 + mpmath.loggamma(
(df + 1) / 2) - mpmath.loggamma(df / 2))
p = mpmath.exp(logp)
else:
logc = (df * mpmath.log(df) / 2 - nc**2 / 2 -
mpmath.loggamma(df / 2) - mpmath.log(mpmath.pi) / 2 -
(df + 1) / 2 * mpmath.log(df + x**2))
c = mpmath.exp(logc)
def _pdf_term(i):
logterm = (mpmath.loggamma(
(df + i + 1) / 2) + i * mpmath.log(x * nc) +
i * mpmath.log(2 / (df + x**2)) / 2 -
mpmath.loggamma(i + 1))
return mpmath.exp(logterm).real
s = mpmath.nsum(_pdf_term, [0, mpmath.inf])
p = c * s
return p
def _calculate_constant(self):
"""
Calculates the normalization constant.
:rtype:
"""
return power(nsum(lambda n: self._internal_function(n) * power(n, -self._alpha), [1, inf],
method=self._summation_method), -1)
def computeMI2(spn, f1, f2, verbose=False):
Pxy = spn.marginalizeToEquation([f1, f2])
Px = spn.marginalizeToEquation([f1])
Py = spn.marginalizeToEquation([f2])
sumIxy = "{Pxy} * (log({Pxy})/log(2) - (log({Px})/log(2) + log({Py})/log(2)))".format(
**{
'Pxy': Pxy,
'Px': Px,
'Py': Py
})
# evl = lambda x, y: eval(sumIxy, None, {"x_%s_" % f1:x, "x_%s_" % f2: y, "poissonpmf":poissonpmf})
evl = compileEq(sumIxy, {
"x_%s_" % f1: "x",
"x_%s_" % f2: "y"
},
compileC=False)
Ixy = nsum(lambda x, y: evl(int(x), int(y)), [0, inf], [0, inf],
verbose=False,
method="d",
tol=10**(-10))
if verbose:
print("I(%s,%s)=%s" % (f1, f2, Ixy))
return Ixy
def computeIxy():
if spn.config["families"][f1] == "poisson":
return nsum(lambda f1val: evalAllF2(f1val), [0, inf],
verbose=False,
method="d")
if spn.config["families"][f1] == "isotonic":
#print(list(range(minv, maxv)))
return sum(map(lambda f1val: evalAllF2(f1val), f1range))
global outer
global inner
if spn.config["featureTypes"][f1] == "continuous":
minv = numpy.min(f1domains)
maxv = numpy.max(f1domains)
inner = 0
integral = integrate.quad(lambda f1val: evalAllF2(f1val),
minv,
maxv,
limit=30,
maxp1=30,
limlst=30)
print(outer, inner, integral)
outer += 1
return integral[0]
#return nsum(lambda f1val: evalAllF2(f1val), [minv, maxv], verbose=False, method="d", tol=10 ** (-10))
else:
return sum(map(lambda f1val: evalAllF2(f1val), f1domains))
def U(u, v, n):
"""
Two-variables Lommel function "U" of order "n".
"""
def seq(s):
return (-1)**s * (u / v)**(n + 2 * s) * mp.besselj(n + 2 * s, v)
return mp.nsum(seq, [0, mp.inf])
def pi_mpmath(n):
"""Calculate PI to the Nth digit.
I figured using mpmath would work well, but this is not very
efficient. With n = 1000, it took over a minute on my laptop.
"""
mp.dps = n
return str(nsum(lambda k: (4/(8*k+1) - 2/(8*k+4) - 1/(8*k+5) - 1/(8*k+6)) / 16**k, (0, inf)))
def bell_approx(n): # Dobinski's formula - nth moment of poisson distribution with E[x]=1
'''
:param n: natural number
:return: nth Bell number
'''
mpmath.mp.dps = 50
return int(round((1/math.e) * mpmath.nsum(lambda x: math.pow(x,n)/math.factorial(x), [0, mpmath.inf])))
def chi(v, z):
'''
:param v:
:param z:
:return: Legendre chi function
'''
return mpmath.nsum(lambda k: pow(z, 2 * k + 1) / pow(2 * k + 1, v),
[0, mpmath.inf])
def dtheta_t3_func(k_v, R_v, alpha_v, theta_v):
'''
'''
version_with_freen = dtheta_t3_oneterm.subs({'k': k_v,
'R': R_v,
'alpha': alpha_v,
'theta': theta_v})
freen_func = lambdify([n], version_with_freen, 'mpmath')
return mpmath.nsum(freen_func, [2, mpmath.inf])
def a1(S):
def sum_item(i):
z = (4 * i + 1)**2 / (16 * S)
val1 = gamma(i + 0.5) * sqrt(4 * i + 1) / (gamma(0.5) * gamma(i + 1)) * exp(-z)
val2 = I(-0.25, z) - I(0.25, z)
return val1 * val2
ITER_MAX = 5
result = float(nsum(sum_item, [0, ITER_MAX])) / sqrt(2 * S)
return result
def pi_compute(n):
"""
>>> pi_compute(50)
'3.1415926535897932384626433832795028841971693993751'
"""
mp.dps = n # accuracy
return str(
nsum(
lambda k: (4 / (8 * k + 1) - 2 / (8 * k + 4) - 1 /
(8 * k + 5) - 1 / (8 * k + 6)) / 16**k, (0, inf)))
def getNthMenageNumber( n ):
if n < 0:
raise ValueError( '\'menage\' requires a non-negative argument' )
elif n in [ 1, 2 ]:
return 0
elif n in [ 0, 3 ]:
return 1
else:
return nsum( lambda k: fdiv( fprod( [ power( -1, k ), fmul( 2, n ), binomial( fsub( fmul( 2, n ), k ), k ),
fac( fsub( n, k ) ) ] ), fsub( fmul( 2, n ), k ) ), [ 0, n ] )
def bessel_function(L, x):
# this expression is the python implementation of the expression for the bessel function of the first kind from the following link:
# https://keisan.casio.com/exec/system/1180573472
val = nsum(
lambda k: ((-1)**k) / (math.factorial(k) * math.gamma(L + k + 1)) *
((x / 2)**(L + 2 * k)), [0, inf])
return val
def canonical_ensemble(V):
"""Calculate the cononical ensemble of the system
Z = sum [ exp( - E_i * beta ) ]
Args
----
V (float) : Volume of the system,
"""
return float(mp.nsum(lambda x: mp.exp(-beta*Ei(x, V)), [0,mp.inf], method='s+r'))
def pi_mpmath(n):
"""Calculate PI to the Nth digit.
I figured using mpmath would work well, but this is not very
efficient. With n = 1000, it took over a minute on my laptop.
"""
mp.dps = n
return str(
nsum(
lambda k: (4 / (8 * k + 1) - 2 / (8 * k + 4) - 1 /
(8 * k + 5) - 1 / (8 * k + 6)) / 16**k, (0, inf)))
def kolmogorov_test(x, m, alpha):
n = len(x)
sort_x = sorted(x)
# Масимальнуая разность между накопленными частотами
D = calc_D(sort_x, m)
n = len(sort_x)
# Расчёт значения статистики критерия хи-квадрат
S = (n * D + 1) / sqrt(n)
S_alpha = 1 - nsum(lambda k: (-1)**k * exp(-2 * k**2 * S**2), [-inf, inf])
passed = alpha < S_alpha
return n, m, D, S, S_alpha, passed
def DedekindEta(tau):
''' Compute the Dedekind Eta function for imaginary argument tau.
See: http://mathworld.wolfram.com/DedekindEtaFunction.html. '''
try:
import mpmath as mp
mpmath_loaded = True
except ImportError:
mpmath_loaded = False
qbar = mp.exp(-2.0*mp.pi*tau)
return mp.nsum(lambda n: ((-1)**n)*(qbar**((6*n-1)*(6.0*n-1)/24)),[-mp.inf,mp.inf])
def moment_i0(a, j):
'''
Calculates the j-th moment of phi_0
Wavelet Analysis: The Scalable Structure of Information (2002)
Howard L. Resnikoff, Raymond O.Jr. Wells
page 262
'''
N = a.size
if j == 0:
return 1
s = mpmath.nsum(lambda k: binomial(j,k)*moment_i0(a, k)*
mpmath.nsum(lambda i: a[int(i)]*mpmath.power(i, j-k),
[0, N-1]),
[0, j-1])
_2 = mp.mpmathify(2)
return s/(_2*(mpmath.power(_2, j)-1))
def mp_wright_bessel(a, b, x, dps=50, maxterms=2000):
"""Compute Wright's generalized Bessel function as Series with mpmath.
"""
with mp.workdps(dps):
a, b, x = mp.mpf(a), mp.mpf(b), mp.mpf(x)
res = mp.nsum(
lambda k: x**k / mp.fac(k) * rgamma_cached(a * k + b, dps=dps),
[0, mp.inf],
tol=dps,
method='s',
steps=[maxterms])
return mpf2float(res)
def computeExpectation(spn, f1, verbose=False):
Px = spn.marginalizeToEquation([f1])
sumEx = "x * {Px}".format(**{'Px': Px})
evl = compileEq(sumEx, {"x_%s_" % f1: "x"})
Ex = nsum(lambda x: evl(int(x)), [0, inf], verbose=False, method="d", tol=10 ** (-10))
if verbose:
print("E(%s)=%s" % (f1, Ex))
return Ex
def computeExpectation2(spn, f1, f2, verbose=False):
Pxy = spn.marginalizeToEquation([f1, f2]).replace("x_%s_" % f1, "x").replace("x_%s_" % f2, "y")
sumExy = "(x * y) * {Pxy}".format(**{'Pxy': Pxy})
evl = compileEq(sumExy, {"x_%s_" % f1: "x", "x_%s_" % f2: "y"})
Exy = nsum(lambda x, y: evl(int(x), int(y)), [0, inf], [0, inf], verbose=False, method="d", tol=10 ** (-10))
if verbose:
print("E(%s, %s)=%s" % (f1, f2, Exy))
return Exy
def computeEntropy2(spn, f1, f2, verbose=False):
Pxy = spn.marginalizeToEquation([f1, f2])
sumHxy = "{Pxy} * log({Pxy})/log(2)".format(**{'Pxy': Pxy})
evl = compileEq(sumHxy, {"x_%s_" % f1: "x", "x_%s_" % f2: "y"})
# evl = lambda x, y: eval(sumHxy, None, {"x_%s_" % f1:x, "x_%s_" % f2: y, "poissonpmf": poissonpmf})
Hxy = -nsum(lambda x, y: evl(int(x), int(y)), [0, inf], [0, inf], verbose=False, methomethod="d", tol=10 ** (-10))
if verbose:
print("H(%s,%s)=%s" % (f1, f2, Hxy))
return Hxy
def nRCS(self, n='richardson+shanks', kind='isotropic gaussian', db=False):
"""Normalized Radar cross-section"""
def _nRCS(self, pp, n, kind):
n = float(n)
return self.wk**2 * exp(-2*(self.sh*self.wk_z)**2) /2 * \
( self.sh**(2*n) * abs( self.I(n)[pp] )**2 * \
roughness.spectrum(self.wk, self.sh, self.cl, self.th, \
n=n, kind=kind) / factorial(n) )
if type(n) is not str:
vv = nsum(lambda x: _nRCS(self, 'vv', x, kind), [1, n])
hh = nsum(lambda x: _nRCS(self, 'hh', x, kind), [1, n])
if type(n) is str:
vv = nsum(lambda x: _nRCS(self, 'vv', x, kind), [1, inf], method=n)
hh = nsum(lambda x: _nRCS(self, 'hh', x, kind), [1, inf], method=n)
vv, hh = float64(vv), float64(hh)
if db:
vv, hh = 10 * log10(vv), 10 * log10(hh)
return {'vv': vv, 'hh': hh}
def computeEntropy(spn, f1, verbose=False):
Px = spn.marginalizeToEquation([f1])
sumHxy = "{Px} * log({Px})/log(2)".format(**{'Px': Px})
evl = compileEq(sumHxy, {"x_%s_" % f1: "x"})
Hx = -nsum(lambda x: evl(int(x)), [0, inf], verbose=False, method="d", tol=10 ** (-10))
if verbose:
print("H(%s)=%s" % (f1, Hx))
return Hx
def nRCS(self, n='richardson+shanks', kind='isotropic gaussian', db=False):
"""Normalized Radar cross-section"""
def _nRCS(self, pp, n, kind):
n = float(n)
return self.wk**2 * exp(-2*(self.sh*self.wk_z)**2) /2 * \
( self.sh**(2*n) * abs( self.I(n)[pp] )**2 * \
roughness.spectrum(self.wk, self.sh, self.cl, self.th, \
n=n, kind=kind) / factorial(n) )
if type(n) is not str:
vv = nsum(lambda x: _nRCS(self, 'vv', x, kind), [1,n] )
hh = nsum(lambda x: _nRCS(self, 'hh', x, kind), [1,n] )
if type(n) is str:
vv = nsum(lambda x: _nRCS(self, 'vv', x, kind), [1,inf], method=n)
hh = nsum(lambda x: _nRCS(self, 'hh', x, kind), [1,inf], method=n)
vv, hh = float64(vv), float64(hh)
if db :
vv, hh = 10*log10(vv), 10*log10(hh)
return {'vv':vv, 'hh':hh}
def cramerVonMises(x, y):
try:
x = sorted(x)
y = sorted(y)
pool = x + y
ps, pr = _sortRank(pool)
rx = array([pr[ind] for ind in [ps.index(element) for element in x]])
ry = array([pr[ind] for ind in [ps.index(element) for element in y]])
n = len(x)
m = len(y)
i = array(range(1, n + 1))
j = array(range(1, m + 1))
u = n * sum(power((rx - i), 2)) + m * sum(power((ry - j), 2))
t = u / (n * m * (n + m)) - (4 * n * m - 1) / (6 * (n + m))
Tmu = 1 / 6 + 1 / (6 * (n + m))
Tvar = 1 / 45 * ((m + n + 1) / power(
(m + n), 2)) * (4 * m * n * (m + n) - 3 *
(power(m, 2) + power(n, 2)) - 2 * m * n) / (4 * m *
n)
t = (t - Tmu) / power(45 * Tvar, 0.5) + 1 / 6
if t < 0:
return -1
elif t <= 12:
a = 1 - mp.nsum(
lambda x:
(mp.gamma(x + 0.5) /
(mp.gamma(0.5) * mp.fac(x))) * mp.power(4 * x + 1, 0.5) * mp.
exp(-mp.power(4 * x + 1, 2) /
(16 * t)) * mp.besselk(0.25,
mp.power(4 * x + 1, 2) / (16 * t)),
[0, 100]) / (mp.pi * mp.sqrt(t))
return float(mp.nstr(a, 3))
else:
return 0
except Exception as e:
print e
return -1
def cdf(x, dfn, dfd, nc):
"""
CDF of the noncentral F distribution.
"""
if x < 0:
return _mp.mp.zero
def _cdfk(k):
return _cdf_term(k, x, dfn, dfd, nc)
with _mp.extradps(5):
x = _mp.mpf(x)
dfn = _mp.mpf(dfn)
dfd = _mp.mpf(dfd)
nc = _mp.mpf(nc)
p = _mp.nsum(_cdfk, [0, _mp.inf])
return p
def internal_energy(V):
"""Average internal energy of the system
E = E(V) Internal energy states of the SHO change depending on volume
Calculates:
<E> = sum [ E_i exp( - E_i * beta ) ]/ Z
w/ Z = Z(V) = cononical enbsemble
Args
---
V (float) : Volume of the system,
"""
return float(mp.nsum(
lambda x: Ei(x, V) * mp.exp(-beta*Ei(x, V)), [0,mp.inf], method='s+r')
/ canonical_ensemble(V) )
def test_cf(dist, support_lower_limit, support_upper_limit):
pdf = density(dist)
t = S('t')
x = S('x')
# first function is the hardcoded CF of the distribution
cf1 = lambdify([t], characteristic_function(dist)(t), 'mpmath')
# second function is the Fourier transform of the density function
f = lambdify([x, t], pdf(x)*exp(I*x*t), 'mpmath')
cf2 = lambda t: mpmath.nsum(lambda x: f(x, t), [support_lower_limit, support_upper_limit], maxdegree=10)
# compare the two functions at various points
for test_point in [2, 5, 8, 11]:
n1 = cf1(test_point)
n2 = cf2(test_point)
assert abs(re(n1) - re(n2)) < 1e-12
assert abs(im(n1) - im(n2)) < 1e-12
def moment(a, i, j):
'''
Calculates the j-th moment of phi_i
Wavelet Analysis: The Scalable Structure of Information (2002)
Howard L. Resnikoff, Raymond O.Jr. Wells
page 262
'''
N = a.size
assert j > -1
if j == 0:
return 1 if i == 0 else 0
if i == 0:
return moment_i0(a, j)
return mpmath.nsum(lambda k: binomial(j,k)*mpmath.power(i, (j-k))*moment_i0(a, k), [0, j])
def getNthMenageNumber(n):
'''https://oeis.org/A000179'''
if n == 1:
return -1
if n == 2:
return 0
if n in [0, 3]:
return 1
return nsum(
lambda k: fdiv(
fprod([
power(-1, k),
fmul(2, n),
binomial(fsub(fmul(2, n), k), k),
fac(fsub(n, k))
]), fsub(fmul(2, n), k)), [0, n])
def hypsum(expr, n, start, prec):
"""
Sum a rapidly convergent infinite hypergeometric series with
given general term, e.g. e = hypsum(1/factorial(n), n). The
quotient between successive terms must be a quotient of integer
polynomials.
"""
from sympy import Float, hypersimp, lambdify
if prec == float('inf'):
raise NotImplementedError('does not support inf prec')
if start:
expr = expr.subs(n, n + start)
hs = hypersimp(expr, n)
if hs is None:
raise NotImplementedError("a hypergeometric series is required")
num, den = hs.as_numer_denom()
func1 = lambdify(n, num)
func2 = lambdify(n, den)
h, g, p = check_convergence(num, den, n)
if h < 0:
raise ValueError("Sum diverges like (n!)^%i" % (-h))
term = expr.subs(n, 0)
if not term.is_Rational:
raise NotImplementedError("Non rational term functionality is not implemented.")
# Direct summation if geometric or faster
if h > 0 or (h == 0 and abs(g) > 1):
term = (MPZ(term.p) << prec) // term.q
s = term
k = 1
while abs(term) > 5:
term *= MPZ(func1(k - 1))
term //= MPZ(func2(k - 1))
s += term
k += 1
return from_man_exp(s, -prec)
else:
alt = g < 0
if abs(g) < 1:
raise ValueError("Sum diverges like (%i)^n" % abs(1/g))
if p < 1 or (p == 1 and not alt):
raise ValueError("Sum diverges like n^%i" % (-p))
# We have polynomial convergence: use Richardson extrapolation
vold = None
ndig = prec_to_dps(prec)
while True:
# Need to use at least quad precision because a lot of cancellation
# might occur in the extrapolation process; we check the answer to
# make sure that the desired precision has been reached, too.
prec2 = 4*prec
term0 = (MPZ(term.p) << prec2) // term.q
def summand(k, _term=[term0]):
if k:
k = int(k)
_term[0] *= MPZ(func1(k - 1))
_term[0] //= MPZ(func2(k - 1))
return make_mpf(from_man_exp(_term[0], -prec2))
with workprec(prec):
v = nsum(summand, [0, mpmath_inf], method='richardson')
vf = Float(v, ndig)
if vold is not None and vold == vf:
break
prec += prec # double precision each time
vold = vf
return v._mpf_
