def xover(chrom,N,p):
"""Single point crossover with probability N,precision p
"""
N = round(chrom.shape[0]*N)
index1 = scipy.arange(chrom.shape[0])
index2 = scipy.unique(scipy.around(scipy.rand(chrom.shape[0],)*chrom.shape[0]))[0:chrom.shape[0]/2]
sel1,sel2 = [],[]
for i in range(len(index1)):
if index1[i] not in index2:
sel1.append(index1[i])
else:
sel2.append(index1[i])
select1 = sel1[0:min([int(round(len(sel1)*N)),int(round(len(sel2)*N))])]
select2 = sel2[0:min([int(round(len(sel1)*N)),int(round(len(sel2)*N))])]
# set xover points
xoverpnt = scipy.around(scipy.rand(len(select1),)*(chrom.shape[1]-1))
# perform xover
nchrom = copy.deepcopy(chrom)
for i in range(len(select1)):
try:
slice1 = chrom[select1[i],0:int(xoverpnt[i])]
slice2 = chrom[select2[i],0:int(xoverpnt[i])]
nchrom[select2[i],0:int(xoverpnt[i])] = slice1
nchrom[select1[i],0:int(xoverpnt[i])] = slice2
except:
nchrom = nchrom
return nchrom
def __init__(self, basef,
translate=True,
rotate=False,
conditioning=None,
asymmetry=None,
oscillate=False,
penalize=None,
):
FunctionEnvironment.__init__(self, basef.xdim, basef.xopt)
self.desiredValue = basef.desiredValue
self.toBeMinimized = basef.toBeMinimized
if translate:
self.xopt = (rand(self.xdim) - 0.5) * 9.8
self._diags = eye(self.xdim)
self._R = eye(self.xdim)
self._Q = eye(self.xdim)
if conditioning is not None:
self._diags = generateDiags(conditioning, self.xdim)
if rotate:
self._R = orth(rand(basef.xdim, basef.xdim))
if conditioning:
self._Q = orth(rand(basef.xdim, basef.xdim))
tmp = lambda x: dot(self._Q, dot(self._diags, dot(self._R, x-self.xopt)))
if asymmetry is not None:
tmp2 = tmp
tmp = lambda x: asymmetrify(tmp2(x), asymmetry)
if oscillate:
tmp3 = tmp
tmp = lambda x: oscillatify(tmp3(x))
self.f = lambda x: basef.f(tmp(x))
def test_blackbox(self):
for A, b in self.cases:
x = solve(A, b, verb=False, maxiter=A.shape[0])
assert(norm(b - A*x)/norm(b - A*rand(b.shape[0],)) < 1e-4)
# Special tests
# (1) Make sure BSR format is preserved, and B is multiple vecs
A, b = self.cases[-1]
(x, ml) = solve(A, b, return_solver=True, verb=False)
assert(ml.levels[0].B.shape[1] == 3)
assert(ml.levels[0].A.format == 'bsr')
# (2) Run with solver and make sure that solution is still good
x = solve(A, b, existing_solver=ml, verb=False)
assert(norm(b - A*x)/norm(b - A*rand(b.shape[0],)) < 1e-4)
# (3) Convert to CSR, make sure B is a single vector
(x, ml) = solve(A.tocsr(), b, return_solver=True, verb=False)
assert(ml.levels[0].B.shape[1] == 1)
assert(ml.levels[0].A.format == 'csr')
# (4) Run with x0, maxiter and tol
x = solve(A, b, existing_solver=ml, x0=zeros_like(b), tol=1e-8,
maxiter=300, verb=False)
assert(norm(b - A*x)/norm(b - A*rand(b.shape[0],)) < 1e-7)
# (5) Run nonsymmetric example, make sure BH isn't None
A, b = self.cases[2]
(x, ml) = solve(A, b, return_solver=True, verb=False,
maxiter=A.shape[0])
assert(ml.levels[0].BH is not None)
def run(self):
# Para cada particula
for i in scipy.arange(self.ns):
# atualiza melhor posicao da particula
self.fit[i],aux = self.avalia_aptidao(self.pop[i])
self.pop[i] = aux.copy()
# atualiza melhor posicao da particula
self.bfp_fitness[i],aux = self.avalia_aptidao(self.bfp[i])
self.bfp[i] = aux.copy()
if self.debug:
print "self.fit[{0}] = {1} bfp_fitness = {2}".format(i,self.fit[i],self.bfp_fitness[i])
if self.bfp_fitness[i] < self.fit[i]:
self.bfp[i] = self.pop[i].copy()
self.bfp_fitness[i] = self.fit[i].copy()
# Atualiza melhor posicao global
idx = self.bfp_fitness.argmax()
curr_best_global_fitness = self.bfp_fitness[idx]
curr_best_global = self.bfp[idx].copy()
if curr_best_global_fitness > self.bfp_fitness.max():
self.bfg = curr_best_global
for i in scipy.arange(self.ns):
# Atualiza velocidade
self.v[i] = self.w*self.v[i]
self.v[i] = self.v[i] + self.c1*scipy.rand()*( self.bfp[i] - self.pop[i])
self.v[i] = self.v[i] + self.c2*scipy.rand()*(self.bfg - self.pop[i])
# Atualiza posicao
self.pop[i] = self.pop[i] + self.v[i]
# calcula fitness
self.fit[i],aux = self.avalia_aptidao(self.pop[i])
self.pop[i] = aux.copy()
def test_DAD(self):
A = poisson((50, 50), format="csr")
x = rand(A.shape[0])
b = rand(A.shape[0])
D = diag_sparse(1.0 / sqrt(10 ** (12 * rand(A.shape[0]) - 6))).tocsr()
D_inv = diag_sparse(1.0 / D.data)
DAD = D * A * D
B = ones((A.shape[0], 1))
# TODO force 2 level method and check that result is the same
kwargs = {"max_coarse": 1, "max_levels": 2, "coarse_solver": "splu"}
sa = smoothed_aggregation_solver(D * A * D, D_inv * B, **kwargs)
residuals = []
x_sol = sa.solve(b, x0=x, maxiter=10, tol=1e-12, residuals=residuals)
avg_convergence_ratio = (residuals[-1] / residuals[0]) ** (1.0 / len(residuals))
# print "Diagonal Scaling Test: %1.3e, %1.3e" %
# (avg_convergence_ratio, 0.25)
assert avg_convergence_ratio < 0.25
def test_symmetry(self):
# Test that a basic V-cycle yields a symmetric linear operator. Common
# reasons for failure are problems with using the same rho for the
# pres/post-smoothers and using the same block_D_inv for
# pre/post-smoothers.
n = 500
A = poisson((n,), format="csr")
smoothers = [
("gauss_seidel", {"sweep": "symmetric"}),
("schwarz", {"sweep": "symmetric"}),
("block_gauss_seidel", {"sweep": "symmetric"}),
"jacobi",
"block_jacobi",
]
rng = arange(1, n + 1, dtype="float").reshape(-1, 1)
Bs = [ones((n, 1)), hstack((ones((n, 1)), rng))]
for smoother in smoothers:
for B in Bs:
ml = smoothed_aggregation_solver(A, B, max_coarse=10, presmoother=smoother, postsmoother=smoother)
P = ml.aspreconditioner()
x = rand(n)
y = rand(n)
assert_approx_equal(dot(P * x, y), dot(x, P * y))
def test_poisson(self):
cases = []
cases.append((500,))
cases.append((250, 250))
cases.append((25, 25, 25))
for case in cases:
A = poisson(case, format='csr')
np.random.seed(0) # make tests repeatable
x = sp.rand(A.shape[0])
b = A*sp.rand(A.shape[0]) # zeros_like(x)
ml = ruge_stuben_solver(A, max_coarse=50)
res = []
x_sol = ml.solve(b, x0=x, maxiter=20, tol=1e-12,
residuals=res)
del x_sol
avg_convergence_ratio = (res[-1]/res[0])**(1.0/len(res))
assert(avg_convergence_ratio < 0.20)
def test_symmetry(self):
# Test that a basic V-cycle yields a symmetric linear operator. Common
# reasons for failure are problems with using the same rho for the
# pres/post-smoothers and using the same block_D_inv for
# pre/post-smoothers.
n = 500
A = poisson((n,), format='csr')
smoothers = [('gauss_seidel', {'sweep': 'symmetric'}),
('schwarz', {'sweep': 'symmetric'}),
('block_gauss_seidel', {'sweep': 'symmetric'}),
'jacobi', 'block_jacobi']
rng = np.arange(1, n + 1, dtype='float').reshape(-1, 1)
Bs = [np.ones((n, 1)), sp.hstack((np.ones((n, 1)), rng))]
# TODO:
# why does python 3 require significant=6 while python 2 passes
# why does python 3 yield a different dot() below than python 2
# only for: ('gauss_seidel', {'sweep': 'symmetric'})
for smoother in smoothers:
for B in Bs:
ml = smoothed_aggregation_solver(A, B, max_coarse=10,
presmoother=smoother,
postsmoother=smoother)
P = ml.aspreconditioner()
np.random.seed(0)
x = sp.rand(n,)
y = sp.rand(n,)
out = (np.dot(P * x, y), np.dot(x, P * y))
# print("smoother = %s %g %g" % (smoother, out[0], out[1]))
assert_approx_equal(out[0], out[1])
def test_improve_candidates(self):
##
# test improve_candidates for the Poisson problem and elasticity, where rho_scale is
# the amount that each successive improve_candidates option should improve convergence
# over the previous improve_candidates option.
improve_candidates_list = [None, [('block_gauss_seidel', {'iterations' : 4, 'sweep':'symmetric'})] ]
# make tests repeatable
numpy.random.seed(0)
cases = []
A_elas,B_elas = linear_elasticity( (60,60), format='bsr')
# Matrix Candidates rho_scale
cases.append( (poisson( (61,61), format='csr'), ones((61*61,1)), 0.9 ) )
cases.append( (A_elas, B_elas, 0.9 ) )
for (A,B,rho_scale) in cases:
last_rho = -1.0
x0 = rand(A.shape[0],1)
b = rand(A.shape[0],1)
for improve_candidates in improve_candidates_list:
ml = smoothed_aggregation_solver(A, B, max_coarse=10, improve_candidates=improve_candidates)
residuals=[]
x_sol = ml.solve(b,x0=x0,maxiter=20,tol=1e-10, residuals=residuals)
rho = (residuals[-1]/residuals[0])**(1.0/len(residuals))
if last_rho == -1.0:
last_rho = rho
else:
# each successive improve_candidates option should be an improvement on the previous
# print "\nimprove_candidates Test: %1.3e, %1.3e, %d\n"%(rho,rho_scale*last_rho,A.shape[0])
assert(rho < rho_scale*last_rho)
last_rho = rho
def driver():
"""
Driver function for testing Laguerre polynomials
"""
from scipy import rand, randn
from numpy import ceil
all_tests = ValidationContainer()
""" Laguerre case """
N = int(ceil(50*rand()))
all_tests.extend(quadrature_test(N,alpha=0.))
all_tests.extend(evaluation_test(N,alpha=0.))
""" Random generalized case 1 """
N = int(ceil(50*rand()))
alpha = 10*rand()
all_tests.extend(quadrature_test(N, alpha=alpha))
all_tests.extend(evaluation_test(N, alpha=alpha))
""" Random generalized case 2 """
N = int(ceil(50*rand()))
alpha = 10*rand()
all_tests.extend(quadrature_test(N, alpha=alpha))
all_tests.extend(evaluation_test(N, alpha=alpha))
return all_tests
def test_poisson(self):
cases = []
# perturbed Laplacian
A = poisson( (50,50), format='csr' )
Ai = A.copy(); Ai.data = Ai.data + 1e-5j*rand(Ai.nnz)
cases.append((Ai, 0.25))
# imaginary Laplacian
Ai = 1.0j*A
cases.append((Ai, 0.25))
## JBS: Not sure if this is a valid test case
## imaginary shift
#Ai = A + 1.1j*scipy.sparse.eye(A.shape[0], A.shape[1])
#cases.append((Ai,0.8))
for A,rratio in cases:
[asa,work] = adaptive_sa_solver(A, num_candidates = 1, symmetry='symmetric')
#sa = smoothed_aggregation_solver(A, B = ones((A.shape[0],1)) )
b = zeros((A.shape[0],))
x0 = rand(A.shape[0],) + 1.0j*rand(A.shape[0],)
residuals0 = []
residuals1 = []
sol0 = asa.solve(b, x0=x0, maxiter=20, tol=1e-10, residuals=residuals0)
#sol1 = sa.solve(b, x0=x0, maxiter=20, tol=1e-10, residuals=residuals1)
conv_asa = (residuals0[-1]/residuals0[0])**(1.0/len(residuals0))
#conv_sa = (residuals1[-1]/residuals1[0])**(1.0/len(residuals1))
assert( conv_asa < rratio )
def __new__(self, nbinaries=1e6):
arr = sp.ones(nbinaries, dtype=[(name, 'f8') for name in ['period', 'mass_ratio', 'eccentricity', 'phase', 'theta', 'inclination']])
arr['eccentricity'] = 0.
arr['phase'] = sp.rand(nbinaries)
arr['theta'] = sp.rand(nbinaries) * 2 * sp.pi
arr['inclination'] = sp.arccos(sp.rand(nbinaries) * 2. - 1.)
return arr.view(OrbitalParameters)
def __init__(self, type='random', pars=parameters()):
if type == 'random':
ee = (rand(pars['Ne'], pars['Ne']) < pars['p_ee'])
ei = (rand(pars['Ne'], pars['Ni']) < pars['p_ei'])
ii = (rand(pars['Ni'], pars['Ni']) < pars['p_ii'])
ie = (rand(pars['Ni'], pars['Ne']) < pars['p_ie'])
self.A = vstack((hstack((ee, ei)), hstack((ie, ii))))
self.A[range(pars['Ne'] + pars['Ni']), range(pars['Ne'] + pars['Ni'])] = 0 # remove selfloops
elif type == 'none':
self.A = zeros((pars['N'], pars['N'])) # no connectivity
elif type == 'uni_torus': # torus with uniform connectivity profile
self.A = zeros((pars['N'], pars['N']))
# construct matrix of pairwise distance
distMat = zeros((pars['N'], pars['N']))
for n1 in range(pars['N']):
coord1 = linear2grid(n1, pars['N_col'])
for n2 in arange(n1 + 1, pars['N']):
coord2 = linear2grid(n2, pars['N_col']) - coord1 # this sets neuron n1 to the origin
distMat[n1, n2] = toric_length(coord2, pars['N_row'], pars['N_col'])
distMat = distMat + distMat.transpose()
# construct adjajency matrix
for n1 in range(pars['N']):
neighbor_ids = nonzero(distMat[:, n1] < pars['sigma_con'])[0]
random.shuffle(neighbor_ids)
idx = neighbor_ids[0:min([pars['ncon'], len(neighbor_ids)])]
self.A[idx, n1] = 1
else:
print "type " + type + " not yet implemented"
def setUp(self):
SP.random.seed(1)
nr = 3
nc = 5
n_dim1 = 8
n_dim2 = 12
# truncation of soft kronecker
self.n_trunk = 10
Xr = SP.rand(nr, n_dim1)
Xc = SP.rand(nc, n_dim2)
Cr = dlimix.CCovSqexpARD(n_dim1)
Cr.setX(Xr)
Cc = dlimix.CCovLinearARD(n_dim2)
Cc.setX(Xc)
self.C = dlimix.CKroneckerCF()
self.C.setRowCovariance(Cr)
self.C.setColCovariance(Cc)
# set kronecker index
self.kronecker_index = dlimix.CKroneckerCF.createKroneckerIndex(nc, nr)
self.n = self.C.Kdim()
self.n_dim = self.C.getNumberDimensions()
self.name = "CKroneckerCF"
self.n_params = self.C.getNumberParams()
params = SP.exp(SP.randn(self.n_params))
self.C.setParams(params)
def initial_cond(coords, mass, dipole, temp, F):
cm_coords = coords - tile(center_of_mass(coords, mass), (coords.shape[0], 1))
print "computing inertia tensor and principal axes of inertia"
mol_I, mol_Ix = eig(inertia_tensor(cm_coords, mass))
mol_I.sort()
print "principal moments of inertia are: ", mol_I
# compute the ratio of the dipole energy to the
# rotational energy
print "x = (mu*F / kB*T_R) = ", norm(dipole) * F / kB_au / temp
# random initial angular velocity vector
# magnitude set so that 0.5 * I * w**2.0 = kT
w_mag = sqrt(2.0 * kB_au * temp / mol_I.mean())
w0 = 2.0 * rand(3) - 1.0
w0 = w0 / norm(w0) * w_mag
# random initial orientation / random unit quaternion
q0 = 2.0 * rand(4) - 1.0
q0 = q0 / norm(q0)
return q0, w0
def test_symmetry(self):
# Test that a basic V-cycle yields a symmetric linear operator. Common
# reasons for failure are problems with using the same rho for the
# pres/post-smoothers and using the same block_D_inv for
# pre/post-smoothers.
n = 500
A = poisson((n,), format='csr')
smoothers = [('gauss_seidel', {'sweep': 'symmetric'}),
('schwarz', {'sweep': 'symmetric'}),
('block_gauss_seidel', {'sweep': 'symmetric'}),
'jacobi', 'block_jacobi']
Bs = [ones((n, 1)),
hstack((ones((n, 1)),
arange(1, n + 1, dtype='float').reshape(-1, 1)))]
for smoother in smoothers:
for B in Bs:
ml = rootnode_solver(A, B, max_coarse=10,
presmoother=smoother,
postsmoother=smoother)
P = ml.aspreconditioner()
x = rand(n,)
y = rand(n,)
assert_approx_equal(dot(P * x, y), dot(x, P * y))
def test_basic(self):
"""check that method converges at a reasonable rate"""
for A, B, c_factor, symmetry, smooth in self.cases:
A = csr_matrix(A)
ml = rootnode_solver(A, B, symmetry=symmetry, smooth=smooth,
max_coarse=10)
numpy.random.seed(0) # make tests repeatable
x = rand(A.shape[0]) + 1.0j * rand(A.shape[0])
b = A * rand(A.shape[0])
residuals = []
x_sol = ml.solve(b, x0=x, maxiter=20, tol=1e-10,
residuals=residuals)
avg_convergence_ratio =\
(residuals[-1] / residuals[0]) ** (1.0 / len(residuals))
# print "Complex Test: %1.3e, %1.3e, %d, %1.3e" % \
# (avg_convergence_ratio, c_factor, len(ml.levels),
# ml.operator_complexity())
assert(avg_convergence_ratio < c_factor)
def run(self):
for i in scipy.arange(self.ns):
# Atualiza velocidade
self.v[i] = self.w*self.v[i]
self.v[i] = self.v[i] + self.c1*scipy.rand()*( self.bfp[i] - self.pop[i])
self.v[i] = self.v[i] + self.c2*scipy.rand()*(self.bfg - self.pop[i])
for j in range(Dim):
if self.v[i][j] >= 52.6:
self.v[i][j] = 52.6
elif self.v[i][j] <= -52.6:
self.v[i][j] = -52.6
# Atualiza posicao
self.pop[i] = self.pop[i] + self.v[i]
self.fit[i],self.pop[i] = self.avalia_aptidao(self.pop[i])
# Atualiza melhor posicao da particula
if self.fit[i] < self.bfp_fitness[i]:
self.bfp[i] = self.pop[i]
self.bfp_fitness[i] = self.fit[i]
if self.debug:
print "self.fit[{0}] = {1} bfp_fitness = {2}".format(i,self.fit[i],self.bfp_fitness[i])
# Atualiza melhor posicao global
if self.bfp_fitness[i] < self.bfg_fitness:
self.bfg_fitness = self.bfp_fitness[i].copy()
self.bfg = self.bfp[i].copy()
def test_DAD(self):
A = poisson((50, 50), format='csr')
x = rand(A.shape[0])
b = rand(A.shape[0])
D = diag_sparse(1.0 / sqrt(10 ** (12 * rand(A.shape[0]) - 6))).tocsr()
D_inv = diag_sparse(1.0 / D.data)
DAD = D * A * D
B = ones((A.shape[0], 1))
# TODO force 2 level method and check that result is the same
kwargs = {'max_coarse': 1, 'max_levels': 2, 'coarse_solver': 'splu'}
sa = rootnode_solver(D * A * D, D_inv * B, **kwargs)
residuals = []
x_sol = sa.solve(b, x0=x, maxiter=10, tol=1e-12, residuals=residuals)
avg_convergence_ratio =\
(residuals[-1] / residuals[0]) ** (1.0 / len(residuals))
# print "Diagonal Scaling Test: %1.3e, %1.3e" %
# (avg_convergence_ratio, 0.4)
assert(avg_convergence_ratio < 0.4)
def test_Transformation1():
"Transform 2-level to eigenbasis and back"
H1 = scipy.rand() * sigmax() + scipy.rand() * sigmay() + scipy.rand() * sigmaz()
evals, ekets = H1.eigenstates()
Heb = H1.transform(ekets) # eigenbasis (should be diagonal)
H2 = Heb.transform(ekets, True) # back to original basis
assert_equal((H1 - H2).norm() < 1e-6,True)
def Evolve_PSO(self):
for i in scipy.arange(self.npop2):
# Atualiza velocidade
self.v[i] = self.w*self.v[i]
self.v[i] = self.v[i] + self.c1*scipy.rand()*( self.bfp[i] - self.pop2[i])
self.v[i] = self.v[i] + self.c2*scipy.rand()*(self.bfg - self.pop2[i])
for j in range(self.v.shape[1]):
if self.v[i][j] >= self.arg_lim[j][1]/2:
self.v[i][j] = self.arg_lim[j][1]/2
elif self.v[i][j] <= -self.arg_lim[j][1]/2:
self.v[i][j] = -self.arg_lim[j][1]/2
# Atualiza posicao
self.pop2[i] = self.pop2[i] + self.v[i]
self.ans2[i],self.pop2[i] = self.resolve_desafio(self.pop2[i])
self.fit2[i] = self.avalia_aptidao2(self.ans2[i])
self.bfp_fitness[i] = self.avalia_aptidao2(self.bfp_ans[i])
self.bfg_fitness = self.avalia_aptidao2(self.bfg_ans)
# Atualiza melhor posicao da particula
if (self.fit2[i] > self.bfp_fitness[i]):
self.bfp[i] = self.pop2[i]
self.bfp_fitness[i] = self.fit2[i]
self.bfp_ans[i] = self.ans2[i]
# Atualiza melhor posicao global
if (self.bfp_fitness[i] > self.bfg_fitness):
self.bfg_fitness = self.bfp_fitness[i].copy()
self.bfg = self.bfp[i].copy()
self.bfg_ans = self.bfp_ans[i].copy()
def testRWSeparatorDetection(self):
"Read and write with automatic separator detection"
# create some random data
N = 10
data = (1-2*scipy.rand(N,N)) + 1j*(1-2*scipy.rand(N,N))
# comma separated values
file_data_store("test.dat", data, "complex", "exp", ",")
data2 = file_data_read("test.dat")
assert_(amax(abs((data-data2))) < 1e-8)
# semicolon separated values
file_data_store("test.dat", data, "complex", "exp", ";")
data2 = file_data_read("test.dat")
assert_(amax(abs((data-data2))) < 1e-8)
# tab separated values
file_data_store("test.dat", data, "complex", "exp", "\t")
data2 = file_data_read("test.dat")
assert_(amax(abs((data-data2))) < 1e-8)
# space separated values
file_data_store("test.dat", data, "complex", "exp", " ")
data2 = file_data_read("test.dat")
assert_(amax(abs((data-data2))) < 1e-8)
# mixed-whitespace separated values
file_data_store("test.dat", data, "complex", "exp", " \t ")
data2 = file_data_read("test.dat")
assert_(amax(abs((data-data2))) < 1e-8)
os.remove("test.dat")
def initialize(self, state, chain):
params = {}
for key in self.scan_range.keys():
# Check for single range
if len(self.scan_range[key]) == 2:
params[key] = sp.rand() * (self.scan_range[key][1] - self.scan_range[key][0]) + self.scan_range[key][0]
else:
# calculate weights of sub_regions
sub_size = sp.array([])
# Determine weights of region
for i in range(0, len(self.scan_range[key]), 2):
sub_size = sp.append(sub_size, self.scan_range[key][i + 1] - self.scan_range[key][i])
self.range_weight[key] = sub_size / float(sp.sum(sub_size))
# sample region based on size
i_sel = 2 * sp.searchsorted(sp.cumsum(self.range_weight[key]), sp.rand())
# sample point
params[key] = (
sp.rand() * (self.scan_range[key][i_sel + 1] - self.scan_range[key][i_sel])
+ self.scan_range[key][i_sel]
)
# params=dict([(key,sp.rand()*(self.scan_range[key][1]-self.scan_range[key][0])+self.scan_range[key][0]) for key in self.scan_range.keys() if type(self.scan_range[key])==list])
# Add constant parameters
for key in self.constants.keys():
params[key] = self.constants[key]
for key in self.functions.keys():
params[key] = self.functions[key](params)
modelid = "%i%01i" % (self.rank, 0) + "%i" % chain.accepted
return params, modelid
def __init__(self, parent=None, width = 10, height = 12, dpi = 100, sharex = None, sharey = None):
self.fig = Figure(figsize = (width, height), dpi=dpi, facecolor = '#FFFFFF')
self.ax = Axes3D(self.fig)
# n = 100
# for c, zl, zh in [('r', -50, -25), ('b', -30, -5)]:
# xs = randrange(n, 23, 32)
# ys = randrange(n, 0, 100)
# zs = randrange(n, zl, zh)
self.ax.scatter3D(S.rand(200), S.rand(200), S.rand(200))#, c = c, alpha = 0.8)
self.ax.set_xlabel('X Label')
self.ax.set_ylabel('Y Label')
self.ax.set_zlabel('Z Label')
# self.ax = self.fig.add_subplot(111, sharex = sharex, sharey = sharey)
# self.fig.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9)
self.xtitle="x-Axis"
self.ytitle="y-Axis"
self.PlotTitle = "Plot"
self.grid_status = True
self.xaxis_style = 'linear'
self.yaxis_style = 'linear'
self.format_labels()
self.ax.hold(True)
FigureCanvas.__init__(self, self.fig)
#self.fc = FigureCanvas(self.fig)
FigureCanvas.setSizePolicy(self,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def test_improve_candidates(self):
# test improve_candidates for the Poisson problem and elasticity, where
# rho_scale is the amount that each successive improve_candidates
# option should improve convergence over the previous
# improve_candidates option.
improve_candidates_list = [None, [("block_gauss_seidel", {"iterations": 4, "sweep": "symmetric"})]]
# make tests repeatable
numpy.random.seed(0)
cases = []
A_elas, B_elas = linear_elasticity((60, 60), format="bsr")
# Matrix Candidates rho_scale
cases.append((poisson((75, 75), format="csr"), ones((75 * 75, 1)), 0.9))
cases.append((A_elas, B_elas, 0.9))
for (A, B, rho_scale) in cases:
last_rho = -1.0
x0 = rand(A.shape[0], 1)
b = rand(A.shape[0], 1)
for improve_candidates in improve_candidates_list:
ml = rootnode_solver(A, B, max_coarse=10, improve_candidates=improve_candidates)
residuals = []
x_sol = ml.solve(b, x0=x0, maxiter=20, tol=1e-10, residuals=residuals)
del x_sol
rho = (residuals[-1] / residuals[0]) ** (1.0 / len(residuals))
if last_rho == -1.0:
last_rho = rho
else:
# each successive improve_candidates option should be an
# improvement on the previous print "\nimprove_candidates
# Test: %1.3e, %1.3e,
# %d\n"%(rho,rho_scale*last_rho,A.shape[0])
assert rho < rho_scale * last_rho
last_rho = rho
def test_dimensions(self):
# 1D
img = scipy.rand(10)
template = scipy.random.randint(0, 2, (3))
result = ght(img, template)
self.assertEqual(result.ndim, 1, "Computing ght with one-dimensional input data failed.")
# 2D
img = scipy.rand(10, 11)
template = scipy.random.randint(0, 2, (3, 4))
result = ght(img, template)
self.assertEqual(result.ndim, 2, "Computing ght with two-dimensional input data failed.")
# 3D
img = scipy.rand(10, 11, 12)
template = scipy.random.randint(0, 2, (3, 4, 5))
result = ght(img, template)
self.assertEqual(result.ndim, 3, "Computing ght with three-dimensional input data failed.")
# 4D
img = scipy.rand(10, 11, 12, 13)
template = scipy.random.randint(0, 2, (3, 4, 5, 6))
result = ght(img, template)
self.assertEqual(result.ndim, 4, "Computing ght with four-dimensional input data failed.")
# 5D
img = scipy.rand(3, 4, 3, 4, 3)
template = scipy.random.randint(0, 2, (2, 2, 2, 2, 2))
result = ght(img, template)
self.assertEqual(result.ndim, 5, "Computing ght with five-dimensional input data failed.")
def preprocess(S, coloring_method=None):
"""Preprocess splitting functions.
Parameters
----------
S : csr_matrix
Strength of connection matrix
method : string
Algorithm used to compute the vertex coloring:
* 'MIS' - Maximal Independent Set
* 'JP' - Jones-Plassmann (parallel)
* 'LDF' - Largest-Degree-First (parallel)
Returns
-------
weights: ndarray
Weights from a graph coloring of G
S : csr_matrix
Strength matrix with ones
T : csr_matrix
transpose of S
G : csr_matrix
union of S and T
Notes
-----
Performs the following operations:
- Checks input strength of connection matrix S
- Replaces S.data with ones
- Creates T = S.T in CSR format
- Creates G = S union T in CSR format
- Creates random weights
- Augments weights with graph coloring (if use_color == True)
"""
if not isspmatrix_csr(S):
raise TypeError('expected csr_matrix')
if S.shape[0] != S.shape[1]:
raise ValueError('expected square matrix, shape=%s' % (S.shape,))
N = S.shape[0]
S = csr_matrix((np.ones(S.nnz, dtype='int8'), S.indices, S.indptr),
shape=(N, N))
T = S.T.tocsr() # transpose S for efficient column access
G = S + T # form graph (must be symmetric)
G.data[:] = 1
weights = np.ravel(T.sum(axis=1)) # initial weights
# weights -= T.diagonal() # discount self loops
if coloring_method is None:
weights = weights + sp.rand(len(weights))
else:
coloring = vertex_coloring(G, coloring_method)
num_colors = coloring.max() + 1
weights = weights + (sp.rand(len(weights)) + coloring)/num_colors
return (weights, G, S, T)
def runSequences(self, num_actions=1, num_features=1, num_states=1,
num_interactions=10000, gamma=None, _lambda=None, lr=None, r_states=None):
if r_states is None:
r_states = [rand(num_features) for _ in range(num_states)]
else:
num_features = len(r_states[0])
num_states = len(r_states)
state_seq = [choice(r_states) for _ in range(num_interactions)]
action_seq = [randint(0, num_actions - 1) for _ in range(num_interactions)]
rewards = [ones(num_interactions), rand(num_interactions), action_seq, [s[0] for s in state_seq]]
datas = [list(zip(state_seq, action_seq, r)) for r in rewards]
res = []
for algo in self.algos:
res.append((algo.__name__, []))
for d in datas:
l = algo(num_actions, num_features)
if gamma is not None:
l.rewardDiscount = gamma
if _lambda is not None:
l._lambda = _lambda
if lr is not None:
l.learningRate = lr
self.trainWith(l, d)
res[-1][-1].append([dot(l._theta, s) for s in r_states])
return res
def getRegion(self,size=3e4,min_nSNPs=1,chrom_i=None,pos_min=None,pos_max=None):
"""
Sample a region from the piece of genotype X, chrom, pos
minSNPnum: minimum number of SNPs contained in the region
Ichrom: restrict X to chromosome Ichrom before taking the region
cis: bool vector that marks the sorted region
region: vector that contains chrom and init and final position of the region
"""
if (self.chrom is None) or (self.pos is None):
bim = plink_reader.readBIM(self.bfile,usecols=(0,1,2,3))
chrom = SP.array(bim[:,0],dtype=int)
pos = SP.array(bim[:,3],dtype=int)
else:
chrom = self.chrom
pos = self.pos
if chrom_i is None:
n_chroms = chrom.max()
chrom_i = int(SP.ceil(SP.rand()*n_chroms))
pos = pos[chrom==chrom_i]
chrom = chrom[chrom==chrom_i]
ipos = SP.ones(len(pos),dtype=bool)
if pos_min is not None:
ipos = SP.logical_and(ipos,pos_min<pos)
if pos_max is not None:
ipos = SP.logical_and(ipos,pos<pos_max)
pos = pos[ipos]
chrom = chrom[ipos]
if size==1:
# select single SNP
idx = int(SP.ceil(pos.shape[0]*SP.rand()))
cis = SP.arange(pos.shape[0])==idx
region = SP.array([chrom_i,pos[idx],pos[idx]])
else:
while 1:
idx = int(SP.floor(pos.shape[0]*SP.rand()))
posT1 = pos[idx]
posT2 = pos[idx]+size
if posT2<=pos.max():
cis = chrom==chrom_i
cis*= (pos>posT1)*(pos<posT2)
if cis.sum()>min_nSNPs: break
region = SP.array([chrom_i,posT1,posT2])
start = SP.nonzero(cis)[0].min()
nSNPs = cis.sum()
if self.X is None:
rv = plink_reader.readBED(self.bfile,useMAFencoding=True,start = start, nSNPs = nSNPs,bim=bim)
Xr = rv['snps']
else:
Xr = self.X[:,start:start+nSnps]
return Xr, region
def test_interleave_data_with_unyts_on_only_one(self):
import unyt
pn = op.network.Cubic(shape=[10, 1, 1])
geo1 = op.geometry.GenericGeometry(network=pn, pores=[0, 1, 2, 3, 4])
geo2 = op.geometry.GenericGeometry(network=pn, pores=[5, 6, 7, 8, 9])
geo1['pore.test'] = sp.rand(geo1.Np, )
geo2['pore.test'] = sp.rand(geo2.Np, ) * unyt.m
assert hasattr(pn['pore.test'], 'units')
def arg_max_reduced_likelihood_function(self):
"""
This function estimates the autocorrelation parameters theta as the
maximizer of the reduced likelihood function.
(Minimization of the opposite reduced likelihood function is used for
convenience)
Parameters
----------
self : All parameters are stored in the Gaussian Process model object.
Returns
-------
optimal_theta : array_like
The best set of autocorrelation parameters (the sought maximizer of
the reduced likelihood function).
optimal_reduced_likelihood_function_value : double
The optimal reduced likelihood function value.
optimal_par : dict
The BLUP parameters associated to thetaOpt.
"""
# Initialize output
best_optimal_theta = []
best_optimal_rlf_value = []
best_optimal_par = []
if self.verbose:
print "The chosen optimizer is: " + str(self.optimizer)
if self.random_start > 1:
print str(self.random_start) + " random starts are required."
percent_completed = 0.
# Force optimizer to fmin_cobyla if the model is meant to be isotropic
if self.optimizer == 'Welch' and self.theta0.size == 1:
self.optimizer = 'fmin_cobyla'
if self.optimizer == 'fmin_cobyla':
def minus_reduced_likelihood_function(log10t):
return -self.reduced_likelihood_function(theta=10.**log10t)[0]
constraints = []
for i in range(self.theta0.size):
constraints.append(lambda log10t: \
log10t[i] - np.log10(self.thetaL[0, i]))
constraints.append(lambda log10t: \
np.log10(self.thetaU[0, i]) - log10t[i])
for k in range(self.random_start):
if k == 0:
# Use specified starting point as first guess
theta0 = self.theta0
else:
# Generate a random starting point log10-uniformly
# distributed between bounds
log10theta0 = np.log10(self.thetaL) \
+ rand(self.theta0.size).reshape(self.theta0.shape) \
* np.log10(self.thetaU / self.thetaL)
theta0 = 10.**log10theta0
# Run Cobyla
log10_optimal_theta = \
optimize.fmin_cobyla(minus_reduced_likelihood_function,
np.log10(theta0), constraints, iprint=0)
optimal_theta = 10.**log10_optimal_theta
optimal_minus_rlf_value, optimal_par = \
self.reduced_likelihood_function(theta=optimal_theta)
optimal_rlf_value = -optimal_minus_rlf_value
# Compare the new optimizer to the best previous one
if k > 0:
if optimal_rlf_value > best_optimal_rlf_value:
best_optimal_rlf_value = optimal_rlf_value
best_optimal_par = optimal_par
best_optimal_theta = optimal_theta
else:
best_optimal_rlf_value = optimal_rlf_value
best_optimal_par = optimal_par
best_optimal_theta = optimal_theta
if self.verbose and self.random_start > 1:
if (20 * k) / self.random_start > percent_completed:
percent_completed = (20 * k) / self.random_start
print "%s completed" % (5 * percent_completed)
optimal_rlf_value = best_optimal_rlf_value
optimal_par = best_optimal_par
optimal_theta = best_optimal_theta
elif self.optimizer == 'Welch':
# Backup of the given atrributes
theta0, thetaL, thetaU = self.theta0, self.thetaL, self.thetaU
corr = self.corr
verbose = self.verbose
# This will iterate over fmin_cobyla optimizer
self.optimizer = 'fmin_cobyla'
self.verbose = False
# Initialize under isotropy assumption
if verbose:
print("Initialize under isotropy assumption...")
self.theta0 = array2d(self.theta0.min())
self.thetaL = array2d(self.thetaL.min())
self.thetaU = array2d(self.thetaU.max())
theta_iso, optimal_rlf_value_iso, par_iso = \
self.arg_max_reduced_likelihood_function()
optimal_theta = theta_iso + np.zeros(theta0.shape)
# Iterate over all dimensions of theta allowing for anisotropy
if verbose:
print("Now improving allowing for anisotropy...")
for i in np.random.permutation(range(theta0.size)):
if verbose:
print "Proceeding along dimension %d..." % (i + 1)
self.theta0 = array2d(theta_iso)
self.thetaL = array2d(thetaL[0, i])
self.thetaU = array2d(thetaU[0, i])
def corr_cut(t, d):
return corr(
array2d(
np.hstack([
optimal_theta[0][0:i], t[0],
optimal_theta[0][(i + 1)::]
])), d)
self.corr = corr_cut
optimal_theta[0, i], optimal_rlf_value, optimal_par = \
self.arg_max_reduced_likelihood_function()
# Restore the given atrributes
self.theta0, self.thetaL, self.thetaU = theta0, thetaL, thetaU
self.corr = corr
self.optimizer = 'Welch'
self.verbose = verbose
else:
raise NotImplementedError(
("This optimizer ('%s') is not " +
"implemented yet. Please contribute!") % self.optimizer)
return optimal_theta, optimal_rlf_value, optimal_par
def approximate_spectral_radius(A,
tol=0.01,
maxiter=15,
restart=5,
symmetric=None,
initial_guess=None,
return_vector=False):
"""
Approximate the spectral radius of a matrix
Parameters
----------
A : {dense or sparse matrix}
E.g. csr_matrix, csc_matrix, ndarray, etc.
tol : {scalar}
Relative tolerance of approximation, i.e., the error divided
by the approximate spectral radius is compared to tol.
maxiter : {integer}
Maximum number of iterations to perform
restart : {integer}
Number of restarted Arnoldi processes. For example, a value of 0 will
run Arnoldi once, for maxiter iterations, and a value of 1 will restart
Arnoldi once, using the maximal eigenvector from the first Arnoldi
process as the initial guess.
symmetric : {boolean}
True - if A is symmetric
Lanczos iteration is used (more efficient)
False - if A is non-symmetric (default
Arnoldi iteration is used (less efficient)
initial_guess : {array|None}
If n x 1 array, then use as initial guess for Arnoldi/Lanczos.
If None, then use a random initial guess.
return_vector : {boolean}
True - return an approximate dominant eigenvector, in addition to the
spectral radius.
False - Do not return the approximate dominant eigenvector
Returns
-------
An approximation to the spectral radius of A, and
if return_vector=True, then also return the approximate dominant
eigenvector
Notes
-----
The spectral radius is approximated by looking at the Ritz eigenvalues.
Arnoldi iteration (or Lanczos) is used to project the matrix A onto a
Krylov subspace: H = Q* A Q. The eigenvalues of H (i.e. the Ritz
eigenvalues) should represent the eigenvalues of A in the sense that the
minimum and maximum values are usually well matched (for the symmetric case
it is true since the eigenvalues are real).
References
----------
.. [1] Z. Bai, J. Demmel, J. Dongarra, A. Ruhe, and H. van der Vorst,
editors. "Templates for the Solution of Algebraic Eigenvalue Problems:
A Practical Guide", SIAM, Philadelphia, 2000.
Examples
--------
>>> from pyamg.util.linalg import approximate_spectral_radius
>>> import numpy as np
>>> from scipy.linalg import eigvals, norm
>>> A = np.array([[1.,0.],[0.,1.]])
>>> print approximate_spectral_radius(A,maxiter=3)
1.0
>>> print max([norm(x) for x in eigvals(A)])
1.0
"""
if not hasattr(A, 'rho') or return_vector:
# somehow more restart causes a nonsymmetric case to fail...look at
# this what about A.dtype=int? convert somehow?
# The use of the restart vector v0 requires that the full Krylov
# subspace V be stored. So, set symmetric to False.
symmetric = False
if maxiter < 1:
raise ValueError('expected maxiter > 0')
if restart < 0:
raise ValueError('expected restart >= 0')
if A.dtype == int:
raise ValueError('expected A to be float (complex or real)')
if A.shape[0] != A.shape[1]:
raise ValueError('expected square A')
if initial_guess is None:
v0 = sp.rand(A.shape[1], 1)
if A.dtype == complex:
v0 = v0 + 1.0j * sp.rand(A.shape[1], 1)
else:
if initial_guess.shape[0] != A.shape[0]:
raise ValueError('initial_guess and A must have same shape')
if (len(initial_guess.shape) > 1) and (initial_guess.shape[1] > 1):
raise ValueError('initial_guess must be an (n,1) or\
(n,) vector')
v0 = initial_guess.reshape(-1, 1)
v0 = np.array(v0, dtype=A.dtype)
for j in range(restart + 1):
[evect, ev, H, V, breakdown_flag] =\
_approximate_eigenvalues(A, tol, maxiter,
symmetric, initial_guess=v0)
# Calculate error in dominant eigenvector
nvecs = ev.shape[0]
max_index = np.abs(ev).argmax()
error = H[nvecs, nvecs - 1] * evect[-1, max_index]
# error is a fast way of calculating the following line
# error2 = ( A - ev[max_index]*sp.mat(
# sp.eye(A.shape[0],A.shape[1])) )*\
# ( sp.mat(sp.hstack(V[:-1]))*\
# evect[:,max_index].reshape(-1,1) )
# print str(error) + " " + str(sp.linalg.norm(e2))
if (np.abs(error)/np.abs(ev[max_index]) < tol) or\
breakdown_flag:
# halt if below relative tolerance
v0 = np.dot(np.hstack(V[:-1]), evect[:,
max_index].reshape(-1, 1))
break
else:
v0 = np.dot(np.hstack(V[:-1]), evect[:,
max_index].reshape(-1, 1))
# end j-loop
rho = np.abs(ev[max_index])
if sparse.isspmatrix(A):
A.rho = rho
if return_vector:
return (rho, v0)
else:
return rho
else:
return A.rho
def ishermitian(A, fast_check=True, tol=1e-6, verbose=False):
"""Returns True if A is Hermitian to within tol
Parameters
----------
A : {dense or sparse matrix}
e.g. array, matrix, csr_matrix, ...
fast_check : {bool}
If True, use the heuristic < Ax, y> = < x, Ay>
for random vectors x and y to check for conjugate symmetry.
If False, compute A - A.H.
tol : {float}
Symmetry tolerance
verbose: {bool}
prints
max( \|A - A.H\| ) if nonhermitian and fast_check=False
abs( <Ax, y> - <x, Ay> ) if nonhermitian and fast_check=False
Returns
-------
True if hermitian
False if nonhermitian
Notes
-----
This function applies a simple test of conjugate symmetry
Examples
--------
>>> import numpy as np
>>> from pyamg.util.linalg import ishermitian
>>> ishermitian(np.array([[1,2],[1,1]]))
False
>>> from pyamg.gallery import poisson
>>> ishermitian(poisson((10,10)))
True
"""
# convert to matrix type
if not sparse.isspmatrix(A):
A = np.asmatrix(A)
if fast_check:
x = sp.rand(A.shape[0], 1)
y = sp.rand(A.shape[0], 1)
if A.dtype == complex:
x = x + 1.0j * sp.rand(A.shape[0], 1)
y = y + 1.0j * sp.rand(A.shape[0], 1)
xAy = np.dot((A * x).conjugate().T, y)
xAty = np.dot(x.conjugate().T, A * y)
diff = float(np.abs(xAy - xAty) / np.sqrt(np.abs(xAy * xAty)))
else:
# compute the difference, A - A.H
if sparse.isspmatrix(A):
diff = np.ravel((A - A.H).data)
else:
diff = np.ravel(A - A.H)
if np.max(diff.shape) == 0:
diff = 0
else:
diff = np.max(np.abs(diff))
if diff < tol:
diff = 0
return True
else:
if verbose:
print(diff)
return False
return diff
import scipy as sp
import nose.tools as nt
import numpy.testing as npt
# my imports
from special import wignerd, gensph
# Global variables
# ================================================================================
lmax = 20
mns = [(0, 0), (2, 2), (2, -2), (0, 2)]
mns += [(0, 1), (3, 0), (3, 5), (7, 1)]
theta = sp.pi * sp.rand(2, 3)
ae = lambda x, y: npt.assert_array_almost_equal(x, y, decimal=14)
d00 = sp.array([
sp.ones(theta.shape),
sp.cos(theta), .5 * (3 * sp.cos(theta)**2 - 1.0),
-.5 * sp.cos(theta) * (3.0 - 5.0 * sp.cos(theta)**2),
1.0 / 8.0 * (3.0 - 30 * sp.cos(theta)**2 + 35 * sp.cos(theta)**4)
])
d22 = sp.array([
sp.zeros(theta.shape),
sp.zeros(theta.shape), .25 * (1.0 + sp.cos(theta))**2,
-.25 * (1.0 + sp.cos(theta))**2 * (2 - 3 * sp.cos(theta)), .25 *
(1.0 + sp.cos(theta))**2 * (1 - 7 * sp.cos(theta) + 7 * sp.cos(theta)**2)
])
d2m2 = sp.array([
def _approximate_eigenvalues(A,
tol,
maxiter,
symmetric=None,
initial_guess=None):
"""Used by approximate_spectral_radius and condest
Returns [W, E, H, V, breakdown_flag], where W and E are the eigenvectors
and eigenvalues of the Hessenberg matrix H, respectively, and V is the
Krylov space. breakdown_flag denotes whether Lanczos/Arnoldi suffered
breakdown. E is therefore the approximate eigenvalues of A.
To obtain approximate eigenvectors of A, compute V*W.
"""
from scipy.sparse.linalg import aslinearoperator
A = aslinearoperator(A) # A could be dense or sparse, or something weird
# Choose tolerance for deciding if break-down has occurred
t = A.dtype.char
eps = np.finfo(np.float).eps
feps = np.finfo(np.single).eps
geps = np.finfo(np.longfloat).eps
_array_precision = {'f': 0, 'd': 1, 'g': 2, 'F': 0, 'D': 1, 'G': 2}
breakdown = {
0: feps * 1e3,
1: eps * 1e6,
2: geps * 1e6
}[_array_precision[t]]
breakdown_flag = False
if A.shape[0] != A.shape[1]:
raise ValueError('expected square matrix')
maxiter = min(A.shape[0], maxiter)
if initial_guess is None:
v0 = sp.rand(A.shape[1], 1)
if A.dtype == complex:
v0 = v0 + 1.0j * sp.rand(A.shape[1], 1)
else:
v0 = initial_guess
v0 /= norm(v0)
# Important to type H based on v0, so that a real nonsymmetric matrix, can
# have an imaginary initial guess for its Arnoldi Krylov space
H = np.zeros((maxiter + 1, maxiter),
dtype=np.find_common_type([v0.dtype, A.dtype], []))
V = [v0]
beta = 0.0
for j in range(maxiter):
w = A * V[-1]
if symmetric:
if j >= 1:
H[j - 1, j] = beta
w -= beta * V[-2]
alpha = np.dot(np.conjugate(w.ravel()), V[-1].ravel())
H[j, j] = alpha
w -= alpha * V[-1] # axpy(V[-1],w,-alpha)
beta = norm(w)
H[j + 1, j] = beta
if (H[j + 1, j] < breakdown):
breakdown_flag = True
break
w /= beta
V.append(w)
V = V[-2:] # retain only last two vectors
else:
# orthogonalize against Vs
for i, v in enumerate(V):
H[i, j] = np.dot(np.conjugate(v.ravel()), w.ravel())
w = w - H[i, j] * v
H[j + 1, j] = norm(w)
if (H[j + 1, j] < breakdown):
breakdown_flag = True
if H[j + 1, j] != 0.0:
w = w / H[j + 1, j]
V.append(w)
break
w = w / H[j + 1, j]
V.append(w)
# if upper 2x2 block of Hessenberg matrix H is almost symmetric,
# and the user has not explicitly specified symmetric=False,
# then switch to symmetric Lanczos algorithm
# if symmetric is not False and j == 1:
# if abs(H[1,0] - H[0,1]) < 1e-12:
# #print "using symmetric mode"
# symmetric = True
# V = V[1:]
# H[1,0] = H[0,1]
# beta = H[2,1]
# print "Approximated spectral radius in %d iterations" % (j + 1)
from scipy.linalg import eig
Eigs, Vects = eig(H[:j + 1, :j + 1], left=False, right=True)
return (Vects, Eigs, H, V, breakdown_flag)
0.99 * x_aper,
'y_sem_ellip_insc':
0.99 * y_aper
})
picFDSW = PIC_FDSW.FiniteDifferences_ShortleyWeller_SquareGrid(
chamb=chamber, Dh=Dh, sparse_solver='PyKLU')
picFD = PIC_FD.FiniteDifferences_Staircase_SquareGrid(chamb=chamber,
Dh=Dh,
sparse_solver='PyKLU')
picFFTPEC = PIC_PEC_FFT.FFT_PEC_Boundary_SquareGrid(x_aper=chamber.x_aper,
y_aper=chamber.y_aper,
Dh=Dh)
# generate particles
x_part = R_charge * (2. * rand(N_part_gen) - 1.)
y_part = R_charge * (2. * rand(N_part_gen) - 1.)
mask_keep = x_part**2 + y_part**2 < R_charge**2
x_part = x_part[mask_keep]
y_part = y_part[mask_keep]
nel_part = 0 * x_part + 1.
#pic scatter
picFDSW.scatter(x_part, y_part, nel_part)
picFD.scatter(x_part, y_part, nel_part)
picFFTPEC.scatter(x_part, y_part, nel_part)
#pic scatter
picFDSW.solve()
picFD.solve()
def plot(self, img_order=None, freq=None, figsize=None, no_axis=False, mic_marker_size=10, **kwargs):
''' Plots the room with its walls, microphones, sources and images '''
import matplotlib
from matplotlib.patches import Circle, Wedge, Polygon
from matplotlib.collections import PatchCollection
import matplotlib.pyplot as plt
if (self.dim == 2):
fig = plt.figure(figsize=figsize)
if no_axis is True:
ax = fig.add_axes([0, 0, 1, 1], aspect='equal', **kwargs)
ax.axis('off')
rect = fig.patch
rect.set_facecolor('gray')
rect.set_alpha(0.15)
else:
ax = fig.add_subplot(111, aspect='equal', **kwargs)
# draw room
polygons = [Polygon(self.corners.T, True)]
p = PatchCollection(polygons, cmap=matplotlib.cm.jet,
facecolor=np.array([1, 1, 1]), edgecolor=np.array([0, 0, 0]))
ax.add_collection(p)
# draw the microphones
if (self.mic_array is not None):
for mic in self.mic_array.R.T:
ax.scatter(mic[0], mic[1],
marker='x', linewidth=0.5, s=mic_marker_size, c='k')
# draw the beam pattern of the beamformer if requested (and available)
if freq is not None \
and isinstance(self.mic_array, bf.Beamformer) \
and (self.mic_array.weights is not None or self.mic_array.filters is not None):
freq = np.array(freq)
if freq.ndim is 0:
freq = np.array([freq])
# define a new set of colors for the beam patterns
newmap = plt.get_cmap('autumn')
desat = 0.7
try:
# this is for matplotlib >= 2.0.0
ax.set_prop_cycle(color=[newmap(k) for k in desat*np.linspace(0, 1, len(freq))])
except:
# keep this for backward compatibility
ax.set_color_cycle([newmap(k) for k in desat*np.linspace(0, 1, len(freq))])
phis = np.arange(360) * 2 * np.pi / 360.
newfreq = np.zeros(freq.shape)
H = np.zeros((len(freq), len(phis)), dtype=complex)
for i, f in enumerate(freq):
newfreq[i], H[i] = self.mic_array.response(phis, f)
# normalize max amplitude to one
H = np.abs(H)**2/np.abs(H).max()**2
# a normalization factor according to room size
norm = np.linalg.norm((self.corners - self.mic_array.center), axis=0).max()
# plot all the beam patterns
i = 0
for f, h in zip(newfreq, H):
x = np.cos(phis) * h * norm + self.mic_array.center[0, 0]
y = np.sin(phis) * h * norm + self.mic_array.center[1, 0]
l = ax.plot(x, y, '-', linewidth=0.5)
# define some markers for different sources and colormap for damping
markers = ['o', 's', 'v', '.']
cmap = plt.get_cmap('YlGnBu')
# draw the scatter of images
for i, source in enumerate(self.sources):
# draw source
ax.scatter(
source.position[0],
source.position[1],
c=cmap(1.),
s=20,
marker=markers[i %len(markers)],
edgecolor=cmap(1.))
# draw images
if (img_order is None):
img_order = self.max_order
I = source.orders <= img_order
val = (np.log2(source.damping[I]) + 10.) / 10.
# plot the images
ax.scatter(source.images[0, I],
source.images[1, I],
c=cmap(val),
s=20,
marker=markers[i % len(markers)],
edgecolor=cmap(val))
return fig, ax
if(self.dim==3):
import mpl_toolkits.mplot3d as a3
import matplotlib.colors as colors
import matplotlib.pyplot as plt
import scipy as sp
fig = plt.figure(figsize=figsize)
ax = a3.Axes3D(fig)
# plot the walls
for w in self.walls:
tri = a3.art3d.Poly3DCollection([w.corners.T], alpha=0.5)
tri.set_color(colors.rgb2hex(sp.rand(3)))
tri.set_edgecolor('k')
ax.add_collection3d(tri)
# define some markers for different sources and colormap for damping
markers = ['o', 's', 'v', '.']
cmap = plt.get_cmap('YlGnBu')
# draw the scatter of images
for i, source in enumerate(self.sources):
# draw source
ax.scatter(
source.position[0],
source.position[1],
source.position[2],
c=cmap(1.),
s=20,
marker=markers[i %len(markers)],
edgecolor=cmap(1.))
# draw images
if (img_order is None):
img_order = self.max_order
I = source.orders <= img_order
val = (np.log2(source.damping[I]) + 10.) / 10.
# plot the images
ax.scatter(source.images[0, I],
source.images[1, I],
source.images[2, I],
c=cmap(val),
s=20,
marker=markers[i % len(markers)],
edgecolor=cmap(val))
# draw the microphones
if (self.mic_array is not None):
for mic in self.mic_array.R.T:
ax.scatter(mic[0], mic[1], mic[2],
marker='x', linewidth=0.5, s=mic_marker_size, c='k')
return fig, ax
from pyamg import gallery, rootnode_solver
from pyamg.gallery import stencil_grid
from pyamg.gallery.diffusion import diffusion_stencil_2d
from cvoutput import *
from convergence_tools import print_cycle_history
##
# Run Rotated Anisotropic Diffusion
n = 10
nx = n
ny = n
stencil = diffusion_stencil_2d(type='FE',epsilon=0.001,theta=scipy.pi/3)
A = stencil_grid(stencil, (nx,ny), format='csr')
numpy.random.seed(625)
x = scipy.rand(A.shape[0])
b = A*scipy.rand(A.shape[0])
ml = rootnode_solver(A, strength=('evolution', {'epsilon':2.0}),
smooth=('energy', {'degree':2}), max_coarse=10)
resvec = []
x = ml.solve(b, x0=x, maxiter=20, tol=1e-14, residuals=resvec)
print_cycle_history(resvec, ml, verbose=True, plotting=False)
##
# Write ConnectionViewer files for multilevel hierarchy ml
xV,yV = numpy.meshgrid(numpy.arange(0,ny,dtype=float),numpy.arange(0,nx,dtype=float))
Verts = numpy.concatenate([[xV.ravel()],[yV.ravel()]],axis=0).T
outputML("test", Verts, ml)
c='r',
marker='o')
ax.scatter(np.asarray([x[maxx][0]]),
np.asarray([y[0][maxy]]),
np.asarray([maxz + 0.2]),
c='b',
marker='D')
# ax.text(x[maxx][0],y[0][maxy],maxz+0.2,"Goal",'y')
# for vtx in [ sp.rand(4,3)*2 + 2 for i in range(10) ] :
for vtx in np.asarray(cube()) * np.asarray([[1, 1, 2], [1, 1, 2],
[1, 1, 2], [1, 1, 2]]) + 2:
tri = a3.art3d.Poly3DCollection([vtx],
facecolors='w',
linewidths=1,
alpha=0.5)
tri.set_color(colors.rgb2hex(sp.rand(3)))
tri.set_edgecolor('k')
ax.add_collection3d(tri)
surf = ax.plot_surface(x,
y,
z,
rstride=1,
cstride=1,
linewidth=0,
antialiased=False,
facecolors=rgb)
plt.savefig(frameLocation + 'frame.png', bbox_inches='tight')
movie_file(frameLocation + 'frame.png')
plt.close(1)
frame_ix = 1000
frame = dlc.get_frame(Vid, frame_ix)
dlc.plot_frame(frame, axes=axes)
# plot all traj in selection
for i in tqdm(SDf.index):
TrialDf = TrialDfs[i]
Df = bhv.event_slice(TrialDf,'PRESENT_INTERVAL_STATE','ITI_STATE')
t_on = Df.iloc[0]['t']
t_off = Df.iloc[-1]['t']
# trial by trial colors
bp_cols = {}
cmaps = dict(zip(bodyparts,['viridis','magma']))
for bp in bodyparts:
c = sns.color_palette(cmaps[bp],as_cmap=True)(sp.rand())
bp_cols[bp] = c
# marker for the start
# frame_ix = dlc.time2frame(t_on, m, b, m2, b2)
frame_ix = Sync.convert(t_on, 'arduino', 'dlc').round().astype('int')
dlc.plot_bodyparts(bodyparts, DlcDf, frame_ix, colors=bp_cols, axes=axes, markersize=5)
# the trajectory
DlcDfSlice = bhv.time_slice(DlcDf, t_on, t_off)
dlc.plot_trajectories(DlcDfSlice, bodyparts, colors=bp_cols, axes=axes, lw=0.75, alpha=0.75, p=0.8)
# %%
"""
## ## #### ######## ######## #######
def discretisation(eigen_vec):
eps = 2.2204e-16
# normalize the eigenvectors
[n, k] = shape(eigen_vec)
vm = kron(ones((1, k)), sqrt(multiply(eigen_vec, eigen_vec).sum(1)))
eigen_vec = divide(eigen_vec, vm)
svd_restarts = 0
exitLoop = 0
### if there is an exception we try to randomize and rerun SVD again
### do this 30 times
while (svd_restarts < 30) and (exitLoop == 0):
# initialize algorithm with a random ordering of eigenvectors
c = zeros((n, 1))
R = matrix(zeros((k, k)))
R[:, 0] = eigen_vec[int(rand(1) * (n - 1)), :].transpose()
for j in range(1, k):
c = c + abs(eigen_vec * R[:, j - 1])
R[:, j] = eigen_vec[c.argmin(), :].transpose()
lastObjectiveValue = 0
nbIterationsDiscretisation = 0
nbIterationsDiscretisationMax = 20
# iteratively rotate the discretised eigenvectors until they
# are maximally similar to the input eignevectors, this
# converges when the differences between the current solution
# and the previous solution differs by less than eps or we
# we have reached the maximum number of itarations
while exitLoop == 0:
nbIterationsDiscretisation = nbIterationsDiscretisation + 1
# rotate the original eigen_vectors
tDiscrete = eigen_vec * R
# discretise the result by setting the max of each row=1 and
# other values to 0
j = reshape(asarray(tDiscrete.argmax(1)), n)
eigenvec_discrete=csc_matrix((ones(len(j)),(range(0,n), \
array(j))),shape=(n,k))
# calculate a rotation to bring the discrete eigenvectors cluster to
# the original eigenvectors
tSVD = eigenvec_discrete.transpose() * eigen_vec
# catch a SVD convergence error and restart
try:
U, S, Vh = svd(tSVD)
except LinAlgError:
# catch exception and go back to the beginning of the loop
print >> sys.stderr, \
"SVD did not converge, randomizing and trying again"
break
# test for convergence
NcutValue = 2 * (n - S.sum())
if((abs(NcutValue-lastObjectiveValue) < eps ) or \
( nbIterationsDiscretisation > \
nbIterationsDiscretisationMax )):
exitLoop = 1
else:
# otherwise calculate rotation and continue
lastObjectiveValue = NcutValue
R = matrix(Vh).transpose() * matrix(U).transpose()
if exitLoop == 0:
raise SVDError("SVD did not converge after 30 retries")
else:
return (eigenvec_discrete)
def test_nonhermitian(self):
# problem data
data = load_example('helmholtz_2D')
A = data['A'].tocsr()
B = data['B']
np.random.seed(625)
x0 = sp.rand(A.shape[0]) + 1.0j * sp.rand(A.shape[0])
b = A * sp.rand(A.shape[0]) + 1.0j * (A * sp.rand(A.shape[0]))
# solver parameters
smooth = ('energy', {'krylov': 'gmres'})
SA_build_args = {
'max_coarse': 25,
'coarse_solver': 'pinv2',
'symmetry': 'symmetric'
}
SA_solve_args = {'cycle': 'V', 'maxiter': 20, 'tol': 1e-8}
strength = [('evolution', {'k': 2, 'epsilon': 2.0})]
smoother = ('gauss_seidel_nr', {'sweep': 'symmetric', 'iterations': 1})
# Construct solver with nonsymmetric parameters
sa = rootnode_solver(A,
B=B,
smooth=smooth,
strength=strength,
presmoother=smoother,
postsmoother=smoother,
**SA_build_args)
residuals = []
# stand-alone solve
x = sa.solve(b, x0=x0, residuals=residuals, **SA_solve_args)
residuals = np.array(residuals)
avg_convergence_ratio =\
(residuals[-1] / residuals[0]) ** (1.0 / len(residuals))
# print "Test 3 %1.3e, %1.3e" % (avg_convergence_ratio, 0.92)
assert (avg_convergence_ratio < 0.92)
# accelerated solve
residuals = []
x = sa.solve(b,
x0=x0,
residuals=residuals,
accel='gmres',
**SA_solve_args)
del x
residuals = np.array(residuals)
avg_convergence_ratio =\
(residuals[-1] / residuals[0]) ** (1.0 / len(residuals))
# print "Test 4 %1.3e, %1.3e" % (avg_convergence_ratio, 0.8)
assert (avg_convergence_ratio < 0.8)
# test that nonsymmetric parameters give the same result as symmetric
# parameters for the complex-symmetric matrix A
strength = 'symmetric'
SA_build_args['symmetry'] = 'nonsymmetric'
sa_nonsymm = rootnode_solver(A,
B=np.ones((A.shape[0], 1)),
smooth=smooth,
strength=strength,
presmoother=smoother,
postsmoother=smoother,
improve_candidates=None,
**SA_build_args)
SA_build_args['symmetry'] = 'symmetric'
sa_symm = rootnode_solver(A,
B=np.ones((A.shape[0], 1)),
smooth=smooth,
strength=strength,
presmoother=smoother,
postsmoother=smoother,
improve_candidates=None,
**SA_build_args)
for (symm_lvl, nonsymm_lvl) in zip(sa_nonsymm.levels, sa_symm.levels):
assert_array_almost_equal(symm_lvl.A.todense(),
nonsymm_lvl.A.todense())
def rand_super():
h_5 = rand_herm(5)
return propagator(h_5, scipy.rand(), [
create(5), destroy(5), jmat(2, 'z')
])
def run_example(with_plots=True):
r"""
Example to demonstrate the use of the Sundials solver Kinsol with
a user provided Jacobian and a preconditioner. The example is the
'Problem 4' taken from the book by Saad:
Iterative Methods for Sparse Linear Systems.
"""
#Read the original matrix
A_original = IO.mmread(os.path.join(file_path, "kinsol_ors_matrix.mtx"))
#Scale the original matrix
A = SPARSE.spdiags(1.0 / A_original.diagonal(), 0,
len(A_original.diagonal()), len(
A_original.diagonal())) * A_original
#Preconditioning by Symmetric Gauss Seidel
if True:
D = SPARSE.spdiags(A.diagonal(), 0, len(A_original.diagonal()),
len(A_original.diagonal()))
Dinv = SPARSE.spdiags(1.0 / A.diagonal(), 0,
len(A_original.diagonal()),
len(A_original.diagonal()))
E = -SPARSE.tril(A, k=-1)
F = -SPARSE.triu(A, k=1)
L = (D - E).dot(Dinv)
U = D - F
Prec = L.dot(U)
solvePrec = LINSP.factorized(Prec)
#Create the RHS
b = A.dot(N.ones((A.shape[0], 1)))
#Define the res
def res(x):
return A.dot(x.reshape(len(x), 1)) - b
#The Jacobian
def jac(x):
return A.todense()
#The Jacobian*Vector
def jacv(x, v):
return A.dot(v.reshape(len(v), 1))
def prec_setup(u, f, uscale, fscale):
pass
def prec_solve(r):
return solvePrec(r)
y0 = S.rand(A.shape[0])
#Define an Assimulo problem
alg_mod = Algebraic_Problem(res,
y0=y0,
jac=jac,
jacv=jacv,
name='ORS Example')
alg_mod_prec = Algebraic_Problem(res,
y0=y0,
jac=jac,
jacv=jacv,
prec_solve=prec_solve,
prec_setup=prec_setup,
name='ORS Example (Preconditioned)')
#Define the KINSOL solver
alg_solver = KINSOL(alg_mod)
alg_solver_prec = KINSOL(alg_mod_prec)
#Sets the parameters
def setup_param(solver):
solver.linear_solver = "spgmr"
solver.max_dim_krylov_subspace = 10
solver.ftol = LIN.norm(res(solver.y0)) * 1e-9
solver.max_iter = 300
solver.verbosity = 10
solver.globalization_strategy = "none"
setup_param(alg_solver)
setup_param(alg_solver_prec)
#Solve orignal system
y = alg_solver.solve()
#Solve Preconditionined system
y_prec = alg_solver_prec.solve()
print("Error , in y: ", LIN.norm(y - N.ones(len(y))))
print("Error (preconditioned), in y: ",
LIN.norm(y_prec - N.ones(len(y_prec))))
if with_plots:
import pylab as P
P.figure(4)
P.semilogy(alg_solver.get_residual_norm_nonlinear_iterations(),
label="Original")
P.semilogy(alg_solver_prec.get_residual_norm_nonlinear_iterations(),
label='Preconditioned')
P.xlabel("Number of Iterations")
P.ylabel("Residual Norm")
P.title("Solution Progress")
P.legend()
P.grid()
P.figure(5)
P.plot(y, label="Original")
P.plot(y_prec, label="Preconditioned")
P.legend()
P.grid()
P.show()
#Basic test
for j in range(len(y)):
nose.tools.assert_almost_equal(y[j], 1.0, 4)
return [alg_mod, alg_mod_prec], [alg_solver, alg_solver_prec]
def random_spanning_tree(gg):
for u,v,d in gg.edges(data=1):
d['rand']=1.0*sp.rand()
return nx.minimum_spanning_tree(gg,weight='rand')
def plot_labels(lbl: scipy.ndarray, lbl_count: int) -> None:
"""Shows a plot of the given label image with a random color map."""
color_map = scipy.rand(lbl_count, 3)
color_map = matplotlib.colors.ListedColormap(color_map)
plt.imshow(lbl, cmap=color_map)
plt.show()
def generic(geometry, func, seeds='pore.seed', **kwargs):
if seeds not in geometry:
geometry['pore.seed'] = _sp.rand(geometry.Np, )
return _misc.generic(geometry=geometry, func=func, seeds=seeds)
def invert(self, rdn_meas, geom, out=None, init=None):
"""Inverts a meaurement. Returns an array of state vector samples.
Similar to Inversion.invert() but returns a list of samples."""
# We will truncate non-surface parameters to their bounds, but leave
# Surface reflectance unconstrained so it can dip slightly below zero
# in a channel without invalidating the whole vector
bounds = s.array([self.fm.bounds[0].copy(), self.fm.bounds[1].copy()])
bounds[:, self.fm.surface_inds] = s.array([[-s.inf], [s.inf]])
# Initialize to conjugate gradient solution
x_MAP = Inversion.invert(self, rdn_meas, geom, out, init)
# Proposal is based on the posterior uncertainty
S_hat, K, G = self.calc_posterior(x_MAP, geom, rdn_meas)
proposal_Cov = S_hat * self.proposal_scaling
proposal = multivariate_normal(cov=proposal_Cov)
# We will use this routine for initializing
def initialize():
x = multivariate_normal(mean=x_MAP, cov=S_hat).rvs()
too_low = x < bounds[0]
x[too_low] = bounds[0][too_low]+eps
too_high = x > bounds[1]
x[too_high] = bounds[1][too_high]-eps
dens = self.log_density(x, rdn_meas, geom, bounds)
return x, dens
# Sample from the posterior using Metropolis/Hastings MCMC
samples, acpts, rejs, x = [], 0, 0, None
for i in range(self.iterations):
if i % self.restart_every == 0:
x, dens = initialize()
xp = x + proposal.rvs()
dens_new = self.log_density(xp, rdn_meas, geom, bounds=bounds)
# Test vs. the Metropolis / Hastings criterion
if s.isfinite(dens_new) and\
s.log(s.rand()) <= min((dens_new - dens, 0.0)):
x = xp
dens = dens_new
acpts = acpts + 1
if self.verbose:
print('%8.5e %8.5e ACCEPT! rate %4.2f' %
(dens, dens_new, s.mean(acpts/(acpts+rejs))))
else:
rejs = rejs + 1
if self.verbose:
print('%8.5e %8.5e REJECT rate %4.2f' %
(dens, dens_new, s.mean(acpts/(acpts+rejs))))
# Make sure we have not wandered off the map
if not s.isfinite(dens_new):
x, dens = initialize()
if i % self.restart_every < self.burnin:
samples.append(x)
return x_MAP.copy(), s.array(samples)
a2009s.32k_fs.reduce3.very_smooth.left.dfs'))
# view_patch_vtk(dfs_left_sm)
rho_rho = []
rho_all = []
#lst=lst[:1]
labs_all = sp.zeros((len(dfs_left.labels), len(lst)))
sub = lst[0]
data = scipy.io.loadmat(
os.path.join(p_dir, sub, sub + '.rfMRI_REST1_LR.\
reduce3.ftdata.NLM_11N_hvar_25.mat'))
LR_flag = msk['LR_flag']
LR_flag = np.squeeze(LR_flag) != 0
data = data['ftdata_NLM']
temp = data[LR_flag, :]
temp[5000:6000, 500:700] += sp.rand(1000, 200) # temp[1000, :]
m = np.mean(temp, 1)
temp = temp - m[:, None]
s = np.std(temp, 1) + 1e-16
temp = temp / s[:, None]
d1 = temp
sub = lst[1]
data = scipy.io.loadmat(
os.path.join(p_dir, sub, sub + '.rfMRI_REST1_LR.\
reduce3.ftdata.NLM_11N_hvar_25.mat'))
LR_flag = msk['LR_flag']
LR_flag = np.squeeze(LR_flag) != 0
data = data['ftdata_NLM']
temp = data[LR_flag, :]
m = np.mean(temp, 1)
def normal(geometry, scale, loc, seeds='pore.seed', **kwargs):
if seeds not in geometry:
geometry['pore.seed'] = _sp.rand(geometry.Np, )
return _misc.normal(geometry=geometry, scale=scale, loc=loc, seeds=seeds)
from convergence_tools import print_cycle_history
if __name__ == '__main__':
print "\nDiffusion problem discretized with p=5 and the local\n" + \
"discontinuous Galerkin method."
# Discontinuous Galerkin Diffusion Problem
data = load_example('local_disc_galerkin_diffusion')
A = data['A'].tocsr()
B = data['B']
elements = data['elements']
vertices = data['vertices']
numpy.random.seed(625)
x0 = scipy.rand(A.shape[0])
b = numpy.zeros_like(x0)
##
# For demonstration, show that a naive SA solver
# yields unsatisfactory convergence
smooth = ('jacobi', {'filter': True})
strength = ('symmetric', {'theta': 0.1})
SA_solve_args = {'cycle': 'W', 'maxiter': 20, 'tol': 1e-8, 'accel': 'cg'}
SA_build_args={'max_levels':10, 'max_coarse':25, 'coarse_solver':'pinv2', \
'symmetry':'hermitian', 'keep':True}
presmoother = ('gauss_seidel', {'sweep': 'symmetric', 'iterations': 1})
postsmoother = ('gauss_seidel', {'sweep': 'symmetric', 'iterations': 1})
##
# Construct solver and solve
def preprocess(S, coloring_method=None):
"""Common preprocess for splitting functions
Parameters
----------
S : csr_matrix
Strength of connection matrix
method : {string}
Algorithm used to compute the vertex coloring:
* 'MIS' - Maximal Independent Set
* 'JP' - Jones-Plassmann (parallel)
* 'LDF' - Largest-Degree-First (parallel)
Returns
-------
weights: ndarray
Weights from a graph coloring of G
S : csr_matrix
Strength matrix with ones
T : csr_matrix
transpose of S
G : csr_matrix
union of S and T
Notes
-----
Performs the following operations:
- Checks input strength of connection matrix S
- Replaces S.data with ones
- Creates T = S.T in CSR format
- Creates G = S union T in CSR format
- Creates random weights
- Augments weights with graph coloring (if use_color == True)
"""
if not isspmatrix_csr(S):
raise TypeError('expected csr_matrix')
if S.shape[0] != S.shape[1]:
raise ValueError('expected square matrix, shape=%s' % (S.shape, ))
N = S.shape[0]
S = csr_matrix((np.ones(S.nnz, dtype='int8'), S.indices, S.indptr),
shape=(N, N))
T = S.T.tocsr() # transpose S for efficient column access
G = S + T # form graph (must be symmetric)
G.data[:] = 1
weights = np.ravel(T.sum(axis=1)) # initial weights
# weights -= T.diagonal() # discount self loops
if coloring_method is None:
weights = weights + sp.rand(len(weights))
else:
coloring = vertex_coloring(G, coloring_method)
num_colors = coloring.max() + 1
weights = weights + (sp.rand(len(weights)) + coloring) / num_colors
return (weights, G, S, T)
def test_Mooney(self):
A10, A01, kappa, rho = sp.rand(4) * 1E3 + 100
print('Material parameters A10, A01 and kappa:', A10, A01, kappa)
my_material = MooneyRivlin(A10, A01, kappa, rho)
self.my_element.material = my_material
self.jacobi_test_element(rtol=1E-3)
def test_Mooney(self):
A10, A01, kappa, rho = sp.rand(4) * 1E3 + 100
my_material = MooneyRivlin(A10, A01, kappa, rho)
self.my_element.material = my_material
self.jacobi_test_element(rtol=5E-4)
def solve(self, wls):
"""Isotropic solver.
INPUT
wls = wavelengths to scan (any asarray-able object).
OUTPUT
self.DE1, self.DE3 = power reflected and transmitted.
NOTE
see:
Moharam, "Formulation for stable and efficient implementation
of the rigorous coupled-wave analysis of binary gratings",
JOSA A, 12(5), 1995
Lalanne, "Highly improved convergence of the coupled-wave
method for TM polarization", JOSA A, 13(4), 1996
Moharam, "Stable implementation of the rigorous coupled-wave
analysis for surface-relief gratings: enhanced trasmittance
matrix approach", JOSA A, 12(5), 1995
"""
self.wls = S.atleast_1d(wls)
LAMBDA = self.LAMBDA
n = self.n
multilayer = self.multilayer
alpha = self.alpha
delta = self.delta
psi = self.psi
phi = self.phi
nlayers = len(multilayer)
i = S.arange(-n, n + 1)
nood = 2 * n + 1
hmax = nood - 1
# grating vector (on the xz plane)
# grating on the xy plane
K = 2 * pi / LAMBDA * \
S.array([S.sin(phi), 0., S.cos(phi)], dtype=complex)
DE1 = S.zeros((nood, self.wls.size))
DE3 = S.zeros_like(DE1)
dirk1 = S.array([S.sin(alpha) * S.cos(delta),
S.sin(alpha) * S.sin(delta),
S.cos(alpha)])
# usefull matrices
I = S.eye(i.size)
I2 = S.eye(i.size * 2)
ZERO = S.zeros_like(I)
X = S.zeros((2 * nood, 2 * nood, nlayers), dtype=complex)
MTp1 = S.zeros((2 * nood, 2 * nood, nlayers), dtype=complex)
MTp2 = S.zeros_like(MTp1)
EPS2 = S.zeros(2 * hmax + 1, dtype=complex)
EPS21 = S.zeros_like(EPS2)
dlt = (i == 0).astype(int)
for iwl, wl in enumerate(self.wls):
# free space wavevector
k = 2 * pi / wl
n1 = multilayer[0].mat.n(wl).item()
n3 = multilayer[-1].mat.n(wl).item()
# incident plane wave wavevector
k1 = k * n1 * dirk1
# all the other wavevectors
tmp_x = k1[0] - i * K[0]
tmp_y = k1[1] * S.ones_like(i)
tmp_z = dispersion_relation_ordinary(tmp_x, tmp_y, k, n1)
k1i = S.r_[[tmp_x], [tmp_y], [tmp_z]]
# k2i = S.r_[[k1[0] - i*K[0]], [k1[1] - i * K[1]], [-i * K[2]]]
tmp_z = dispersion_relation_ordinary(tmp_x, tmp_y, k, n3)
k3i = S.r_[[k1i[0, :]], [k1i[1, :]], [tmp_z]]
# aliases for constant wavevectors
kx = k1i[0, :]
ky = k1[1]
# angles of reflection
# phi_i = S.arctan2(ky,kx)
phi_i = S.arctan2(ky, kx.real) # OKKIO
Kx = S.diag(kx / k)
Ky = ky / k * I
Z1 = S.diag(k1i[2, :] / (k * n1 ** 2))
Y1 = S.diag(k1i[2, :] / k)
Z3 = S.diag(k3i[2, :] / (k * n3 ** 2))
Y3 = S.diag(k3i[2, :] / k)
# Fc = S.diag(S.cos(phi_i))
fc = S.cos(phi_i)
# Fs = S.diag(S.sin(phi_i))
fs = S.sin(phi_i)
MR = S.asarray(S.bmat([[I, ZERO],
[-1j * Y1, ZERO],
[ZERO, I],
[ZERO, -1j * Z1]]))
MT = S.asarray(S.bmat([[I, ZERO],
[1j * Y3, ZERO],
[ZERO, I],
[ZERO, 1j * Z3]]))
# internal layers (grating or layer)
X.fill(0.0)
MTp1.fill(0.0)
MTp2.fill(0.0)
for nlayer in range(nlayers - 2, 0, -1): # internal layers
layer = multilayer[nlayer]
d = layer.thickness
EPS2, EPS21 = layer.getEPSFourierCoeffs(
wl, n, anisotropic=False)
E = toeplitz(EPS2[hmax::-1], EPS2[hmax:])
E1 = toeplitz(EPS21[hmax::-1], EPS21[hmax:])
E11 = inv(E1)
# B = S.dot(Kx, linsolve(E,Kx)) - I
B = kx[:, S.newaxis] / k * linsolve(E, Kx) - I
# A = S.dot(Kx, Kx) - E
A = S.diag((kx / k) ** 2) - E
# Note: solution bug alfredo
# randomizzo Kx un po' a caso finche' cond(A) e' piccolo (<1e10)
# soluzione sporca... :-(
# per certi kx, l'operatore di helmholtz ha 2 autovalori nulli e A, B
# non sono invertibili --> cambio leggermente i kx... ma dovrei invece
# trattare separatamente (analiticamente) questi casi
if cond(A) > 1e10:
warning('BAD CONDITIONING: randomization of kx')
while cond(A) > 1e10:
Kx = Kx * (1 + 1e-9 * S.rand())
B = kx[:, S.newaxis] / k * linsolve(E, Kx) - I
A = S.diag((kx / k) ** 2) - E
if S.absolute(K[2] / k) > 1e-10:
raise ValueError(
'First Order Helmholtz Operator not implemented, yet!')
elif ky == 0 or S.allclose(S.diag(Ky / ky * k), 1):
# lalanne
# H_U_reduced = S.dot(Ky, Ky) + A
H_U_reduced = (ky / k) ** 2 * I + A
# H_S_reduced = S.dot(Ky, Ky) + S.dot(Kx, linsolve(E, S.dot(Kx, E11))) - E11
H_S_reduced = (ky / k) ** 2 * I + kx[:, S.newaxis] / k * linsolve(E,
kx[:, S.newaxis] / k * E11) - E11
q1, W1 = eig(H_U_reduced)
q1 = S.sqrt(q1)
q2, W2 = eig(H_S_reduced)
q2 = S.sqrt(q2)
# boundary conditions
# V11 = S.dot(linsolve(A, W1), S.diag(q1))
V11 = linsolve(A, W1) * q1[S.newaxis, :]
V12 = (ky / k) * S.dot(linsolve(A, Kx), W2)
V21 = (ky / k) * S.dot(linsolve(B, Kx), linsolve(E, W1))
# V22 = S.dot(linsolve(B, W2), S.diag(q2))
V22 = linsolve(B, W2) * q2[S.newaxis, :]
# Vss = S.dot(Fc, V11)
Vss = fc[:, S.newaxis] * V11
# Wss = S.dot(Fc, W1) + S.dot(Fs, V21)
Wss = fc[:, S.newaxis] * W1 + fs[:, S.newaxis] * V21
# Vsp = S.dot(Fc, V12) - S.dot(Fs, W2)
Vsp = fc[:, S.newaxis] * V12 - fs[:, S.newaxis] * W2
# Wsp = S.dot(Fs, V22)
Wsp = fs[:, S.newaxis] * V22
# Wpp = S.dot(Fc, V22)
Wpp = fc[:, S.newaxis] * V22
# Vpp = S.dot(Fc, W2) + S.dot(Fs, V12)
Vpp = fc[:, S.newaxis] * W2 + fs[:, S.newaxis] * V12
# Wps = S.dot(Fc, V21) - S.dot(Fs, W1)
Wps = fc[:, S.newaxis] * V21 - fs[:, S.newaxis] * W1
# Vps = S.dot(Fs, V11)
Vps = fs[:, S.newaxis] * V11
Mc2bar = S.asarray(S.bmat([[Vss, Vsp, Vss, Vsp],
[Wss, Wsp, -Wss, -Wsp],
[Wps, Wpp, -Wps, -Wpp],
[Vps, Vpp, Vps, Vpp]]))
x = S.r_[S.exp(-k * q1 * d), S.exp(-k * q2 * d)]
# Mc1 = S.dot(Mc2bar, S.diag(S.r_[S.ones_like(x), x]))
xx = S.r_[S.ones_like(x), x]
Mc1 = Mc2bar * xx[S.newaxis, :]
X[:, :, nlayer] = S.diag(x)
MTp = linsolve(Mc2bar, MT)
MTp1[:, :, nlayer] = MTp[0:2 * nood, :]
MTp2 = MTp[2 * nood:, :]
MT = S.dot(
Mc1, S.r_[
I2, S.dot(
MTp2, linsolve(
MTp1[
:, :, nlayer], X[
:, :, nlayer]))])
else:
ValueError(
'Second Order Helmholtz Operator not implemented, yet!')
# M = S.asarray(S.bmat([-MR, MT]))
M = S.c_[-MR, MT]
b = S.r_[S.sin(psi) * dlt,
1j * S.sin(psi) * n1 * S.cos(alpha) * dlt,
-1j * S.cos(psi) * n1 * dlt,
S.cos(psi) * S.cos(alpha) * dlt]
x = linsolve(M, b)
R, T = S.split(x, 2)
Rs, Rp = S.split(R, 2)
for ii in range(1, nlayers - 1):
T = S.dot(linsolve(MTp1[:, :, ii], X[:, :, ii]), T)
Ts, Tp = S.split(T, 2)
DE1[:, iwl] = (k1i[2, :] / (k1[2])).real * S.absolute(Rs) ** 2 + \
(k1i[2, :] / (k1[2] * n1 ** 2)).real * \
S.absolute(Rp) ** 2
DE3[:, iwl] = (k3i[2, :] / (k1[2])).real * S.absolute(Ts) ** 2 + \
(k3i[2, :] / (k1[2] * n3 ** 2)).real * \
S.absolute(Tp) ** 2
# save the results
self.DE1 = DE1
self.DE3 = DE3
return self
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import sys
import time
from pylab import load as L
import numpy as N
from scipy import rand
test_data = rand(10, 2)
my_data = [['00', '01', '02'], ['10', '11', '12'], ['20', '21', '22'],
['30', '31', '32']]
#my_data = L('Z.csv', delimiter = ',')
def main():
app = QApplication(sys.argv)
w = DBTable()
#w.show()
sys.exit(app.exec_())
class DBTable(QWidget):
# super(Plot_Widget, self).__init__(None)#new new^2:changed from parent
# self.setAttribute(Qt.WA_DeleteOnClose)
def __init__(self, dataList=None, colHeaderList=None):
QWidget.__init__(self)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle('Database Result')
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 4 14:01:02 2018
@author : Alexis Martin
"""
import scipy
import numpy as np
import time
import PartitionData as part
import matplotlib.pyplot as plt
nData = 1000000
dim = 100
nNodes = 50
X = scipy.rand(nData, dim)
# print("X created")
ind = np.random.choice(nData, nNodes)
# print("ind created")
NodePositions = X[ind, ]
# print("NodePositions created")
XSquared = np.ndarray.reshape((X**2).sum(axis=1), (nData, 1))
# print("XSquared created")
print("Start")
t = time.time()
partition, dists = part.PartitionData(X, NodePositions, 100000, XSquared)
print(time.time() - t, "seconds")
if nData < 100000 and dim == 2:
A = [None] * nNodes
color = ['c', 'r', 'b', 'g', 'y', 'm', 'k']
def gen_data(N=100, P=4):
f = 20
G = 1. * (sp.rand(N, f) < 0.2)
F = sp.rand(N, 2)
Y = sp.randn(N, P)
return Y, F, G
# a[0] = -a[0]
# write
print(type(a))
# a[:] = np.resize(np.array([[1,2],[3,255]]),(4,)).astype('uint8')
a[1:2] = np.array([
255,
]).astype('uint8')
print(sum(a))
if __name__ == '__main__':
# Create the array
N = int(4)
unshared_arr = scipy.rand(N).astype('uint8')
a = Array(c_ubyte, np.zeros((4, ), dtype=np.uint8))
print(a[:])
# Create, start, and finish the child process
p = Process(target=f, args=(a, ))
p.start()
p.join()
# Print out the changed values
print(a[:])
# b = np.frombuffer(a.get_obj(),dtype=np.uint8) # same address in memory
# b = np.array(a) # copy
b = a[:]
b[0] = 10
print '-'
# data += [[output[6],output[7],output[8],output[9],output[10],output[11]]]
fs_dyn = []
for j in sorted(FSNet.activation.iterkeys()):
if j > (dim - 1):
fs_dyn += [FSNet.activation[j]]
data += [fs_dyn]
#goalFS.append([FSNet.activation[12],FSNet.mismatch[12],FSNet.net[12].isActive,FSNet.net[12].failed])
goalsDyn.append(goalsReached)
NFSDyn.append(len(FSNet.net.keys()))
if (currState == goal):
if (oldState != goal):
goalsReached += 1
# break
# if (len(FSNet.failedFS)==0 and (np.rand() < 0.2)):# and (len(FSNet.activatedFS)==dim):
if (np.rand() < 0.2):
currState = start[:]
FSNet.resetActivity()
print currState, start
if len(FSNet.matchedFS) > 0 and drawFSNet:
plt.figure(num=('t:' + str(t)))
plt.subplots_adjust(left=0.02, right=0.98, top=1., bottom=0.0)
viz.drawNet(FSNet.net)
plt.figure()
plt.subplot(3, 1, 1)
plt.pcolor(np.asarray(zip(*data)))
plt.title('out FS dynamics')
#plt.figure()
plt.subplot(3, 1, 2)
plt.plot(goalsDyn)
