def rho(beta, mk, K, N):
"""
rho(beta, data) is the Dirichlet multinomial likelihood.
rho(beta, data) together with the d_xi(beta) make up
the posterior for the nsb estimator
"""
return np.prod([mp.power(mp.rf(beta, np.double(n)), mk[n])
for n in mk]) / mp.rf(K * beta, np.double(N))
def compute_g(n):
"""g_k from DLMF 5.11.3/5.11.5"""
a = compute_a(2*n)
g = []
for k in range(n):
g.append(mp.sqrt(2)*mp.rf(0.5, k)*a[2*k])
return g
def _get_value(self, x, mu, v):
try:
return rf(v, x) / gamma(x + 1) * (v / float(v + mu))**v * (
mu / float(v + mu))**x
except ValueError:
print(x, mu, v, file=sys.stderr)
return 1
def o_function(l, k, r):
res = mpmath.hyp1f1(-1j / k + l, 2 * l + 2, -2 * 1j * k * r)
res *= (1. / (2 * l + 1)) * (k * r)**l
res *= mpmath.gamma(1 + 1j / k)
res *= mpmath.rf(-1j / k, l)
res *= (-2j)**l / mpmath.fac(2 * l)
res *= mpmath.exp(mpmath.pi / (2 * k))
return res
def revert(coeffs, taylor=True):
"""
Series reversion.
Given `coeffs`, the Taylor coefficients of a function, find the
Taylor coefficients of the compositional inverse of the function.
The calculation here is based on the formulas for the coefficients
of the inverse in terms of Bell polynomials:
https://en.wikipedia.org/wiki/Bell_polynomials#Reversion_of_series
If the argument `taylor` is True, the coefficients must be the
Taylor series coefficients. If it is not True, the coefficients
are the derivatives. That is, they are the Taylor coefficients
multiplied by the factorial terms.
"""
c0 = coeffs[0]
if coeffs[1] == 0:
raise ValueError('coeffs[1] must be nonzero.')
if taylor:
# Rescale the coefficients to the derivative values.
f = [c * mpmath.factorial(i) for i, c in enumerate(coeffs)]
else:
f = coeffs
m = len(f)
f_hat = [f[k + 1] / ((k + 1) * f[1]) for k in range(1, m - 1)]
# inv_derivs will be the series of derivatives of the inverse.
g = [0] * m
g[1] = 1 / f[1]
for n in range(2, m):
s = sum((-1)**k * mpmath.rf(n, k) *
_bell_incomplete_poly(n - 1, k, f_hat[:n - k])
for k in range(1, n))
g[n] = s / f[1]**n
if taylor:
# Convert the derivatives to the Taylor coefficients
inv_coeffs = [c / mpmath.factorial(k) for k, c in enumerate(g)]
else:
inv_coeffs = g
return inv_coeffs, c0
def _rhoi(x, nxkx, beta): return power(rf(beta, np.double(x)), nxkx[x])
def log_likelihood_DP_alpha(a, K1, N):
"""
Alpha-dependent terms of the log-likelihood of a Dirichlet Process.
"""
return (K1 - 1.) * mp.log(a) - mp.log(mp.rf(a + 1., N - 1.))
def _logvarrho_DP(a, rnsum, K1, N):
return rnsum + _logprod_DP(a, K1) - mp.log(mp.rf(a + 1., N - 1.))
def _logvarrhoi_DP(n, mk):
return mp.log(mp.rf(1., n - 1.)) * mk[n]
def _rho(beta, mk, K,
N): # Computes the Dirichlet-multinomial likelihood from eq. (68)
rn = np.array([_rhoi(n, beta, mk, K, N) for n in mk])
return rn.prod() / mp.rf(K * beta, np.double(N))
def _rho(beta, nxkx, N, K):
kappa = beta * K
rx = np.array([_rhoi(x, nxkx, beta) for x in nxkx])
return rx.prod() / rf(kappa, np.double(N))
def _rhoi(x, nxkx, beta):
return power(rf(beta, np.double(x)), nxkx[x])
def _rhoi(x, nxkx, beta):
return power(rf(beta, float(x)), float(nxkx[x]))
def _rho(beta, nxkx, N, K): # this is p(B|c)*log(m)/p(B)
kappa = beta * K
rx = np.array([_rhoi(x, nxkx, beta) for x in nxkx])
return rx.prod() / rf(kappa, np.double(N))
def _rho(beta, nxkx, N, K):# this is p(B|c)*log(m)/p(B) kappa = beta*K rx = np.array([_rhoi(x, nxkx, beta) for x in nxkx]) return rx.prod()/rf(kappa, np.double(N))
def _get_value(self, x, mu, v):
try:
return rf(v, x) / gamma(x+1) * ( v/float(v+mu) ) ** v * ( mu/float(v+mu) ) ** x
except ValueError:
print(x, mu, v, file=sys.stderr)
return 1
def _rhoi(n, beta, mk, K,
N): # Computes the ratio of gamma functions in the product
return mp.power(mp.rf(beta, np.double(n)), mk[n])
