def leaves_symbolic():
n_min = 0
n_max = 5
t = np.zeros(n_max + 1)
c = np.zeros(n_max + 1)
for n in xrange(n_min, n_max + 1):
t[n] = special.binom(2 * n, n) / (n + 1)
c[n] = 0 if n < 1 else special.binom(2 * n - 2, n - 1)
print "Calculated from solutions:"
for n in xrange(n_min, n_max + 1):
print "t[{0}] = {1}, c[{2}] = {3}".format(n, t[n], n, c[n])
z = sp.symbols("z")
t_of_z = 0
c_of_z = 0
for n in xrange(n_min, n_max + 1):
t_of_z += t[n] * z ** n
c_of_z += c[n] * z ** n
print "T(z):"
sp.pprint(t_of_z)
print "C(z):"
sp.pprint(c_of_z)
print "z + 2 z T(z) C(z):"
sp.pprint(sp.expand(sp.simplify(z + 2 * z * t_of_z * c_of_z)))
def bin_bals(): mili_p_s = 1000 s_p_m = 60 m_p_h = 60 h_p_d = 24 d_p_y = 365 bins = 10 *s_p_m * m_p_h * h_p_d *d_p_y rates = [1,5,10,15,20,25,30,35,40,45,50,55,60] collisions_10= [(special.binom(mph * h_p_d*d_p_y,2) *1.0/ bins) for mph in rates] bins = 100 *s_p_m * m_p_h * h_p_d *d_p_y collisions_100= [(special.binom(mph * h_p_d*d_p_y,2) *1.0/ bins) for mph in rates] bins = 1000 *s_p_m * m_p_h * h_p_d *d_p_y collisions_1000= [(special.binom(mph * h_p_d*d_p_y,2) *1.0/ bins) for mph in rates] bins = 1 *s_p_m * m_p_h * h_p_d *d_p_y collisions_1= [(special.binom(mph * h_p_d*d_p_y,2) *1.0/ bins) for mph in rates] plt.plot(rates,collisions_1,'ko',label='1 second') plt.plot(rates,collisions_10,'bo',label='1/10 of a second') plt.plot(rates,collisions_100,'ro',label='1/100 of a second') plt.plot(rates,collisions_1000,'yo',label='1/1000 of a second') plt.gca().legend(loc='upper left',shadow=True) plt.show() for i in xrange(len(rates)): print "%s : %s"%(rates[i],collisions[i])
def restricted_composition(n,k,h,p): result = 0 #Formula C if isinstance(h,int)and isinstance(p,int) and p!=n and h!=1: for j in range(0,k+1): result = result + summation_term_c32(k,j,n,h,p) #Formula 3.2 elif isintance(h,list) and isinstance(p,list): diff = [j-i for i,j in zip(h,p)] result = special.binom(n-sum(h)+k-1,k-1) for j in range(1,k+1): result = result + summation_term_32(n,k,j,sum(h),diff) #Formula A elif isinstance(h,list) and isinstance(p,int) and p==n: nom = 0 for i in h: nom += i result = special.binom(n+k-1-nom,k-1) #Formula B elif isinstance(p,list) and h==1: result = special.binom(n-1,k-1) for j in range(1,k+1): result = result + summation_term_b3(n,k,j,p) #Formula D elif isinstance(h,int) and p==n: result = special.binom(n-k*(t-1)-1,k-1) #Formula E elif h==1 and isinstance(p,int): for j in range(0,k+1): result = math.pow(-1,j)*special.binom(k,j)*(n-j*p-1,k-1) print result
def _contingency(self):
""" Compute TP, FP, TN, and FN
for any pair of points.
"""
tp_fp, tp = 0.0, 0.0
tn_fn, fn = 0.0, 0.0
for i, v1 in enumerate(self.ysize[:, :]):
c1, n1 = v1
imemb1 = self._get_members(c1)
gsub1 = self.g[imemb1]
if n1 >= 1:
tp_fp += sp.binom(n1, 2)
for j in np.unique(gsub1):
size_ij = np.sum(gsub1 == j)
if size_ij >= 2:
tp += sp.binom(size_ij, 2)
size_j = np.sum(self.g == j)
fn += size_ij * (size_j - size_ij)
# print("%d %d %d %d\t\t%d"%(j, size_j, size_ij, size_ij*(size_j-size_ij), fn))
if i < self.ysize.shape[0] - 1:
tn_fn += n1 * np.sum(self.ysize[i + 1 :, 1])
self.tp = tp
self.fp = tp_fp - tp
fn = fn / 2
self.tn = tn_fn - fn
self.fn = fn
# sys.stderr.write("TP: %.0f FP: %.0f \t TN: %.0f FN: %.0f\n"%(self.tp,self.fp,self.tn,self.fn))
return None
def expected_number_of_transactions_in_first_n_periods(self, n):
"""
Expected number of transactions occurring across first n transaction opportunities. Used by Fader
and Hardie to assess in-sample fit.
Pr(X(n) = x|alpha, beta, gamma, delta)
See (7) in Fader & Hardie 2010.
Parameters:
n: scalar, number of transaction opportunities
Returns: DataFrame of predicted values, indexed by x
"""
params = self._unload_params('alpha', 'beta', 'gamma', 'delta')
alpha, beta, gamma, delta = params
x_counts = self.data.groupby('frequency')['n_custs'].sum()
x = asarray(x_counts.index)
p1 = special.binom(n, x) * exp(special.betaln(alpha + x, beta + n - x) - special.betaln(alpha, beta) +
special.betaln(gamma, delta + n) - special.betaln(gamma, delta))
for j in np.arange(x.shape[0]):
i = np.arange(x[j], n)
p2 = np.sum(special.binom(i, x[j]) *
exp(special.betaln(alpha + x[j], beta + i - x[j]) - special.betaln(alpha, beta) +
special.betaln(gamma +1, delta + i) - special.betaln(gamma, delta)))
p1[j] += p2
idx = pd.Index(x, name='frequency')
return DataFrame(p1 * x_counts.sum(), index=idx, columns=['model'])
def mcnf_kernel(R, d, c, norm=True):
n, m = R.size
x_choose_d = {n : binom(n, d)}
nCd = x_choose_d[n]
X = R.T*R
if c == d == 1:
K = X
else:
K = co.matrix(0.0, (m, m))
for i in range(m):
#if (i+1) % 100 == 0:
# print "%d/%d" %(i+1,m)
for j in range(i, m):
xii = n - int(X[i,i])
if xii not in x_choose_d:
x_choose_d[xii] = binom(xii, d)
xjj = n - int(X[j,j])
if xjj not in x_choose_d:
x_choose_d[xjj] = binom(xjj, d)
xij = n - int(X[i,i]) - int(X[j,j]) + int(X[i,j])
if xij not in x_choose_d:
x_choose_d[xij] = binom(xij, d)
r = nCd - x_choose_d[xii] - x_choose_d[xjj] + x_choose_d[xij]
K[i,j] = K[j,i] = binom(r, c)
return force_normalize(K) if norm else K
def satisfy_campi_garatti_condition_raw(dimension, sample_size, drop_size,
chance_constraint_rhs, confidence):
return (spsp.binom(drop_size + dimension - 1, drop_size) *
np.sum([spsp.binom(sample_size, i) *
chance_constraint_rhs**i *
(1. - chance_constraint_rhs)**(sample_size - i)
for i in range(drop_size + dimension - 1)])) < confidence
def boxspline_gen(x1,x2,n,r1,r2):
print(x1[5,5], x2[5,5])
det = r1[0]*r2[1]-r1[1]*r2[0]
x1 = -abs(x1); x2 = abs(x2);
u = 1./det*( r2[1]*x1 - r2[0]*x2)
v = 1./det*(-r1[1]*x1 + r1[0]*x2)
ind = where(v>0)
v[ind] = -v[ind]
u[ind]=u[ind]+v[ind]
ind = where(v>u/2)
v[ind]=u[ind]-v[ind]
print(u[5,5], v[5,5])
val=np.zeros(np.shape(x1))
for K in range(-n,n+1) :#mceil(u.max())):
for L in range(-n,n+1) :#mceil(v.max())) :
for i in range(0,min(n+K, n+L)+1):
coeff=(-1.)**(K+L+i)*binom(n,i-K)*binom(n,i-L)*binom(n,i)
for d in range (0,n) :
aux=abs(2./sqrt(3.)*(r1[1]*u+r2[1]*v)+K-L)
aux2=(2.*(r1[0]*u+r2[0]*v)-K-L-aux)/2
aux2[where(aux2<0)]=0
val = val + coeff*binom(n-1+d,d)/factorial(2*n-1+d)/factorial(n-1-d)\
* aux**(n-1-d)\
* aux2**(2*n-1+d)
print(val[4:7,4:7])
return val
def cic_decim_bit_truncation(in_len, out_len, decim, cic_order, cic_delay, stage):
"""Returns how many bits to truncate from a stage in a CIC decmiator."""
# Use the nomenclature from Hogenauer
N = cic_order
M = cic_delay
R = decim
Bin = in_len
Bout = out_len
# First define the CIC impulse response function
ha = lambda j, k: sum([( (-1)**l * binom(N, l) * binom(N - j + k - R * M * l, k - R * M * l)) for l in range(0, int(math.floor(k / (R * M)) + 1))])
hb = lambda j, k: (-1)**k * binom(2 * N + 1 - j, k)
def h(j, k):
if j in range(1, N + 1):
return ha(j, k)
else:
return hb(j, k)
# This is the variance error gain at stage j
def F(j):
if j in range(1, 2 * N + 1):
return math.sqrt(sum([h(j, k) ** 2 for k in range(0, (R * M - 1) * N + j - 1)]))
else:
return 1.0
# Find the maximum number of bits that would be truncated
Bmax = cic_decim_max_bits(in_len, decim, cic_order, cic_delay)
B2N1 = Bmax - Bout + 1
# And find it's variance
sigma2N1 = math.sqrt((1/12.) * ((2 ** B2N1) ** 2))
sigmaT2N1 = math.sqrt((sigma2N1 ** 2) * (F(2 * N + 1) ** 2))
# Finally, compute how many bits to discard in this stage to keep the
# overall error below the final stage's truncation
return int(math.floor(-math.log(F(stage), 2) + math.log(sigmaT2N1, 2) + .5 * math.log(6./N, 2)))
def summation_term_c32(k,j,n,t,w): temp1 = math.pow(-1,j)*special.binom(k,j) nom = n-k*(t-1)+j*(t-w-1)-1 denom = k-1 if nom < denom: return 0 result = temp1*special.binom(nom,denom) return result
def B3Poly(i,n):
"""Restituisce il polinomio di Bernstein (i,n), implementato con
numpy.polynomial e usando l'espressione in serie di potenze"""
outPoly = P.Polynomial([0])
for k in range(i,n+1):
nextTerm = k*[0]
nextTerm.append((-1)**(i-k) * binom(n,i) * binom(i,k))
outPoly += nextTerm
return outPoly
def ApproximatedProbability (N, A, pattern, t): k = len(pattern) n = N - (t*k) print k,n denominator = A**N numerator = special.binom(n+t,t)*A**n print special.binom(n+t,t),A**n print 'Result:',numerator,'/',denominator,'=', return numerator / denominator
def M(j, x):
'''Probability Weighted Moments.
x must be sorted.
See [1] and eq. (32) in [2]
'''
n = len(x)
return sum([x[i-1] * binom(i-1, j)/binom(n-1, j)
for i in range(j+1, n)])/n
def clebgor(j1, j2, j, m1, m2, m):
"""
Parameters: j1, j2, j: the angular momenta input
m1, m2, m: the z components of angular momenta input
Returns: The numerical value of the Clebsch-Gordan coeffcient.
Remarks: Note that in the sum none of the binomial coeffcients
can have negative values. Thus, zmin is there to make
sure that the sums have a cut-off.
"""
zmin = int(min([j1 - m1, j2 + m2]))
J = j1 + j2 + j
return (int(m1 + m2 == m) *
int(np.abs(j1 - j2) <= j <= (j1 + j2)) *
int(np.abs(m1) <= j1) *
int(np.abs(m2) <= j2) *
int(np.abs(m) <= j) *
int((j1 + m1) >= 0.0) *
int((j2 + m2) >= 0.0) *
int((j + m) >= 0.0) *
int(J >= 0) *
np.sqrt(binom(2 * j1, J - 2 * j) *
binom(2 * j2, J - 2 * j) /
(binom(J + 1, J - 2 * j) *
binom(2 * j1, j1 - m1) *
binom(2 * j2, j2 - m2) *
binom(2 * j, j - m))) *
np.sum([(-1) ** z * binom(J - 2 * j, z) *
binom(J - 2 * j2, j1 - m1 - z) *
binom(J - 2 * j1, j2 + m2 - z) for z in range(zmin + 1)]))
def solve_for_cs(D, T, deg):
"""Takes an input series of values (D) and uses them to solve Ax = b
D = values
T = spacing between D
"""
# Create Q
# am = [1, 4, 6, 4, 1] (binomial array for deg 4)
am = np.array([[binom(deg, i) for i in range(deg + 1)]])
# cm = matrix of 1's and -1's (based on index, e.g. for even deg: 0,0 = 1; 0,1 = -1;, 0,2 = 1, etc)
cm = (1 - 2*np.mod(np.sum(np.indices((deg+1, deg+1)), axis=0), 2*np.ones((deg+1, deg+1))))
# Fix for odd deg (the array needs to be flipped... -1, 1 instead of 1, -1)
if deg % 2:
cm *= -1
# A is square binomial matrix scaled by matrix of 1's and -1s (scalar of two from differentiation)
Q = 2*am*am.T*cm
# Create R
# R is matrix of exponents for (t-1) [[8, 7, 6, 5, 4], [7, 6, 5, 4, 3], ...[4, 3, 2, 1, 0]]
R = np.flip(np.arange(deg+1) + np.arange(deg+1)[:,None])
# Create S
# S is matrix of exponents for t [[0, 1, 2, 3, 4], [1, 2, 3, 4, 5], ...[4, 5, 6, 7, 8]]
S = np.arange(deg+1) + np.arange(deg+1)[:,None]
# Matrix A
A = -1 * np.array(
[np.sum(q * (T-1)**r * T**s) for q, r, s in zip(Q.ravel(), R.ravel(), S.ravel())]
).reshape((deg+1, deg+1))
# am is 1 row matrix of binomial coefficients
am = np.array([binom(deg, i) for i in range(deg + 1)])
# bm is matrix of 1's and -1's (based on index)
bm = (-1 + 2*np.mod(np.sum(np.indices((1, deg+1)), axis=0).ravel(), 2 * np.ones((deg+1))))
# U is binomial coefficients scaled by matrix of 1's and -1's (scalar of two from differentiation)
U = 2*am*bm
V = np.arange(deg, -1, -1)
W = np.arange(deg + 1)
# Vector b
b = np.array(
[np.sum(u * (T-1)**v * D*T**w) for u, v, w in zip(U.ravel(), V.ravel(), W.ravel())]
).reshape((deg+1, 1))
# Solve Ax = b
return solve(A, b).ravel()
def MinNumPoints(self):
"""
Returns the minimum number of points still required.
"""
from scipy.special import binom
m = self.num_vars
n = 1
r = binom(m + n, n)
while r < self.num_points:
n += 1
r = binom(m + n, n)
self.degree = n
return int(r - self.num_points)
def calcprob(d, n, t, h):
"""
Return the probability for `h` hits in a roll of `n` fair, identical
`d`-sided exploding dice, where every die equal or higher to `t` is
deemed a hit.
Taken from: http://math.stackexchange.com/a/1649514/11949
"""
factor = (t-1)**n/d**(n+h)
probsum = 0.0
for k in range(0, max([h,n])+1 ):
probsum += binom(n,k) * binom(n+h-k-1, h-k) * (d*(d-t)/(t-1))**k
return factor * probsum
def chords_per_finger_count(buttons, rockers, fingers):
# print "How many ways are there to put {fingers} fingers on {buttons} buttons and {rockers} rockers?".format(fingers = fingers, buttons = buttons, rockers = rockers)
count = 0
for fingers_on_buttons in range(fingers+1):
fingers_on_rockers = fingers - fingers_on_buttons;
if fingers_on_rockers <= rockers and fingers_on_buttons <= fingers_on_buttons:
button_combinations = binom(buttons, fingers_on_buttons)
# print "There are {} ways to put {} fingers on {} buttons".format(button_combinations, fingers_on_buttons, buttons)
rocker_combinations =binom(rockers, fingers_on_rockers) * 2 ** (fingers_on_rockers)
# print "There are {} ways to put {} fingers on {} rockers".format(rocker_combinations, fingers_on_rockers, rockers)
count += button_combinations * rocker_combinations
# print "If {fingers_on_buttons} are on the buttons and {fingers_on_rockers} are on the rockers, then there are {new_possibilities} ".format(fingers_on_buttons = fingers_on_buttons, fingers_on_rockers = fingers_on_rockers, new_possibilities = button_combinations * rocker_combinations)
return count
def main():
# number of balls in a bag
N = 450
# Blue of which are of the color blue, the rest are red
Blue = 70
# we are pulling balls out at random
# the probability of succesfully pulling the ball out is mu
mu = 0.01
# if we repeat the drawing experiment very many times,
# what is the expected number of blue balls we'll manage to pull out?
expected = 0
for blue in range (Blue+1):
for n in range (blue, N+1): # n is the number of balls drawn
expected += special.binom(Blue, blue)*special.binom(N-Blue, n-blue)*math.pow(mu,n)*math.pow(1-mu, N-n)*blue
print "expected, calculated: ", expected
expectedMIT = 0
Red = N-Blue
for blue in range (Blue+1):
expectedMIT += blue*beta_binomial (blue, Blue, mu*Red, Red)
print "expectedMIT, calculated: ", expectedMIT
# now try the same thing through a simulation
bag = []
for i in range(N):
bag.append("r")
for i in range(Blue):
done = False
while not done:
rand_pos = random.randint(0,N-1)
if bag[rand_pos] == "r":
bag[rand_pos] = "b"
done = True
avg = 0.0
# say we do 1000 experiments
number_of_exps = 1000
for exp in range(number_of_exps):
count = 0
for i in range(N):
if random.random() < mu:
# we have chosen this position ("pulled out this ball")
if bag[i] == "b": count +=1
avg += count
avg /= number_of_exps
print "avg in the experiment: ", avg
def spin_q_function(rho, theta, phi):
"""Husimi Q-function for spins.
Parameters
----------
state : qobj
A state vector or density matrix for a spin-j quantum system.
theta : array_like
theta-coordinates at which to calculate the Q function.
phi : array_like
phi-coordinates at which to calculate the Q function.
Returns
-------
Q, THETA, PHI : 2d-array
Values representing the spin Q function at the values specified
by THETA and PHI.
"""
if rho.type == 'bra':
rho = rho.dag()
if rho.type == 'ket':
rho = ket2dm(rho)
J = rho.shape[0]
j = (J - 1) / 2
THETA, PHI = meshgrid(theta, phi)
Q = np.zeros_like(THETA, dtype=complex)
for m1 in arange(-j, j+1):
Q += binom(2*j, j+m1) * cos(THETA/2) ** (2*(j-m1)) * sin(THETA/2) ** (2*(j+m1)) * \
rho.data[int(j-m1), int(j-m1)]
for m2 in arange(m1+1, j+1):
Q += (sqrt(binom(2*j, j+m1)) * sqrt(binom(2*j, j+m2)) *
cos(THETA/2) ** (2*j-m1-m2) * sin(THETA/2) ** (2*j+m1+m2)) * \
(exp(1j * (m2-m1) * PHI) * rho.data[int(j-m1), int(j-m2)] +
exp(1j * (m1-m2) * PHI) * rho.data[int(j-m2), int(j-m1)])
return Q.real, THETA, PHI
def numberOfMacroStates(NA,NB,q):
numMacrostates = np.zeros(q+1)
probability = np.zeros_like(numMacrostates)
for i in range(q+1):
qa = i
qb = q-qa
numMacrostates[i] = binom(qa + NA -1,qa)*binom(qb + NB -1,qb)
probability = numMacrostates/np.sum(numMacrostates)
return numMacrostates, probability
def holo_diff_first_order(x,y,N):
from numpy import zeros
M = (N-1)/2
m = (N-3)/2
out = zeros(x.shape[0])
L=len(x)
for k in np.arange(1,M+1,1):
zaehler = y[M+k:L-M+k] - y[M-k:L-M-k]
nenner = x[M+k:L-M+k] - x[M-k:L-M-k]
nenner[ np.where(nenner == 0) ] = 1e-3 #to avoid trouble when x is constant
c = (binom(2*m , m -k +1) - binom(2*m,m-k-1)) / 2**(2*m+1)
out[M:-M] = out[M:-M] + 2 * k * c * zaehler/nenner
return out
def mSel(a, mu, s, k, m):
hyperg = hyp1f1(k + mu, m + 2.0 * mu, s)
ret = binom(m, k)
ret /= zSel(a, mu, s)
ret *= math.exp(gammaln(k + mu) + gammaln(m - k + mu) - gammaln(m + 2.0 * mu))
ret *= (1.0 - math.exp(-(1.0 - a) * s) * hyperg)
return ret
def pdf(self):
r"""
Generate the vector of probabilities for the Beta-binomial
(n, a, b) distribution.
The Beta-binomial distribution takes the form
.. math::
p(k \,|\, n, a, b) =
{n \choose k} \frac{B(k + a, n - k + b)}{B(a, b)},
\qquad k = 0, \ldots, n,
where :math:`B` is the beta function.
Parameters
----------
n : scalar(int)
First parameter to the Beta-binomial distribution
a : scalar(float)
Second parameter to the Beta-binomial distribution
b : scalar(float)
Third parameter to the Beta-binomial distribution
Returns
-------
probs: array_like(float)
Vector of probabilities over k
"""
n, a, b = self.n, self.a, self.b
k = np.arange(n + 1)
probs = binom(n, k) * beta(k + a, n - k + b) / beta(a, b)
return probs
def loss_function(params, func=simulate_dynamics, time_scale=1, df=func_data):
"""Calculate the loss function.
Parameters
----------
params : array-like, parameters that determine starting state of population
func : model begin fit to the data
time_scale : int (optional), the number of discrete time steps per year
number : int, (optional), the number of discretized states and actions
default is one "generation" of the dynamics per year
df : data to use, default is from func_data
Returns
----------
negLL : float, negative log likelihood to be minimized
"""
# Simulate the dynamics from 1100 to 1500
X_sol, Y_sol, prior = func(params, n_years=401, time_scale=time_scale)
# Get p(m_2) over time
m2_sol = np.asarray([prior.dot(line)[0,0] for line in X_sol[:,1::2]])
# Append solution trajectory to data frame
# Use approximate value when trajectory reaches boundary
df['p'] = np.minimum(m2_sol.ravel(), np.repeat(.9999999, len(m2_sol)))
# Add binomial coefficient
df['binom'] = binom(df.ones + df.zeros, df.ones)
# Calculate log-likelihood for
df['LL'] = np.log(df.binom) + (df.ones * np.log(df.p)) + (df.zeros * np.log(1 - df.p))
# Only use years that have tokens
df = df[df['has.tokens'] == 1]
# Calculate log likelihood given m2_sol
LL = np.sum(df['LL'])
negLL = -1*LL
# Minimizing negative log-likelihood is equivalent to maximizing log-likelihood
return negLL
def coverage_probability(full_amount, cover_amount, number_of_data):
if cover_amount == full_amount:
return 0.0, 0.0 # since the full range is already covered, the coverage possibility would be 100%
# but as this indicates that no significant rule can be determined, 100% are treated as 0%
p = float(0)
for k in range(int(full_amount - 1)):
p += ((-1) ** k) * special.binom(full_amount, full_amount - k) * ((
full_amount - k) / full_amount) ** number_of_data
pc = float(0)
for k in range(int(cover_amount - 1)):
pc += ((-1) ** k) * special.binom(cover_amount, cover_amount - k) * ((
cover_amount - k) / cover_amount) ** number_of_data
return p, pc
def herald_on_N(N,Mmax,t,tt,s,nmax=20):
"""Claculates the density matrix for a state heralded on N photons in arm a
up to Mmax photons and after going losses t and tt in arms a and b and where the squeezing parameters
are in the list s"""
m=len(s)
if m==1:
return herald_on_Nsm(N,0,Mmax,t,tt,s[0],nmax=20)
else:
total_number=special.binom(N+m-1,N)
combinations=comb(N,m)
#print total_number
ci=np.empty((m,N+1,Mmax+1))
for i in range(m):
for n in range(N+1):
ci[i,n]=herald_on_Nsm(n,0,Mmax,t,tt,s[i],nmax)
#print len(ci[i])
dmindices=itertools.product(range(Mmax+1),repeat=m)
dm=np.zeros([Mmax+1 for i in range(m)])
for i in dmindices:
ssum=0.0
for j in combinations:
prod=1.0
for k in range(m):
prod*=ci[k,j[k],i[k]]
ssum+=prod
dm[i]=ssum
return dm
def getBetaSampleShift(self, y, N, j):
"""
Construct beta sample using shifting procedure.
Parameters
----------
y : array
Values from which to estimate noise
N : int
Last order of the Taylor series taken into account
j : int
Jump parameter (>0)
Returns
-------
Beta sample : array
An array holding all available beta values.
"""
# Calculate the required coefficients (a_k)
self.ak = self.get_ak(N)
# Required chunk length to obtain realization
# of beta = (N+2) + (N-1)*(j-1) = (N+1)*j + 1
cl = (N + 1) * j + 1
b = np.zeros(len(y) - cl + 1)
for i in smo.range(len(y) - cl + 1):
# Realizations of the beta sample
b[i] = np.sum(y[i:i + cl:j] * self.ak)
# Normalize to obtain width of sigma_0
b /= np.sqrt(ss.binom(2 * N + 2, N + 1))
return b
def fourWay_ew_collisionRate(b,k,c,phi):
'''
compute the rate of (b;k[1],...,k[len(k)];s)-collisions
since s = b -sum(k), it does not need to be an argument
it is assumed that all entries in the vector k are integers greater
than 0, and that len(k) < 4
'''
# k = [x for x in k if x>1]
# K = sum(k)
# if all([i==1 for i in k]) or K > b or K < 2 :
# return 0
# else:
# r = len(k)
# K = sum(k)
# return sum([binom(b-K,l)*lambda_ew_collisionRate(b,K,c,phi)*np.prod(range(4,4-(r+l),-1))/4.0**(K+l) for l in range(0,4-r+1)])
#
# P_k = multinomial(K,k)/(4.0**K) * multinomial(len(k)-k.count(0),[k.count(i) for i in range(1,K+1)])
# print P_k,multinomial(K,k),(4.0**K),multinomial(len(k),[k.count(i) for i in range(1,K+1)])
# The last factor in the above, counts the number of different ways
# to arrange the numbers k[1],...k[len(k)]
# return P_k * lambda_ew_collisionRate(b,K,c,phi)
k = [x for x in k if x>1] #remove all 1 and 0 entires from k
K = sum(k) #Total number of affected blocks
# print b,k,K
if all([i==1 for i in k]) or K > b or K < 2 :
return 0
else:
r = len(k)
s = b-K
l_max = min(4-r,s)
return sum([(binom(s,l) * lambda_ew_collisionRate(b,K+l,c,phi))*(fallingFactorial(4,l+r)/(4.0**(K+l))) for l in range(0,l_max+1)])
def monotone_disjunctive_kernel(X,T=None,d=2):
X, T = check_X_T(X, T)
L = np.dot(X,T.T)
n = X.shape[1]
XX = np.dot(X.sum(axis=1).reshape(X.shape[0],1), np.ones((1,T.shape[0])))
TT = np.dot(T.sum(axis=1).reshape(T.shape[0],1), np.ones((1,X.shape[0])))
N_x = n - XX
N_t = n - TT
N_xz = N_x - TT.T + L
N_d = binom(n, d)
N_x = binom(N_x,d)
N_t = binom(N_t,d)
N_xz = binom(N_xz,d)
return (N_d - N_x - N_t.T + N_xz)
def explain(self, incoming_instance, **kwargs):
# convert incoming input to a standardized iml object
instance = convert_to_instance(incoming_instance)
match_instance_to_data(instance, self.data)
# find the feature groups we will test. If a feature does not change from its
# current value then we know it doesn't impact the model
self.varyingInds = self.varying_groups(instance.x)
self.varyingFeatureGroups = [
self.data.groups[i] for i in self.varyingInds
]
self.M = len(self.varyingFeatureGroups)
# find f(x)
if self.keep_index:
model_out = self.model.f(instance.convert_to_df())
else:
model_out = self.model.f(instance.x)
if isinstance(model_out, (pd.DataFrame, pd.Series)):
model_out = model_out.values
self.fx = model_out[0]
if not self.vector_out:
self.fx = np.array([self.fx])
# if no features vary then there no feature has an effect
if self.M == 0:
phi = np.zeros((len(self.data.groups), self.D))
phi_var = np.zeros((len(self.data.groups), self.D))
# if only one feature varies then it has all the effect
elif self.M == 1:
phi = np.zeros((len(self.data.groups), self.D))
phi_var = np.zeros((len(self.data.groups), self.D))
diff = self.link.f(self.fx) - self.link.f(self.fnull)
for d in range(self.D):
phi[self.varyingInds[0], d] = diff[d]
# if more than one feature varies then we have to do real work
else:
self.l1_reg = kwargs.get("l1_reg", "auto")
# pick a reasonable number of samples if the user didn't specify how many they wanted
self.nsamples = kwargs.get("nsamples", "auto")
if self.nsamples == "auto":
self.nsamples = 2 * self.M + 2**11
# if we have enough samples to enumerate all subsets then ignore the unneeded samples
self.max_samples = 2**30
if self.M <= 30:
self.max_samples = 2**self.M - 2
if self.nsamples > self.max_samples:
self.nsamples = self.max_samples
# reserve space for some of our computations
self.allocate()
# weight the different subset sizes
num_subset_sizes = np.int(np.ceil((self.M - 1) / 2.0))
num_paired_subset_sizes = np.int(np.floor((self.M - 1) / 2.0))
weight_vector = np.array([(self.M - 1.0) / (i * (self.M - i))
for i in range(1, num_subset_sizes + 1)])
weight_vector[:num_paired_subset_sizes] *= 2
weight_vector /= np.sum(weight_vector)
log.debug("weight_vector = {0}".format(weight_vector))
log.debug("num_subset_sizes = {0}".format(num_subset_sizes))
log.debug("num_paired_subset_sizes = {0}".format(
num_paired_subset_sizes))
log.debug("M = {0}".format(self.M))
# fill out all the subset sizes we can completely enumerate
# given nsamples*remaining_weight_vector[subset_size]
num_full_subsets = 0
num_samples_left = self.nsamples
group_inds = np.arange(self.M, dtype='int64')
mask = np.zeros(self.M)
remaining_weight_vector = copy.copy(weight_vector)
for subset_size in range(1, num_subset_sizes + 1):
# determine how many subsets (and their complements) are of the current size
nsubsets = binom(self.M, subset_size)
if subset_size <= num_paired_subset_sizes: nsubsets *= 2
log.debug("subset_size = {0}".format(subset_size))
log.debug("nsubsets = {0}".format(nsubsets))
log.debug(
"self.nsamples*weight_vector[subset_size-1] = {0}".format(
num_samples_left *
remaining_weight_vector[subset_size - 1]))
log.debug(
"self.nsamples*weight_vector[subset_size-1/nsubsets = {0}".
format(num_samples_left *
remaining_weight_vector[subset_size - 1] /
nsubsets))
# see if we have enough samples to enumerate all subsets of this size
if num_samples_left * remaining_weight_vector[
subset_size - 1] / nsubsets >= 1.0 - 1e-8:
num_full_subsets += 1
num_samples_left -= nsubsets
# rescale what's left of the remaining weight vector to sum to 1
if remaining_weight_vector[subset_size - 1] < 1.0:
remaining_weight_vector /= (
1 - remaining_weight_vector[subset_size - 1])
# add all the samples of the current subset size
w = weight_vector[subset_size - 1] / binom(
self.M, subset_size)
if subset_size <= num_paired_subset_sizes: w /= 2.0
for inds in itertools.combinations(group_inds,
subset_size):
mask[:] = 0.0
mask[np.array(inds, dtype='int64')] = 1.0
self.addsample(instance.x, mask, w)
if subset_size <= num_paired_subset_sizes:
mask[:] = np.abs(mask - 1)
self.addsample(instance.x, mask, w)
else:
break
log.info("num_full_subsets = {0}".format(num_full_subsets))
# add random samples from what is left of the subset space
samples_left = self.nsamples - self.nsamplesAdded
log.debug("samples_left = {0}".format(samples_left))
if num_full_subsets != num_subset_sizes:
weight_left = np.sum(weight_vector[num_full_subsets:])
rand_sample_weight = weight_left / samples_left
log.info("weight_left = {0}".format(weight_left))
log.info("rand_sample_weight = {0}".format(rand_sample_weight))
remaining_weight_vector = weight_vector[num_full_subsets:]
remaining_weight_vector /= np.sum(remaining_weight_vector)
log.info("remaining_weight_vector = {0}".format(
remaining_weight_vector))
log.info("num_paired_subset_sizes = {0}".format(
num_paired_subset_sizes))
ind_set = np.arange(len(remaining_weight_vector))
while samples_left > 0:
mask[:] = 0.0
np.random.shuffle(group_inds)
ind = np.random.choice(ind_set,
1,
p=remaining_weight_vector)[0]
mask[group_inds[:ind + num_full_subsets + 1]] = 1.0
samples_left -= 1
self.addsample(instance.x, mask, rand_sample_weight)
# add the compliment sample
if samples_left > 0:
mask -= 1.0
mask[:] = np.abs(mask)
self.addsample(instance.x, mask, rand_sample_weight)
samples_left -= 1
# execute the model on the synthetic samples we have created
self.run()
# solve then expand the feature importance (Shapley value) vector to contain the non-varying features
phi = np.zeros((len(self.data.groups), self.D))
phi_var = np.zeros((len(self.data.groups), self.D))
for d in range(self.D):
vphi, vphi_var = self.solve(self.nsamples / self.max_samples,
d)
phi[self.varyingInds, d] = vphi
phi_var[self.varyingInds, d] = vphi_var
if not self.vector_out:
phi = np.squeeze(phi, axis=1)
phi_var = np.squeeze(phi_var, axis=1)
return phi
def check(N,K):
S = range(N)
assert binom(N,K) == length(sample(S, K, ordered=0, replace=0))
#A01 = sample(S, K, ordered=0, replace=1) # ???
assert binom(N,K) * factorial(K) == length(sample(S, K, ordered=1, replace=0))
assert N**K == length(sample(S, K, ordered=1, replace=1))
def test_nchoosek(self):
assert nchoosek(3, 2) == binom(3, 2)
def explain(self, incoming_instance, **kwargs):
# convert incoming input to a standardized iml object
instance = convert_to_instance(incoming_instance)
match_instance_to_data(instance, self.data)
# find the feature groups we will test. If a feature does not change from its
# current value then we know it doesn't impact the model
self.varyingInds = self.varying_groups(instance.x)
if self.data.groups is None:
self.varyingFeatureGroups = np.array([i for i in self.varyingInds])
self.M = self.varyingFeatureGroups.shape[0]
else:
self.varyingFeatureGroups = [self.data.groups[i] for i in self.varyingInds]
self.M = len(self.varyingFeatureGroups)
groups = self.data.groups
# convert to numpy array as it is much faster if not jagged array (all groups of same length)
if self.varyingFeatureGroups and all(len(groups[i]) == len(groups[0]) for i in self.varyingInds):
self.varyingFeatureGroups = np.array(self.varyingFeatureGroups)
# further performance optimization in case each group has a single value
if self.varyingFeatureGroups.shape[1] == 1:
self.varyingFeatureGroups = self.varyingFeatureGroups.flatten()
# find f(x)
if self.keep_index:
model_out = self.model.f(instance.convert_to_df())
else:
model_out = self.model.f(instance.x)
if isinstance(model_out, (pd.DataFrame, pd.Series)):
model_out = model_out.values
self.fx = model_out[0]
if not self.vector_out:
self.fx = np.array([self.fx])
# if no features vary then no feature has an effect
if self.M == 0:
phi = np.zeros((self.data.groups_size, self.D))
phi_var = np.zeros((self.data.groups_size, self.D))
# if only one feature varies then it has all the effect
elif self.M == 1:
phi = np.zeros((self.data.groups_size, self.D))
phi_var = np.zeros((self.data.groups_size, self.D))
diff = self.link.f(self.fx) - self.link.f(self.fnull)
for d in range(self.D):
phi[self.varyingInds[0],d] = diff[d]
# if more than one feature varies then we have to do real work
else:
self.l1_reg = kwargs.get("l1_reg", "auto")
# pick a reasonable number of samples if the user didn't specify how many they wanted
self.nsamples = kwargs.get("nsamples", "auto")
if self.nsamples == "auto":
self.nsamples = 2 * self.M + 2**11
# if we have enough samples to enumerate all subsets then ignore the unneeded samples
self.max_samples = 2 ** 30
if self.M <= 30:
self.max_samples = 2 ** self.M - 2
if self.nsamples > self.max_samples:
self.nsamples = self.max_samples
# reserve space for some of our computations
self.allocate()
# weight the different subset sizes
num_subset_sizes = np.int(np.ceil((self.M - 1) / 2.0))
num_paired_subset_sizes = np.int(np.floor((self.M - 1) / 2.0))
weight_vector = np.array([(self.M - 1.0) / (i * (self.M - i)) for i in range(1, num_subset_sizes + 1)])
weight_vector[:num_paired_subset_sizes] *= 2
weight_vector /= np.sum(weight_vector)
log.debug("weight_vector = {0}".format(weight_vector))
log.debug("num_subset_sizes = {0}".format(num_subset_sizes))
log.debug("num_paired_subset_sizes = {0}".format(num_paired_subset_sizes))
log.debug("M = {0}".format(self.M))
# fill out all the subset sizes we can completely enumerate
# given nsamples*remaining_weight_vector[subset_size]
num_full_subsets = 0
num_samples_left = self.nsamples
group_inds = np.arange(self.M, dtype='int64')
mask = np.zeros(self.M)
remaining_weight_vector = copy.copy(weight_vector)
for subset_size in range(1, num_subset_sizes + 1):
# determine how many subsets (and their complements) are of the current size
nsubsets = binom(self.M, subset_size)
if subset_size <= num_paired_subset_sizes: nsubsets *= 2
log.debug("subset_size = {0}".format(subset_size))
log.debug("nsubsets = {0}".format(nsubsets))
log.debug("self.nsamples*weight_vector[subset_size-1] = {0}".format(
num_samples_left * remaining_weight_vector[subset_size - 1]))
log.debug("self.nsamples*weight_vector[subset_size-1]/nsubsets = {0}".format(
num_samples_left * remaining_weight_vector[subset_size - 1] / nsubsets))
# see if we have enough samples to enumerate all subsets of this size
if num_samples_left * remaining_weight_vector[subset_size - 1] / nsubsets >= 1.0 - 1e-8:
num_full_subsets += 1
num_samples_left -= nsubsets
# rescale what's left of the remaining weight vector to sum to 1
if remaining_weight_vector[subset_size - 1] < 1.0:
remaining_weight_vector /= (1 - remaining_weight_vector[subset_size - 1])
# add all the samples of the current subset size
w = weight_vector[subset_size - 1] / binom(self.M, subset_size)
if subset_size <= num_paired_subset_sizes: w /= 2.0
for inds in itertools.combinations(group_inds, subset_size):
mask[:] = 0.0
mask[np.array(inds, dtype='int64')] = 1.0
self.addsample(instance.x, mask, w)
if subset_size <= num_paired_subset_sizes:
mask[:] = np.abs(mask - 1)
self.addsample(instance.x, mask, w)
else:
break
log.info("num_full_subsets = {0}".format(num_full_subsets))
# add random samples from what is left of the subset space
nfixed_samples = self.nsamplesAdded
samples_left = self.nsamples - self.nsamplesAdded
log.debug("samples_left = {0}".format(samples_left))
if num_full_subsets != num_subset_sizes:
remaining_weight_vector = copy.copy(weight_vector)
remaining_weight_vector[:num_paired_subset_sizes] /= 2 # because we draw two samples each below
remaining_weight_vector = remaining_weight_vector[num_full_subsets:]
remaining_weight_vector /= np.sum(remaining_weight_vector)
log.info("remaining_weight_vector = {0}".format(remaining_weight_vector))
log.info("num_paired_subset_sizes = {0}".format(num_paired_subset_sizes))
ind_set = np.random.choice(len(remaining_weight_vector), 4 * samples_left, p=remaining_weight_vector)
ind_set_pos = 0
used_masks = {}
while samples_left > 0 and ind_set_pos < len(ind_set):
mask.fill(0.0)
ind = ind_set[ind_set_pos] # we call np.random.choice once to save time and then just read it here
ind_set_pos += 1
subset_size = ind + num_full_subsets + 1
mask[np.random.permutation(self.M)[:subset_size]] = 1.0
# only add the sample if we have not seen it before, otherwise just
# increment a previous sample's weight
mask_tuple = tuple(mask)
new_sample = False
if mask_tuple not in used_masks:
new_sample = True
used_masks[mask_tuple] = self.nsamplesAdded
samples_left -= 1
self.addsample(instance.x, mask, 1.0)
else:
self.kernelWeights[used_masks[mask_tuple]] += 1.0
# add the compliment sample
if samples_left > 0 and subset_size <= num_paired_subset_sizes:
mask[:] = np.abs(mask - 1)
# only add the sample if we have not seen it before, otherwise just
# increment a previous sample's weight
if new_sample:
samples_left -= 1
self.addsample(instance.x, mask, 1.0)
else:
# we know the compliment sample is the next one after the original sample, so + 1
self.kernelWeights[used_masks[mask_tuple] + 1] += 1.0
# normalize the kernel weights for the random samples to equal the weight left after
# the fixed enumerated samples have been already counted
weight_left = np.sum(weight_vector[num_full_subsets:])
log.info("weight_left = {0}".format(weight_left))
self.kernelWeights[nfixed_samples:] *= weight_left / self.kernelWeights[nfixed_samples:].sum()
# execute the model on the synthetic samples we have created
self.run()
# solve then expand the feature importance (Shapley value) vector to contain the non-varying features
phi = np.zeros((self.data.groups_size, self.D))
phi_var = np.zeros((self.data.groups_size, self.D))
for d in range(self.D):
vphi, vphi_var = self.solve(self.nsamples / self.max_samples, d)
phi[self.varyingInds, d] = vphi
phi_var[self.varyingInds, d] = vphi_var
if not self.vector_out:
phi = np.squeeze(phi, axis=1)
phi_var = np.squeeze(phi_var, axis=1)
return phi
def P(L, n, s):
return binom(n - 1, L - 1) * ((1 / s)**(L - 1)) * ((1 - (1 / s))**(n - L))
def smolyak_sparse_grid(self, polynom, level):
"""
SMOLYAK_SPARSE_GRID builds a spase grid for multi-dimensional integration.
It is based on Clenshaw-Curtis points and weights with growth rule: 2**(l-1) + 1.
Parameters
----------
polynom (PolyChaos) :
PolyChaos instance
level (int) :
level of the integration
Results
-------
x_points (ndarray) :
2D-ndarray with all integration points (with repetition)
eps_points (ndarray) :
2D-ndarray with all integration points (with repetition) in the suitable range
for the othogonal polynomials
weights (ndarray) :
2D-ndarray with weights to be used with points (with repetition)
unique_points (ndarray) :
2D-ndarray with non-repeated integration points
AUTHOR: Luca Giaccone ([email protected])
DATE: 24.12.2018
HISTORY:
"""
# min and max level
o_min = max([level + 1, polynom.dim])
o_max = level + polynom.dim
# get multi-index for all level
comb = np.empty((0, polynom.dim), dtype=int)
for k in range(o_min, o_max + 1):
multi_index, _ = self.index_with_sum(polynom.dim, k)
comb = np.append(comb, multi_index, axis=0)
# initialize final array
x_points = np.empty((0, polynom.dim))
eps_points = np.empty((0, polynom.dim))
weights = np.empty((0, ))
# define integration points and weights
for lev in comb:
local_x = []
local_eps = []
local_w = []
coeff = (-1)**(level + polynom.dim - np.sum(lev)) * binom(
polynom.dim - 1, level + polynom.dim - np.sum(lev))
# cycle on integration variables
for l, k, p in zip(lev, polynom.distrib, polynom.param):
# set integration type depending on distrib
if k.upper() == 'U':
kind = 'CC'
elif k.upper() == 'N':
kind = 'GH'
# get number of integration points
n = self.growth_rule(l, kind=kind)
# get gauss points and weight
x0, w0 = quad_coeff(rule=n, kind=kind)
# change of variable
if (k.upper() == 'U'):
eps = np.copy(x0)
w = np.copy(w0) * 0.5
if p != [-1, 1]:
x = (p[1] - p[0]) / 2 * x0 + (p[1] + p[0]) / 2
else:
x = np.copy(x0)
elif (k.upper() == 'N'):
eps = np.sqrt(2) * 1 * x0 + 0
x = eps * p[1] + p[0]
w = w0 * (1 / np.sqrt(np.pi))
# store local points
local_x.append(x)
local_eps.append(eps)
local_w.append(w)
# update final array
x_points = np.concatenate(
(x_points,
np.concatenate(columnize(*np.meshgrid(*local_x)), axis=1)))
eps_points = np.concatenate(
(eps_points,
np.concatenate(columnize(*np.meshgrid(*local_eps)), axis=1)))
weights = np.concatenate((weights, coeff * np.prod(np.concatenate(
columnize(*np.meshgrid(*local_w)), axis=1),
axis=1)))
# get unique points
unique_x_points, inverse_index = np.unique(x_points,
axis=0,
return_inverse=True)
return x_points, eps_points, weights, unique_x_points, inverse_index
import numpy as np
from scipy.special import binom
n = 25
mat = np.array([[0., 0., 1.], [1., 0., 0.], [0., 1., 0.]])
I = np.identity(3, dtype=float)
val = np.zeros((3, 3))
var = I
for k in range(n + 1):
val += binom(n, k) * var
var = np.dot(var, mat)
print(val)
def get_multinomial_coefficient(params):
if len(params) == 1:
return 1
if params[-1] == 0:
return get_multinomial_coefficient(params[:-1])
return int(binom(sum(params), params[-1])) * get_multinomial_coefficient(params[:-1])
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib
from scipy.special import binom
m = 30
p = lambda x,k: binom(m,k)*(x**k)*((1-x)**(m-k))
g = lambda x,n: np.sum([p(x,k) for k in range(n+1)])
g(0.1,0)
xrange = np.arange(0,1,0.01)
prior = lambda x: 10 if (x<0.6 and x>0.4) else 1
S = np.sum([prior(x) for x in xrange])
priormemo = {x: prior(x)/S for x in xrange}
prior = lambda x: priormemo[x]
N = lambda k: np.sum([p(x,k)*prior(x) for x in xrange])
Nmemo = {k:N(k) for k in range(m+1)}
N = lambda k: Nmemo[k]
N(2)
pp = lambda x,k: (p(x,k)*prior(x))/N(k)
cumpp = lambda i,k: np.sum([pp(y,k) for y in xrange[:i]])
cumpp2 = lambda i,k: np.sum([pp(y,k) for y in xrange[i+1:]])
fbayes = lambda k: np.min([x for i,x in enumerate(xrange) if cumpp2(i,k)<d])
fbayesmemo = {k:fbayes(k) for k in range(m+1)}
fbayes = lambda k: fbayesmemo[k]
plt.scatter(range(m),list(map(f,range(m))))
def get_rate_matrix(self, states):
print('Computing rate matrix')
#print(self.species)
#dstates = states[self.species[0]]
#for i_specie in range(1,len(self.species)):
# specie = self.species[i_specie]
# print(dstates)
# print(states[specie])
# print(np.array(np.meshgrid(dstates,states[specie])).T.reshape(-1,2))
# exit()
indep_species = deepcopy(self.species)
for conservation_law in self.conservation_laws:
for specie in conservation_law.keys():
if specie != 'total':
indep_species.remove(specie)
break
else:
print('ERROR')
enum_states = np.array(
np.meshgrid(*[states[specie]
for specie in indep_species])).T.reshape(
-1, len(indep_species))
print('Number of enumerated states: ', enum_states.shape)
enum_states_full = np.nan * np.ones(
(enum_states.shape[0], len(self.species)))
for i_specie, specie in enumerate(self.species):
if specie in indep_species:
i_indep_species = indep_species.index(specie)
enum_states_full[:, i_specie] = enum_states[:, i_indep_species]
else:
for conservation_law in self.conservation_laws:
if specie in conservation_law.keys():
enum_states_full[:,
i_specie] = conservation_law['total']
for specie_j in conservation_law.keys():
if (specie_j != 'total') and (specie_j != specie):
j_indep_species = indep_species.index(specie_j)
enum_states_full[:,
i_specie] -= enum_states[:,
j_indep_species]
print('Enumerated states: ', enum_states_full)
K = np.zeros((enum_states_full.shape[0], enum_states_full.shape[0]))
for i in range(enum_states_full.shape[0]):
state_i = enum_states_full[i, :]
print('Searching connection for state {0:d}'.format(i))
for j in range(enum_states_full.shape[0]):
state_j = enum_states_full[j, :]
diff = (state_j - state_i).astype(int)
for i_reaction in range(self.A.shape[0]):
if np.all(self.A[i_reaction, :] == diff):
number_of_each_reagents = np.power(
state_i, self.P[i_reaction, :])
#print('\tadding component {0:d} {1:d}'.format(i,j))
for ind_col in np.where(self.P[i_reaction, :] > 1):
number_of_each_reagents[ind_col] = special.binom(
state_i[ind_col], self.P[i_reaction, ind_col])
number_of_reagents = np.prod(number_of_each_reagents)
#print('species ',self.species)
#print('state_i ',state_i)
#print('state_j ',state_j)
#print('P ',self.P[i_reaction,:])
#print('A ',self.A[i_reaction,:])
#print('number_of_each_reagents ',number_of_each_reagents)
#print('number_of_reagents ',number_of_reagents)
K[j, i] += number_of_reagents * self.rates[i_reaction]
for i in range(enum_states_full.shape[0]):
K[i, i] = -np.sum(K[:, i])
print('Rate matrix: ', K)
T = sp.linalg.expm(K)
print('Transition matrix: ', T)
print(np.sum(T, axis=0))
eigv = np.linalg.eigvals(T)
inds = np.argsort(np.abs(eigv))[-1::-1]
print('eigvs = ', eigv[inds])
output = ''
for i in inds:
eig = eigv[i]
output += '\tEigenvalue = {0:f}\n'.format(eig)
output += '\tTimescale = {0:f}\n'.format(-1.0 /
np.log(np.abs(eig)))
if eig.imag != 0:
r, phi = cmath.polar(eig)
output += '\t\tperiod = {0:f}\n'.format(2 * np.pi /
np.abs(phi))
print(output)
exit()
def get_propensity(self, state=None):
"""
Example:
Species :
M = 2
P = 3
Transition matrix :
-> M M -> M -> M + P P ->
M 1 -1 0 0
P 0 0 1 -1
rate 1.000000 2.000000 3.000000 4.0000
state
[2
3]
P
[[0 0]
[1 0]
[1 0]
[0 1]
]
number_of_each_reagent
[[1 1] First reaction -> M: No reagent
[2 1] Second reaction M -> : M is the reagent
[2 1] Third reaction M -> M + P: M is the reagent
[1 3]] Forth reaction P ->: P is the reagent
number_of_reagents
[1 First reaction -> M: No reagent
2 Second reaction M -> : M is the reagent, so 2 molecules
2 Third reaction M -> M + P: M is the reagent, so 2 molecules
3] Forth reaction P ->: P is the reagent so 3 molecules
number_of_reagents * self.rates
[1 This is rate_1(1) * 1 (that's why we need a 1 in number_of_reagents for a constant rate reaction)
4 This is rate_2(2) * M(2)
6 This is rate_3(3) * M(2)
12] This is rate_4(4) * P(3)
"""
if state is None:
state = self.state
number_of_each_reagents = np.power(state, self.P)
# print 'state: ',state
# print 'self.P: ',self.P
# print 'number_of_each_reagents(before correction): ',number_of_each_reagents
inds_row, inds_col = np.where(self.P > 1)
# This correction is needed for reactions that use more than one molecule of the same kind
for ind_row, ind_col in zip(inds_row, inds_col):
# self.P[ind_row,ind_col] = Number of molecules needed for the reaction
# state[ind_col] = Number of molecules that are present
# e.g. A + 3*B -> C
# with number_of_each_reagents = np.power(state,self.P) the contributio of B is B**3
# here we correct to binomial_coefficient(B,3)
number_of_each_reagents[ind_row, ind_col] = special.binom(
state[ind_col], self.P[ind_row, ind_col])
# print 'number_of_each_reagents(after correction): ',number_of_each_reagents
number_of_reagents = np.prod(number_of_each_reagents, axis=1)
# print 'number_of_reagents: ',number_of_reagents
propensities = number_of_reagents * self.rates
for i_reaction, rate_patch in self.rate_patches.items():
input_values = [
state[self.species.index(specie)]
for specie in inspect.getargspec(rate_patch).args
]
propensities[i_reaction] *= rate_patch(*input_values)
# print 'propensities: ',propensities
return propensities
def spin_q_function(rho, theta, phi):
r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
j, theta, phi)`` where j is the spin length.
The implementation here is more efficient as it doesn't
generate all of the SCS at theta and phi (see references).
The spin Q function is normal when integrated over the surface of the
sphere
.. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
Parameters
----------
state : qobj
A state vector or density matrix for a spin-j quantum system.
theta : array_like
Polar (colatitude) angle at which to calculate the Husimi-Q function.
phi : array_like
Azimuthal angle at which to calculate the Husimi-Q function.
Returns
-------
Q, THETA, PHI : 2d-array
Values representing the spin Husimi Q function at the values specified
by THETA and PHI.
References
----------
[1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
https://doi.org/10.1119/1.4898595
"""
if rho.type == 'bra':
rho = rho.dag()
if rho.type == 'ket':
rho = ket2dm(rho)
J = rho.shape[0]
j = (J - 1) / 2
THETA, PHI = meshgrid(theta, phi)
Q = np.zeros_like(THETA, dtype=complex)
for m1 in arange(-j, j + 1):
Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
sin(THETA / 2) ** (2 * (j - m1)) * \
rho.data[int(j - m1), int(j - m1)]
for m2 in arange(m1 + 1, j + 1):
Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
cos(THETA / 2) ** (2 * j + m1 + m2) *
sin(THETA / 2) ** (2 * j - m1 - m2)) * \
(exp(1j * (m1 - m2) * PHI) * rho.data[int(j - m1), int(j - m2)] +
exp(1j * (m2 - m1) * PHI) * rho.data[int(j - m2), int(j - m1)])
return Q.real, THETA, PHI
def make_ops(self):
def diag(bands,locs):
return sparse.dia_matrix((bands,locs),shape=(len(bands[0]),len(bands[0])))
a,b, N = self.consts['a'],self.consts['b'], self.max_degree+1
n = np.arange(0,N)
na = n+a
nb = n+b
nab = n+a+b
nnab = 2*n+a+b
# (1-z) <a,b| = <a-1,b| A-
if a > 0:
if a+b==0:
middle = na/(2*n+1)
lower = (nb+1)/(2*n+1)
middle[0] = 2*a
else:
middle = 2*na*nab/(nnab*(nnab+1))
lower = 2*(n+1)*(nb+1)/((nnab+1)*(nnab+2))
self.op['A-'] = diag([-np.sqrt(lower),np.sqrt(middle)],[-1,0])
# <a,b| = <a+1,b| A+
if a+b == 0 or a+b == -1:
middle = (na+1)/(2*n+1)
upper = nb/(2*nab+1)
middle[0], upper[0] = (1+a)*(1-(a+b)), 0
else:
middle = 2*(na+1)*(nab+1)/((nnab+1)*(nnab+2))
upper = 2*n*nb/(nnab*(nnab+1))
self.op['A+'] = diag([np.sqrt(middle),-np.sqrt(upper)],[0,+1])
# (1+z) <a,b| = <a,b-1| B-
if b > 0:
if a+b == 0:
middle = nb/(2*n+1)
lower = (na+1)/(2*n+1)
middle[0] = 2*b
else:
middle = 2*nb*nab/(nnab*(nnab+1))
lower = 2*(n+1)*(na+1)/((nnab+1)*(nnab+2))
self.op['B-'] = diag([np.sqrt(lower),np.sqrt(middle)],[-1,0])
# <a,b| = <a,b+1| B+
if a+b == 0 or a+b == -1:
middle = (nb+1)/(2*n+1)
upper = na/(2*nab+1)
middle[0], upper[0] = (1+b)*(1-(a+b)), 0
else:
middle = 2*(nb+1)*(nab+1)/((nnab+1)*(nnab+2))
upper = 2*n*na/(nnab*(nnab+1))
self.op['B+'] = diag([np.sqrt(middle),np.sqrt(upper)],[0,+1])
# ( a - (1-z)*d/dz ) <a,b| = <a-1,b+1| C-
if a > 0:
self.op['C-'] = diag([np.sqrt(na*(nb+1))],[0])
# ( b + (1+z)*d/dz ) <a,b| = <a+1,b-1| C+
if b > 0:
self.op['C+'] = diag([np.sqrt((na+1)*nb)],[0])
# ( a(1+z) - b(1-z) - (1-z^2)*d/dz ) <a,b| = <a-1,b-1| D-
if a > 0 and b > 0:
self.op['D-'] = diag([np.sqrt((n+1)*nab)],[-1])
# d/dz <a,b| = <a+1,b+1| D+
self.op['D+'] = diag([np.sqrt(n*(nab+1))],[+1])
# z <a,b| = <a,b| J
self.op['J'] = 0.5*(self.pull('B+',self.op['B+']) - self.pull('A+',self.op['A+']))
self.op['z=+1'] = np.sqrt(nnab+1)*np.sqrt(fun.binom(na,a))*np.sqrt(fun.binom(nab,a))
self.op['z=-1'] = ((-1)**n)*np.sqrt(nnab+1)*np.sqrt(fun.binom(nb,b))*np.sqrt(fun.binom(nab,b))
if a+b==-1:
self.op['z=+1'][0] = np.sqrt(np.sin(np.pi*np.abs(a))/np.pi)
self.op['z=-1'][0] = np.sqrt(np.sin(np.pi*np.abs(b))/np.pi)
def sterm(n, k, j):
"""
This is a numerical calculation of the base term of a Stirling number term.
"""
return int((-1)**(k - j) * scis.binom(k, j) * j**n)
def __init__(cls, *args, **kwargs):
cls._ORDER = 2
cls._binom_coeffs = [[sp.binom(n, k) for k in range(cls._ORDER + 1)]
for n in range(cls._ORDER + 1)]
cost_mat_inv_z8 = cp.asarray(loadmat(paths+'matrices/cost_mat_inv_z8.mat')['inv_z']) cost_mat_inv_x9 = cp.asarray(loadmat(paths+'matrices/cost_mat_inv_x9.mat')['inv_x']) cost_mat_inv_y9 = cp.asarray(loadmat(paths+'matrices/cost_mat_inv_y9.mat')['inv_y']) cost_mat_inv_z9 = cp.asarray(loadmat(paths+'matrices/cost_mat_inv_z9.mat')['inv_z']) Aeq_x = cp.asarray(loadmat(paths+'matrices/Aeq_x.mat')['Aeq_x']) Aeq_y = cp.asarray(loadmat(paths+'matrices/Aeq_y.mat')['Aeq_y']) Aeq_z = cp.asarray(loadmat(paths+'matrices/Aeq_z.mat')['Aeq_z']) Afc = cp.asarray(loadmat(paths+'matrices/Afc.mat')['Afc']) rho = cp.asarray(loadmat(paths+'matrices/rho.mat')['rho_init'][0]) print (rho) ncomb = int(binom(nbot,2)) x_init, y_init, z_init, x_fin, y_fin, z_fin = init_final_pos() vx_init = cp.zeros(nbot) vy_init = cp.zeros(nbot) vz_init = cp.zeros(nbot) ax_init = cp.zeros(nbot) ay_init = cp.zeros(nbot) az_init = cp.zeros(nbot) vx_fin = cp.zeros(nbot) vy_fin = cp.zeros(nbot) vz_fin = cp.zeros(nbot) ax_fin = cp.zeros(nbot) ay_fin = cp.zeros(nbot) az_fin = cp.zeros(nbot)
def f_xtheta(x, theta, k, m):
#return(2*(m-k+1)*(1-1.0/4**k*sum([binom(k,i)*3*(3*x)**i/(3+8*theta*i) for i in range(k+1)])))
return ((1 - 1.0 / 4**k * sum([
binom(k, i) * 3 * (3 * x)**i / (3 + 8 * theta * i)
for i in range(k + 1)
])))
def get_exponent_matrix(spatial_dimension: int, poly_degree: int, lp_degree: Union[float, int]) -> np.ndarray:
""" creates an array of "multi-indices" symmetric in each dimension
pre allocate the right amount of memory
then starting from the 0 vector, lexicographically "count up" and add all valid exponent vectors
NOTE: this has only been tested for up to dim 4 and up to deg 5.
be aware that the preallocated array might be too small
(<- will raise an IndexError by accessing the array out of bounds)!
:param spatial_dimension: the dimensionality m
:param poly_degree: the highest exponent which should occur in the exponent matrix
:param lp_degree: the value for p of the l_p-norm
:return: an array of shape (m, x) with all possible exponent vectors v with: l_p-norm(v) < poly_degree
sorted lexicographically.
"""
n = poly_degree
m = spatial_dimension
p = lp_degree
p = float(p) # float dtype expected
max_nr_exp = (n + 1) ** m
if p < 0.0:
raise ValueError('values for p must be larger than 0.')
# for some special cases it is known how many distinct exponent vectors exist:
if p == 1.0:
nr_expected_exponents = binom(m + n, n)
elif p == np.inf or m == 1 or n == 1:
# in dimension 1 all lp-degrees are equal!
nr_expected_exponents = max_nr_exp
else:
# for values p << 2 the estimation based on the hypersphere volume tends to underestimate
# the required amount of space! -> clip values for estimation.
# TODO find more precise upper bound.
# -> increases the volume in order to make sure there truly is enough memory being allocated
p_estimation = max(p, 1.7)
vol_lp_sphere = lp_hypersphere_vol(m, radius=1.0, p=p_estimation)
vol_hypercube = 2 ** m
vol_fraction = vol_lp_sphere / vol_hypercube
nr_expected_exponents = max_nr_exp * vol_fraction
nr_expected_exponents = int(nr_expected_exponents)
if nr_expected_exponents > 1e6:
raise ValueError(f'trying to generate exponent matrix with {max_nr_exp} entries.')
exponents = np.empty((nr_expected_exponents, m), dtype=INT_DTYPE)
nr_filled_exp = fill_exp_matrix(exponents, p, n)
# NOTE: validity checked by tests:
# if nr_expected_exponents == nr_filled_exp and lp_degree != np.inf:
# raise ValueError('potentially not enough memory has been allocated to fit all valid exponent vectors! '
# 'check increasing the `incr_factor`')
# just use relevant part:
out = exponents[:nr_filled_exp, :]
# NOTE: since tiny_array is a view onto huge_array, so long as a reference to tiny_array exists the full
# big memory allocation will remain. creating an independent copy however will take up resources!
# cf. http://numpy-discussion.10968.n7.nabble.com/Numpy-s-policy-for-releasing-memory-td1533.html
# NOTE: will be slow for very large arrays. since everything needs not be copied!
if nr_filled_exp * 2 < nr_expected_exponents:
warn(f'more than double the required memory has been allocated ({nr_filled_exp} filled '
f'<< {nr_expected_exponents} allocated). inefficient!')
out = out.copy() # independent copy
del exponents # free up memory
return out
""" Advent of Code Day 10 """
import numpy as np
import itertools
from scipy.special import binom
adapters = np.loadtxt('./input_day10.txt', dtype=np.int64)
adapters = np.concatenate(([0], np.sort(adapters), [np.max(adapters) + 3]))
diffs = np.diff(adapters)
# Part I
count1 = (diffs == 1).sum()
count3 = (diffs == 3).sum()
print(count1 * count3)
# Part II
# Assuming there are no voltage diffs of 2 in the sorted adapter list.
# For each island of N<=5 adapters with voltage diff = 1, we can drop groups
# of 0, 1 or 2 adapters (if island size allows).
nperms = 1
for diff, group in itertools.groupby(diffs):
if diff == 1:
group = list(group)
nfree = len(group) - 1
fac = np.sum([binom(nfree, i) for i in [0, 1, 2]])
if nfree > 3: # no cases like this in the input...
raise ValueError('Invalid forumula')
nperms *= fac
print(int(nperms))
def delannoy(m, n):
s = 0
for k in range(min(m, n) + 1):
s += binom(m, k) * binom(n, k) * 2**k
return s
def minNforHDIpower(genPriorMean,
genPriorN,
HDImaxwid=None,
nullVal=None,
ROPE=None,
desiredPower=0.8,
audPriorMean=0.5,
audPriorN=2,
HDImass=0.95,
initSampSize=1,
verbose=True):
import numpy as np
from HDIofICDF import HDIofICDF, beta
from scipy.special import binom, betaln
if HDImaxwid != None and nullVal != None:
sys.exit('One and only one of HDImaxwid and nullVal must be specified')
if ROPE == None:
ROPE = [nullVal, nullVal]
# Convert prior mean and N to a, b parameter values of beta distribution.
genPriorA = genPriorMean * genPriorN
genPriorB = (1.0 - genPriorMean) * genPriorN
audPriorA = audPriorMean * audPriorN
audPriorB = (1.0 - audPriorMean) * audPriorN
# Initialize loop for incrementing sampleSize
sampleSize = initSampSize
# Increment sampleSize until desired power is achieved.
while True:
zvec = np.arange(0,
sampleSize + 1) # All possible z values for N flips.
# Compute probability of each z value for data-generating prior.
pzvec = np.exp(
np.log(binom(sampleSize, zvec)) +
betaln(zvec + genPriorA, sampleSize - zvec + genPriorB) -
betaln(genPriorA, genPriorB))
# For each z value, compute HDI. hdiMat is min, max of HDI for each z.
hdiMat = np.zeros((len(zvec), 2))
for zIdx in range(0, len(zvec)):
z = zvec[zIdx]
# Determine the limits of the highest density interval
# hdp is a function from PyMC package and takes a sample vector as
# input, not a function.
hdiMat[zIdx] = HDIofICDF(beta,
credMass=HDImass,
a=(z + audPriorA),
b=(sampleSize - z + audPriorB))
if HDImaxwid != None:
hdiWid = hdiMat[:, 1] - hdiMat[:, 0]
powerHDI = np.sum(pzvec[hdiWid < HDImaxwid])
if nullVal != None:
powerHDI = np.sum(pzvec[(hdiMat[:, 0] > ROPE[1]) |
(hdiMat[:, 1] < ROPE[0])])
if verbose:
print(" For sample size = %s\npower = %s\n" %
(sampleSize, powerHDI))
if powerHDI > desiredPower:
break
else:
sampleSize += 1
return sampleSize
if __name__ == '__main__':
def print_header(text):
print('\n\033[1m\033[31m\033[4m{}\033[0m'.format(text))
# Original solutions
print_header('Original solutions')
print(list(recur(nuts, [], None)))
# Approximate distribution of solutions.
#
# We use Hoeffding's inequality to be 0.95 confident that we are 0.01
# within true probabilities. That is n >= 1/(2*epsilon^2) * log(2/alpha) ~=
# 18444.
trials = 18444
all_nuts = {Nut(perm) for perm in permutations(range(1, 7))}
counts = Counter()
for _ in range(trials):
nuts = set(sample(all_nuts, 7))
n_sols = sum(1 for _ in recur(nuts, [], None))
counts[n_sols] += 1
print_header('Distribution of number of solutions')
total = binom(len(all_nuts), 7)
for k, v in counts.most_common():
f = v / trials
print('{:<4}{:<10.2e}{:<8.1%}{}'.format(k, f * total, f,
'=' * int(f * 40)))
def fBinomial(x, n, p):
k = np.around(x)
return sp.binom(n, k) * p**k * (1. - p)**(n - k)
def AlgebraicCoalescentJCExpectedKmerDistance(x, theta, k):
#return(2*(m-k+1)*(1-1.0/4**k*sum([binom(k,i)*3*(3*x)**i/(3+8*theta*i) for i in range(k+1)])))
return ((1 - 1.0 / 4**k * sum([
binom(k, i) * 3 * (3 * x)**i / (3 + 8 * theta * i)
for i in range(k + 1)
])))
def hockey_stick_pmf_unstable(n, k):
pmf = np.zeros(shape=(n, ), dtype=np.float)
for idx in range(n):
i = idx + 1
pmf[idx] = binom(i - 1, k - 1) / binom(n, k)
return pmf
def out_deg_distro(n, k, d, vd, c, m, alpha):
z = compute_z(d, vd, c, m, alpha)
return binom(n - 1, k) * z**k * (1 - z)**(n - k - 1)
def binomial(n, p, towhere):
probability = 0
for indx in range(towhere + 1):
probability += spc.binom(n, indx) * p**indx * (1 - p)**(n - indx)
return probability
def catalan(n):
return int(binom(2*n, n)) // (n+1)
def grunspan_prob(n, q):
p = 1 - q
prob = 1.0
for k in range(n):
prob -= (p**n * q**k - q**n * p**k) * binom(k + n - 1, k)
return prob
def _point_probability(k, n, l, p: float = 0.5): # noqa:E741
return binom(n - l, k) * p**k * (1 - p)**(n - k - l)
