def CompHyperPlane(V,K): # compute the outwards normal direction #V: vertex; K: vertex index for each facet ns = zeros((shape(K)[0],shape(V)[1]+1)) # normal of each hyperplane and offset NP=[] #invalid hyperplane nbCol= shape(V)[1] for i in range(shape(K)[0]): tmp = zeros((shape(V[K[i,:],:])[0],nbCol+1)) tmp[:,0:nbCol] = V[K[i,:],:] tmp[:,nbCol]= ones((shape(V[K[i,:],:])[0])) tmp1= nullspace(tmp) tmp1 = transpose(tmp1) if shape(tmp1)[0]== 0: print "Oops! Not Valid......" if shape(tmp1)[0]>1: ns[i,:] = tmp1[0,:] NP.append(i) else: ns[i,:] = tmp1[0,:] #check the normal and it is outwards direction: """ If V is a normal, b is an offset, and x is a point inside the convex hull, then Vx+b <0. In the newer version of scipy, this hyperplane is given as an output. """ if dot(ns[i,0:6],V[K[i,0],:])<0: ns[i,:] = -ns[i,:] ns = numpy.delete(ns,NP,0) K = numpy.delete(K, NP,0) return ns, K
def SetT(self):
if self.H_hat.shape[0] != 0:
NS = nullspace(self.H_hat)
if rank(NS) >= self.Nj:
self.PrecodingT = NS[:, 0:self.Nj]
else:
self.PrecodingT = [None]
else:
self.PrecodingT = [None]
def extractVoltage(self, y):
# Construct matrix A, work out the math more carefully
A = np.zeros((self.COUNT, self.COUNT))
for i in range(len(y)):
A -= y[i] * self.F_MATRICES[i]
A += np.identity(self.COUNT)
# Find the null space of matrix A
ns = nullspace(A)
return ns
def checkit(a):
print "a:"
print a
r = rank(a)
print "rank is", r
ns = nullspace(a)
print "nullspace:"
print ns
if ns.size > 0:
res = np.abs(np.dot(a, ns)).max()
print "max residual is", res
def circumference(c,r,Nvec,np):
"""
Function that generates the coordinates of a circunference as a
3xnumberOfPoints matrix.
---Inputs---
c - center of circumfarence.
r - radius of circumference.
Nvec - vector normal to the circumference, used to rotate the circunfarence (vortex ring)
np - number of points defining the circumference
---
C.Losada de la Lastra 2014
NOTE: For the purpose of this project the matrix 'C' contains np+1 columns.
This is to take into account the need to close the circunference when
plotting the circunference or calculating the induced velocity due to the vortex ring.
"""
from rank_nullspace import nullspace #.pyc file where nullspace is defined
#range of angles corresponding to the points on the circumference
theta = N.array([i*(2*M.pi/np) for i in range(np)])
thet_cos = N.array([M.cos(theta[i]) for i in range(len(theta))])
theta_cos = N.array([thet_cos,])
thet_sin = N.array([M.sin(theta[i]) for i in range(len(theta))])
theta_sin = N.array([thet_sin,])
#rotation of the circunference with respect to the vector normal to the ring
rot = N.array(nullspace(Nvec))#rotation vecors y & z
rot_y = N.array([rot[:,0],]).transpose()
rot_z = N.array([rot[:,1],]).transpose()
#rotation of the x,y,z coordinates of the cirumference
C_origin = N.array([c,]*(np)).transpose()
C_y = r*N.dot(rot_y,theta_cos)
C_z = r*N.dot(rot_z,theta_sin)
C = C_origin + C_y + C_z
#points in the middle of the segments forming the circumference
#where the velocity will be induced from (more realistic)
C_iVel = N.zeros_like(C)
for i in range(len(C_y[0])):
pnt = N.array([C[0][i],C[1][i],C[2][i]])
pnt0 = N.array([C[0][i-1],C[1][i-1],C[2][i-1]])
vect = pnt0-pnt
vect_u = vect/LA.norm(vect)
ivel_pnt = pnt + vect_u*(LA.norm(vect)/2)
C_iVel[0][i]=ivel_pnt[0]
C_iVel[1][i]=ivel_pnt[1]
C_iVel[2][i]=ivel_pnt[2]
return N.array([C, C_iVel])
def ContactPrimitive(p,np, mu, nb): W = zeros((6,nb)) ns = nullspace(np) X=transpose(ns[:,0]) Z=np Y =cross(Z, X) R=ones((3,3)) R[0:3,0] = X R[0:3,1] = Y R[0:3,2] = Z for i in range(nb): W[0,i]= mu*cos(float(i)/nb*2.0*pi) W[1,i]= mu*sin(float(i)/nb*2*pi) W[2,i]= 1 W[0:3,i] = dot(R,W[0:3,i]) W[3:6,i] = cross(p,W[0:3,i]) return transpose(W)
def calculate_knfst(K, labels):
'''
Calculates projection matrix of KNFST
'''
classes = np.unique(labels)
if len(classes) < 2:
raise Exception("KNFST requires 2 or more classes")
n, m = K.shape
if n != m:
raise Exception("Kernel matrix must be quadratic")
centered_k = KernelCenterer().fit_transform(K)
basis_values, basis_vecs = np.linalg.eig(centered_k)
idx = basis_values.argsort()[::-1]
basis_values = basis_values[idx]
basis_vecs = basis_vecs[:, idx]
basis_vecs = basis_vecs[:,basis_values > 1e-12]
basis_values = basis_values[basis_values > 1e-12]
basis_values = np.diag(1.0/np.sqrt(basis_values))
basis_vecs = basis_vecs.dot(basis_values)
L = np.zeros([n,n])
for cl in classes:
for idx1, x in enumerate(labels == cl):
for idx2, y in enumerate(labels == cl):
if x and y:
L[idx1, idx2] = 1.0/np.sum(labels==cl)
M = np.ones([m,m])/m
H = ((np.eye(m,m)-M).dot(basis_vecs)).T.dot(K).dot(np.eye(n,m)-L)
t_sw = H.dot(H.T)
eigenvecs = nullspace(t_sw)
if eigenvecs.shape[1] < 1:
eigenvals, eigenvecs = np.linalg.eig(t_sw)
eigenvals = np.diag(eigenvals)
min_idx = eigenvals.argsort()[0]
eigenvecs = eigenvecs[:, min_idx]
proj = (np.eye(m,m)-M).dot(basis_vecs).dot(eigenvecs)
return proj
def calculate_knfst(K, labels):
'''
Calculates projection matrix of KNFST
'''
classes = np.unique(labels)
if len(classes) < 2:
raise Exception("KNFST requires 2 or more classes")
n, m = K.shape
if n != m:
raise Exception("Kernel matrix must be quadratic")
centered_k = KernelCenterer().fit_transform(K)
basis_values, basis_vecs = np.linalg.eig(centered_k)
idx = basis_values.argsort()[::-1]
basis_values = basis_values[idx]
basis_vecs = basis_vecs[:, idx]
basis_vecs = basis_vecs[:, basis_values > 1e-12]
basis_values = basis_values[basis_values > 1e-12]
basis_values = np.diag(1.0 / np.sqrt(basis_values))
basis_vecs = basis_vecs.dot(basis_values)
L = np.zeros([n, n])
for cl in classes:
for idx1, x in enumerate(labels == cl):
for idx2, y in enumerate(labels == cl):
if x and y:
L[idx1, idx2] = 1.0 / np.sum(labels == cl)
M = np.ones([m, m]) / m
H = ((np.eye(m, m) - M).dot(basis_vecs)).T.dot(K).dot(np.eye(n, m) - L)
t_sw = H.dot(H.T)
eigenvecs = nullspace(t_sw)
if eigenvecs.shape[1] < 1:
eigenvals, eigenvecs = np.linalg.eig(t_sw)
eigenvals = np.diag(eigenvals)
min_idx = eigenvals.argsort()[0]
eigenvecs = eigenvecs[:, min_idx]
proj = (np.eye(m, m) - M).dot(basis_vecs).dot(eigenvecs)
return proj
def get_prob_dist(M):
'''
Input:
M : matrix
Output:
dist : prob normalised nullspace vector of M
'''
nullspace = rank_nullspace.nullspace(M, rtol=1e-9)
if (nullspace.shape[1] > 0):
#non-trivial nullspace exists for M
# dist is prob distribution
dist = nullspace[:, 0] / nullspace[:, 0].sum(axis=0)
else:
#nullspace is trivial, in this case there is no stable prob. distribution,
#In case raised, try changing the rtol parameter
raise ValueError(
'Nullspace of Markov matrix is trivial. No probability distribution exists'
)
return dist
def get_prob_dist(self):
'''
Output:
dist : prob normalised nullspace vector of M
'''
# Adjacency matrix, caution not the Markov matrix
A = nx.to_numpy_matrix(self.G)
# look at this carefully
M = A.T - np.diag(np.array(A.sum(axis=1)).reshape((A.shape[0])))
try:
nullspace = rank_nullspace.nullspace(M,rtol=1e-9,atol=1e-9)
if (nullspace.shape[1] > 0):
#non-trivial nullspace exists for M
# dist is prob distribution
self.dist = nullspace[:,0]/nullspace[:,0].sum(axis=0)
else:
#nullspace is trivial, in this case there is no stable prob. distribution,
#In case raised, try changing the rtol parameter
raise ValueError('Nullspace of Markov matrix is trivial. No probability distribution exists')
except (ValueError,np.linalg.LinAlgError) as e:
raise exceptions.InvalidChargeState
return self.dist
print print '*****' # now show a under-determined system allows more solutions kFlips = 7 # confirm more probs would completely determine this situation # (will be by analogy to the moment curve) print '***** nSides =',nSides,'kFlips =',kFlips sU = freqSystem(nSides,kFlips) print 'is full rank' print rank(sU['a'].T * sU['a'])==kFlips+1 print 'can extend to full rank' sCheck = freqSystem(nSides,kFlips,stepMult=2) print rank(sCheck['a'].T * sCheck['a'])==kFlips+1 wiggleRoom = nullspace(sU['a']) print 'confirm null vecs' wiggleDim = wiggleRoom.shape[1] print (wiggleRoom.shape[0]==kFlips+1) & \ (wiggleDim + nSides-1==kFlips+1) & \ (numpy.matrix.max(abs(sU['a'] * wiggleRoom))<1.0e-12) baseSoln = empiricalMeansEstimates(nSides,kFlips) print 'empirical solution' printEsts(baseSoln) baseLosses = losses(nSides,baseSoln) print 'empirical solution losses' printLosses(baseLosses) def wsoln(x): return baseSoln + matMulFlatten(wiggleRoom,x)
def compute_paths(T, econ):
"""
Compute simulated time paths for exogenous and endogenous variables.
Parameters
===========
T: int
Length of the simulation
econ: a namedtuple of type 'Economy', containing
beta - Discount factor
Sg - Govt spending selector matrix
Sd - Exogenous endowment selector matrix
Sb - Utility parameter selector matrix
Ss - Coupon payments selector matrix
discrete - Discrete exogenous process (True or False)
proc - Stochastic process parameters
Returns
========
path: a namedtuple of type 'Path', containing
g - Govt spending
d - Endowment
b - Utility shift parameter
s - Coupon payment on existing debt
c - Consumption
l - Labor
p - Price
tau - Tax rate
rvn - Revenue
B - Govt debt
R - Risk free gross return
pi - One-period risk-free interest rate
Pi - Cumulative rate of return, adjusted
xi - Adjustment factor for Pi
The corresponding values are flat numpy ndarrays.
"""
# == Simplify names == #
beta, Sg, Sd, Sb, Ss = econ.beta, econ.Sg, econ.Sd, econ.Sb, econ.Ss
if econ.discrete:
P, x_vals = econ.proc
else:
A, C = econ.proc
# == Simulate the exogenous process x == #
if econ.discrete:
state = mc_tools.sample_path(P, init=0, sample_size=T)
x = x_vals[:, state]
else:
# == Generate an initial condition x0 satisfying x0 = A x0 == #
nx, nx = A.shape
x0 = nullspace((eye(nx) - A))
x0 = -x0 if (x0[nx - 1] < 0) else x0
x0 = x0 / x0[nx - 1]
# == Generate a time series x of length T starting from x0 == #
nx, nw = C.shape
x = zeros((nx, T))
w = randn(nw, T)
x[:, 0] = x0.T
for t in range(1, T):
x[:, t] = dot(A, x[:, t - 1]) + dot(C, w[:, t])
# == Compute exogenous variable sequences == #
g, d, b, s = (dot(S, x).flatten() for S in (Sg, Sd, Sb, Ss))
# == Solve for Lagrange multiplier in the govt budget constraint == #
## In fact we solve for nu = lambda / (1 + 2*lambda). Here nu is the
## solution to a quadratic equation a(nu**2 - nu) + b = 0 where
## a and b are expected discounted sums of quadratic forms of the state.
Sm = Sb - Sd - Ss
# == Compute a and b == #
if econ.discrete:
ns = P.shape[0]
F = scipy.linalg.inv(np.identity(ns) - beta * P)
a0 = 0.5 * dot(F, dot(Sm, x_vals).T ** 2)[0]
H = dot(Sb - Sd + Sg, x_vals) * dot(Sg - Ss, x_vals)
b0 = 0.5 * dot(F, H.T)[0]
a0, b0 = float(a0), float(b0)
else:
H = dot(Sm.T, Sm)
a0 = 0.5 * var_quadratic_sum(A, C, H, beta, x0)
H = dot((Sb - Sd + Sg).T, (Sg + Ss))
b0 = 0.5 * var_quadratic_sum(A, C, H, beta, x0)
# == Test that nu has a real solution before assigning == #
warning_msg = """
Hint: you probably set government spending too {}. Elect a {}
Congress and start over.
"""
disc = a0 ** 2 - 4 * a0 * b0
if disc >= 0:
nu = 0.5 * (a0 - sqrt(disc)) / a0
else:
print "There is no Ramsey equilibrium for these parameters."
print warning_msg.format("high", "Republican")
sys.exit(0)
# == Test that the Lagrange multiplier has the right sign == #
if nu * (0.5 - nu) < 0:
print "Negative multiplier on the government budget constraint."
print warning_msg.format("low", "Democratic")
sys.exit(0)
# == Solve for the allocation given nu and x == #
Sc = 0.5 * (Sb + Sd - Sg - nu * Sm)
Sl = 0.5 * (Sb - Sd + Sg - nu * Sm)
c = dot(Sc, x).flatten()
l = dot(Sl, x).flatten()
p = dot(Sb - Sc, x).flatten() # Price without normalization
tau = 1 - l / (b - c)
rvn = l * tau
# == Compute remaining variables == #
if econ.discrete:
H = dot(Sb - Sc, x_vals) * dot(Sl - Sg, x_vals) - dot(Sl, x_vals) ** 2
temp = dot(F, H.T).flatten()
B = temp[state] / p
H = dot(P[state, :], dot(Sb - Sc, x_vals).T).flatten()
R = p / (beta * H)
temp = dot(P[state, :], dot(Sb - Sc, x_vals).T).flatten()
xi = p[1:] / temp[: T - 1]
else:
H = dot(Sl.T, Sl) - dot((Sb - Sc).T, Sl - Sg)
L = np.empty(T)
for t in range(T):
L[t] = var_quadratic_sum(A, C, H, beta, x[:, t])
B = L / p
Rinv = (beta * dot(dot(Sb - Sc, A), x)).flatten() / p
R = 1 / Rinv
AF1 = dot(Sb - Sc, x[:, 1:])
AF2 = dot(dot(Sb - Sc, A), x[:, : T - 1])
xi = AF1 / AF2
xi = xi.flatten()
pi = B[1:] - R[: T - 1] * B[: T - 1] - rvn[: T - 1] + g[: T - 1]
Pi = cumsum(pi * xi)
# == Prepare return values == #
path = Path(g=g, d=d, b=b, s=s, c=c, l=l, p=p, tau=tau, rvn=rvn, B=B, R=R, pi=pi, Pi=Pi, xi=xi)
return path
def circumference(c, r, Nvec, np):
"""
Function that generates the coordinates of a circunference as a
3xnumberOfPoints matrix.
---Inputs---
c - center of circumfarence.
r - radius of circumference.
Nvec - vector normal to the circumference, used to rotate the circunfarence (vortex ring)
np - number of points defining the circumference
---
C.Losada de la Lastra 2014
NOTE: For the purpose of this project the matrix 'C' contains np+1 columns.
This is to take into account the need to close the circunference when
plotting the circunference or calculating the induced velocity due to the vortex ring.
"""
from rank_nullspace import nullspace #.pyc file where nullspace is defined
#range of angles corresponding to the points on the circumference
theta = N.array([i * (2 * M.pi / np) for i in range(np)])
thet_cos = N.array([M.cos(theta[i]) for i in range(len(theta))])
theta_cos = N.array([
thet_cos,
])
thet_sin = N.array([M.sin(theta[i]) for i in range(len(theta))])
theta_sin = N.array([
thet_sin,
])
#rotation of the circunference with respect to the vector normal to the ring
rot = N.array(nullspace(Nvec)) #rotation vecors y & z
rot_y = N.array([
rot[:, 0],
]).transpose()
rot_z = N.array([
rot[:, 1],
]).transpose()
#rotation of the x,y,z coordinates of the cirumference
C_origin = N.array([
c,
] * (np)).transpose()
C_y = r * N.dot(rot_y, theta_cos)
C_z = r * N.dot(rot_z, theta_sin)
C = C_origin + C_y + C_z
#points in the middle of the segments forming the circumference
#where the velocity will be induced from (more realistic)
C_iVel = N.zeros_like(C)
for i in range(len(C_y[0])):
pnt = N.array([C[0][i], C[1][i], C[2][i]])
pnt0 = N.array([C[0][i - 1], C[1][i - 1], C[2][i - 1]])
vect = pnt0 - pnt
vect_u = vect / LA.norm(vect)
ivel_pnt = pnt + vect_u * (LA.norm(vect) / 2)
C_iVel[0][i] = ivel_pnt[0]
C_iVel[1][i] = ivel_pnt[1]
C_iVel[2][i] = ivel_pnt[2]
return N.array([C, C_iVel])
X_scaler = StandardScaler().fit(X_raw)
X_std = X_scaler.transform(X_raw) # cf .inverse_transform()
# Acoustics
Y_scaler = StandardScaler().fit(Y_raw)
Y_std = Y_scaler.transform(Y_raw)
# PCA
pca = PCA(n_components=3)
pca.fit(X_std)
X_reduced = pca.transform(X_std)
# Linear Regression
# X*w = y
W = np.dot(np.linalg.pinv(X_reduced), Y_std)
# Get null space
nullvec = nullspace(W.T)
# Compute median articulation & acoustic values
medianArtic = np.zeros((len(vowel_list), 14))
medianAcous = np.zeros((len(vowel_list), 2))
for i, v in enumerate(vowel_list):
x = df.loc[df.Label == v, artic_col].values
y = df.loc[df.Label == v, acous_col].values
medianArtic[i, :] = np.median(x, axis=0) # 7x14
medianAcous[i, :] = np.median(y, axis=0) # 7x2
# Estimate F1, F2 for each vowel
y_scaled_vowels = np.dot(pca.transform(X_scaler.transform(medianArtic)), W)
y_vowels = Y_scaler.inverse_transform(y_scaled_vowels) # 7x2
def compute_paths(T, econ):
"""
Compute simulated time paths for exogenous and endogenous variables.
Parameters
===========
T: int
Length of the simulation
econ: a namedtuple of type 'Economy', containing
beta - Discount factor
Sg - Govt spending selector matrix
Sd - Exogenous endowment selector matrix
Sb - Utility parameter selector matrix
Ss - Coupon payments selector matrix
discrete - Discrete exogenous process (True or False)
proc - Stochastic process parameters
Returns
========
path: a namedtuple of type 'Path', containing
g - Govt spending
d - Endowment
b - Utility shift parameter
s - Coupon payment on existing debt
c - Consumption
l - Labor
p - Price
tau - Tax rate
rvn - Revenue
B - Govt debt
R - Risk free gross return
pi - One-period risk-free interest rate
Pi - Cumulative rate of return, adjusted
xi - Adjustment factor for Pi
The corresponding values are flat numpy ndarrays.
"""
# == Simplify names == #
beta, Sg, Sd, Sb, Ss = econ.beta, econ.Sg, econ.Sd, econ.Sb, econ.Ss
if econ.discrete:
P, x_vals = econ.proc
else:
A, C = econ.proc
# == Simulate the exogenous process x == #
if econ.discrete:
state = mc_tools.sample_path(P, init=0, sample_size=T)
x = x_vals[:,state]
else:
# == Generate an initial condition x0 satisfying x0 = A x0 == #
nx, nx = A.shape
x0 = nullspace((eye(nx) - A))
x0 = -x0 if (x0[nx-1] < 0) else x0
x0 = x0 / x0[nx-1]
# == Generate a time series x of length T starting from x0 == #
nx, nw = C.shape
x = zeros((nx, T))
w = randn(nw, T)
x[:, 0] = x0.T
for t in range(1,T):
x[:, t] = dot(A, x[:, t-1]) + dot(C, w[:, t])
# == Compute exogenous variable sequences == #
g, d, b, s = (dot(S, x).flatten() for S in (Sg, Sd, Sb, Ss))
# == Solve for Lagrange multiplier in the govt budget constraint == #
## In fact we solve for nu = lambda / (1 + 2*lambda). Here nu is the
## solution to a quadratic equation a(nu**2 - nu) + b = 0 where
## a and b are expected discounted sums of quadratic forms of the state.
Sm = Sb - Sd - Ss
# == Compute a and b == #
if econ.discrete:
ns = P.shape[0]
F = scipy.linalg.inv(np.identity(ns) - beta * P)
a0 = 0.5 * dot(F, dot(Sm, x_vals).T**2)[0]
H = dot(Sb - Sd + Sg, x_vals) * dot(Sg - Ss, x_vals)
b0 = 0.5 * dot(F, H.T)[0]
a0, b0 = float(a0), float(b0)
else:
H = dot(Sm.T, Sm)
a0 = 0.5 * var_quadratic_sum(A, C, H, beta, x0)
H = dot((Sb - Sd + Sg).T, (Sg + Ss))
b0 = 0.5 * var_quadratic_sum(A, C, H, beta, x0)
# == Test that nu has a real solution before assigning == #
warning_msg = """
Hint: you probably set government spending too {}. Elect a {}
Congress and start over.
"""
disc = a0**2 - 4 * a0 * b0
if disc >= 0:
nu = 0.5 * (a0 - sqrt(disc)) / a0
else:
print "There is no Ramsey equilibrium for these parameters."
print warning_msg.format('high', 'Republican')
sys.exit(0)
# == Test that the Lagrange multiplier has the right sign == #
if nu * (0.5 - nu) < 0:
print "Negative multiplier on the government budget constraint."
print warning_msg.format('low', 'Democratic')
sys.exit(0)
# == Solve for the allocation given nu and x == #
Sc = 0.5 * (Sb + Sd - Sg - nu * Sm)
Sl = 0.5 * (Sb - Sd + Sg - nu * Sm)
c = dot(Sc, x).flatten()
l = dot(Sl, x).flatten()
p = dot(Sb - Sc, x).flatten() # Price without normalization
tau = 1 - l / (b - c)
rvn = l * tau
# == Compute remaining variables == #
if econ.discrete:
H = dot(Sb - Sc, x_vals) * dot(Sl - Sg, x_vals) - dot(Sl, x_vals)**2
temp = dot(F, H.T).flatten()
B = temp[state] / p
H = dot(P[state, :], dot(Sb - Sc, x_vals).T).flatten()
R = p / (beta * H)
temp = dot(P[state,:], dot(Sb - Sc, x_vals).T).flatten()
xi = p[1:] / temp[:T-1]
else:
H = dot(Sl.T, Sl) - dot((Sb - Sc).T, Sl - Sg)
L = np.empty(T)
for t in range(T):
L[t] = var_quadratic_sum(A, C, H, beta, x[:, t])
B = L / p
Rinv = (beta * dot(dot(Sb - Sc, A), x)).flatten() / p
R = 1 / Rinv
AF1 = dot(Sb - Sc, x[:, 1:])
AF2 = dot(dot(Sb - Sc, A), x[:, :T-1])
xi = AF1 / AF2
xi = xi.flatten()
pi = B[1:] - R[:T-1] * B[:T-1] - rvn[:T-1] + g[:T-1]
Pi = cumsum(pi * xi)
# == Prepare return values == #
path = Path(g=g,
d=d,
b=b,
s=s,
c=c,
l=l,
p=p,
tau=tau,
rvn=rvn,
B=B,
R=R,
pi=pi,
Pi=Pi,
xi=xi)
return path
print print print '*****' # now show a under-determined system allows more solutions kFlips = 7 # confirm more probs would completely determine this situation # (will be by analogy to the moment curve) print '***** nSides =', nSides, 'kFlips =', kFlips sU = freqSystem(nSides, kFlips) print 'is full rank' print rank(sU['a'].T * sU['a']) == kFlips + 1 print 'can extend to full rank' sCheck = freqSystem(nSides, kFlips, stepMult=2) print rank(sCheck['a'].T * sCheck['a']) == kFlips + 1 wiggleRoom = nullspace(sU['a']) print 'confirm null vecs' wiggleDim = wiggleRoom.shape[1] print (wiggleRoom.shape[0]==kFlips+1) & \ (wiggleDim + nSides-1==kFlips+1) & \ (numpy.matrix.max(abs(sU['a'] * wiggleRoom))<1.0e-12) baseSoln = empiricalMeansEstimates(nSides, kFlips) print 'empirical solution' printEsts(baseSoln) baseLosses = losses(nSides, baseSoln) print 'empirical solution losses' printLosses(baseLosses) print(sum(baseLosses)) print(max(baseLosses))
