def is_psd(M: np.ndarray, strict=False, tol=1e-8) -> bool: """ Tests if matrix is positive semi-definite Parameters ---------- M: (N, N) ndarray Matrix to be tested for positive semi-definiteness strict: bool If True, tests for posotive definiteness tol: float Numeric tolerance to check for equality Returns ------- bool True if matrix is positive (semi-)definite, else False """ if isinstance(M, (int, float)): return M >= 0 M = np.asarray(M) if not is_symmetric(M, tol): return False if strict: return (la.eigvalsh(M) > 0).all() else: return (la.eigvalsh(M) >= 0).all()
def FBFMEB(engine,app): ''' This method calculates the energy spectrums of the spin excitations. ''' path,ne=app.path,min(app.ne or engine.nmatrix,engine.nmatrix) if path is not None: bz,reciprocals=engine.basis.BZ,engine.lattice.reciprocals if not isinstance(path,HP.BaseSpace): path=bz.path(HP.KMap(reciprocals,path) if isinstance(path,str) else path,mode='Q') result=np.zeros((path.rank(0),ne+1)) result[:,0]=path.mesh(0) if path.mesh(0).ndim==1 else np.array(range(path.rank(0))) engine.log<<'%s: '%path.rank(0) for i,paras in enumerate(path('+')): engine.log<<'%s%s'%(i,'..' if i<path.rank(0)-1 else '') m=engine.matrix(scalefree=app.scalefree,scaleint=app.scaleint,**paras) result[i,1:]=nl.eigvalsh(m)[:ne] if app.method=='eigvalsh' else HM.eigsh(m,k=ne,evon=False) engine.log<<'\n' else: result=np.zeros((2,ne+1)) result[:,0]=np.array(range(2)) m=engine.matrix(scalefree=app.scalefree,scaleint=app.scaleint) result[0,1:]=nl.eigvalsh(m)[:ne] if app.method=='eigvalsh' else HM.eigsh(m,k=ne,evon=False) result[1,1:]=result[0,1:] name='%s_%s%s'%(engine.tostr(mask=path.tags),app.name,app.suffix) if app.savedata: np.savetxt('%s/%s.dat'%(engine.dout,name),result) if app.plot: app.figure('L',result,'%s/%s'%(engine.dout,name)) if app.returndata: return result
def Eigenvalues(Hgesamt): eigenwerte=[] eigenwerte2=[] for l in range(N/2): block=Hgesamt[l*8:8+l*8:,l*8:8+l*8:] eigenwerte.append(LA.eigvalsh(block)) eigenwerte2.extend(LA.eigvalsh(block)) #print(eigenwerte2) return(eigenwerte)
def linear_algebra(): """ Use the `numpy.linalg` library to do Linear Algebra For a reference on math, see 'Linear Algebra explained in four pages' http://minireference.com/static/tutorials/linear_algebra_in_4_pages.pdf """ ### Setup two vectors x = np.array([1, 2, 3, 4]) y = np.array([5, 6, 7, 8]) ### Vector Operations include addition, subtraction, scaling, norm (length), # dot product, and cross product print np.vdot(x, y) # Dot product of two vectors ### Setup two arrays / matrices a = np.array([[1, 2], [3, 9]]) b = np.array([[2, 4], [5, 6]]) ### Dot Product of two arrays print np.dot(a, b) ### Solving system of equations (i.e. 2 different equations with x and y) print LA.solve(a, b) ### Inverse of a matrix undoes the effects of the Matrix # The matrix multipled by the inverse matrix returns the # 'identity matrix' (ones on the diagonal and zeroes everywhere else); # identity matrix is useful for getting rid of the matrix in some equation print LA.inv(a) # return inverse of the matrix print "\n" ### Determinant of a matrix is a special way to combine the entries of a # matrix that serves to check if matrix is invertible (!=0) or not (=0) print LA.det(a) # returns the determinant of the array print "\n" # e.g. 3, means that it is invertible ### Eigenvectors is a special set of input vectors for which the action of # the matrix is described as simple 'scaling'. When a matrix is multiplied # by one of its eigenvectors, the output is the same eigenvector multipled # by a constant (that constant is the 'eigenvalue' of the matrix) print LA.eigvals(a) # comput the eigenvalues of a general matrix print "\n" print LA.eigvalsh(a) # Comput the eigenvalues of a Hermitian or real symmetric matrix print "\n" print LA.eig(a) # return the eigenvalues for a square matrix print "\n" print LA.eigh(a) # return the eigenvalues or eigenvectors of a Hermitian or symmetric matrix print "\n"
def do(self, a, b): # note that eigenvalue arrays returned by eig must be sorted since # their order isn't guaranteed. ev = linalg.eigvalsh(a, 'L') evalues, evectors = linalg.eig(a) evalues.sort(axis=-1) assert_allclose(ev, evalues, rtol=get_rtol(ev.dtype)) ev2 = linalg.eigvalsh(a, 'U') assert_allclose(ev2, evalues, rtol=get_rtol(ev.dtype))
def info_rate(G_PRE,H,Sigma_Z): #G_PRE is a list for precoding matrices for all users #H is a list for channel matrices G1, G2 = G_PRE R_users = list() for u in [0,1]: # 2 users m, n = H[u].shape R_total = array(0) for i in range(n): #G = G_RX[u] #R_v1 = identity(n) #R_v2 = identity(n) R_v1 = zeros((n,n)) R_v1[0,0] = 1 R_v2 = zeros((n,n)) R_v2[1,1] = 1 Sigma_X = \ G1.dot(R_v1).dot(G1.conj().transpose()) + \ G2.dot(R_v2).dot(G2.conj().transpose()) Sigma_Y = ( H[u].dot(Sigma_X).dot(H[u].conj().transpose()) + Sigma_Z ) if u==0: # if user 1 R_v1[i,i] = 0 elif u==1: # if user 2 R_v2[i,i] = 0 Sigma_X_V = \ G1.dot(R_v1).dot(G1.conj().transpose()) + \ G2.dot(R_v2).dot(G2.conj().transpose()) Sigma_Y_V = ( H[u].dot(Sigma_X_V).dot(H[u].conj().transpose()) + Sigma_Z ) H_Y = sum(log(eigvalsh(Sigma_Y))) H_Y_V = sum(log(eigvalsh(Sigma_Y_V))) R = H_Y - H_Y_V R_total = R_total + R R_users.append(R_total) return R_users
def info_rate_ild_fast( H_TX, H_CH, H_RX, P_vec, SCHEME, SIM ): N0 = SIM['N0']; dt = SIM['dt']; REAL_DIM_PER_SYM = SIM['REAL_DIM_PER_SYM']; T_TRANSMISSION = SIM['T_TRANSMISSION']; # Power allocation (uniform) Sigma_X_NORMALIZED, layer = power_alloc(H_TX, SCHEME, SIM); K_prime = len(layer); #K_prime = SHCEME['K_prime'] # Compute mutual informal layer by layer R_vec_per_layer = zeros((K_prime,len(P_vec))); for k in range(K_prime): sigma2_N = N0/2 * REAL_DIM_PER_SYM * (1/dt); # DEPENDS ON WHETHER NOISE IS REAL (PASSBAND) OR COMPLEX (BASEBAND) #Sigma_N = sigma2_N * eye(length(layer{k})); H_RX_k = H_RX[:,layer[k]]; H_RX_k, s, V = svd(H_RX_k); # ensure that H_RX_k is orthonormal H_RXCHTX = H_RX_k.transpose().dot(H_CH).dot(H_TX); Sigma_X = Sigma_X_NORMALIZED; #XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX Sigma_S = H_RXCHTX.dot(Sigma_X).dot(H_RXCHTX.transpose()); #Sigma_Z = H_RX_k.transpose().dot(sigma2_N).dot(H_RX_k); Sigma_X_bar = Sigma_X; Sigma_X_bar[:,layer[k]] = 0; Sigma_X_bar[layer[k],:] = 0; Sigma_S_bar = H_RXCHTX.dot(Sigma_X_bar).dot(H_RXCHTX.transpose()); EIG_S = eigvalsh(Sigma_S); EIG_S_bar = eigvalsh(Sigma_S_bar); I_vec = zeros(len(P_vec)); loop_index = 0; for P in P_vec: #I = sum(log(eig( P*Sigma_S+Sigma_Z ))) - sum(log(eig( P*Sigma_S_bar+Sigma_Z ))); I = sum(log( P * EIG_S + sigma2_N )) - sum(log( P * EIG_S_bar + sigma2_N )); I_vec[loop_index] = I; loop_index = loop_index + 1; R_vec_per_layer[k,:] = I_vec / 2 * REAL_DIM_PER_SYM / T_TRANSMISSION; R_vec = sum(R_vec_per_layer,0); # sum the rows (sum along the columns) return R_vec
def _fa_paf(self, smc = True): cor = self.cor.copy() if smc: np.fill_diagonal(cor, utils.SMC(cor)) eig_val1 = la.eigvalsh(self.cor) eig_val1.sort() comm = np.sum(np.diag(cor)) err = comm comm_list = [] i = 0 while err > self.lower: eig_val, eig_vec = utils.eigenh_sorted(cor) if (self.n_factors > 1): loadings = eig_vec[:, :self.n_factors].dot( np.diag(np.sqrt(eig_val[:self.n_factors]))) else: loadings = eig_vec[:, 0] * np.sqrt(eig_val[0]) model = loadings.dot(loadings.T) new = np.diag(model) comm1 = np.sum(new) np.fill_diagonal(cor, new) err = np.abs(comm - comm1) if np.iscomplex(err): print('Imaginary eigenvalue condition' ' occurred!') break comm = comm1 comm_list.append(comm1) i += 1 if i > 1000: print('maximum iteration exceeded') err = 0 self.loadings = loadings
def normal_eval(mu, P, x, dP=None): """ Probability of x under normal(mu,inv(P)) Parameters ---------- mu: array of shape (n): the mean parameter P: array of shape (n,n): the precision matrix x: array of shape (n): the data to be evaluated Returns ------- (float) the density """ p = np.size(mu) if dP==None: dP = np.prod(eigvalsh(P)) mu = np.reshape(mu,(1,p)) w0 = np.log(dP)-p*np.log(2*np.pi) w0 /= 2 x = np.reshape(x,(1,p)) q = np.dot(np.dot(mu-x,P),(mu-x).T) w = w0 - q/2 L = np.exp(w) return np.squeeze(L)
def compactness(im): from numpy import array, meshgrid, arange, shape, mean, zeros from numpy import outer, sum, max, linalg from numpy import sqrt from math import exp (h, w) = shape(im) (X, Y) = meshgrid(arange(w), arange(h)) x = X.flatten() y = Y.flatten() wgts = im[y, x] sw = sum(wgts) if sw == 0: return 1 wgts /= sw wpts = array([wgts * x, wgts * y]) wmean = sum(wpts, 1) N = len(x) s = array([x, y]) P = zeros((2, 2)) for i in range(0, N): P += wgts[i] * outer(s[:, i], s[:, i]) P = P - outer(wmean, wmean) det = abs(linalg.det(P)) if det > 0: v = linalg.eigvalsh(P) v = abs(v) r = min(v) / max(v) return 100.0 * sqrt(r / det) else: return 0.0
def __call__(self, function, point, state): """ Computes Goldfeld step """ g = function.gradient(point) state['gradient'] = g G = function.hessian(point) state['hessian'] = G c = 1e-8 # is this one best? d0 = None try: L = cholesky(G) # reach here => isPositiveDefinite = True step = n_solve(L.T, n_solve(L, -g)) except: # isPositiveDefinite = False G_eigvals = eigvalsh(G) minEig = min(G_eigvals) if minEig < 0: shift = -minEig + c #avoiding sparse case with big nVars for i in xrange(point): G[i,i] += shift step = n_solve(G, -g) state['direction'] = step return step
def calculate_gyration_tensor_parameters(points): """ Calculates the gyration tensor parameters R_g^2, η, c, κ from a list of all points inside a cavity. - R_g^2 is the squared gyration radius - η is the asphericity - c is the acylindricity - κ is the anisotropy """ points = np.array(points, dtype=np.float) mean = np.mean(points, axis=0) points -= mean gyration_tensor = np.zeros((3, 3)) for i in range(3): for j in range(i, 3): gyration_tensor[i, j] = np.dot(points[:, i], points[:, j]) gyration_tensor[j, i] = gyration_tensor[i, j] # cell volume is constant, cavity volume is proportional to len(points) gyration_tensor /= len(points) eigvals = list(sorted(la.eigvalsh(gyration_tensor), reverse=True)) squared_gyration_radius = sum(eigvals) if squared_gyration_radius > 0: asphericity = (eigvals[0] - 0.5 * (eigvals[1] + eigvals[2])) / squared_gyration_radius acylindricity = (eigvals[1] - eigvals[2]) / squared_gyration_radius anisotropy = (asphericity ** 2 + 0.75 * acylindricity ** 2) ** 0.5 else: asphericity = 0 acylindricity = 0 anisotropy = 0 return mean, squared_gyration_radius, asphericity, acylindricity, anisotropy
def array_compactness(im): ''' calculate the compactness of a 2D array. Each element of the 2D array should be proportional to the score of that pixel in the overall scoring scheme . ''' from numpy import array,meshgrid,arange,shape,mean,zeros from numpy import outer,sum,max,linalg from numpy import sqrt from math import exp (h,w) = shape(im) (X,Y) = meshgrid(arange(w),arange(h)) x = X.flatten() y = Y.flatten() wgts = im[y,x] sw = sum(wgts) if sw == 0: return 1 wgts /= sw wpts = array([wgts*x, wgts*y]) wmean = sum(wpts, 1) N = len(x) s = array([x,y]) P = zeros((2,2)) for i in range(0,N): P += wgts[i]*outer(s[:,i],s[:,i]) P = P - outer(wmean,wmean); det = abs(linalg.det(P)) if (det <= 0): return 0.0 v = linalg.eigvalsh(P) v = abs(v) r = min(v)/max(v) return 100.0*sqrt(r/det)
def f(k): kp = kpgen(k) # get kpoint hk = hk_gen(kp) # generate hamiltonian # es,ew = lgs.eigsh(csc_matrix(hk),k=4,which="LM",sigma=0.0) es = lg.eigvalsh(hk) # get eigenvalues g = np.min(es[es>0.]) - np.max(es[es<0.]) return g # return gap
def eigenvalues_hadamard(matrix1, matrix2): """Computes the Hadamard product of 2 matrices. See https://www.johndcook.com/blog/2018/10/10/hadamard-product/ for details :param matrix1: first matrix :param matrix2: second matrix :return: lower and upper """ matrix1 = array(matrix1) # as arrays matrix2 = array(matrix2) eig_a = eigvalsh(matrix1) # eigenvalues (optimized for Hermitian matrices) eig_b = eigvalsh(matrix2) return eig_a, eig_b
def unweighted_likelihood_(self, x): """ return the likelihood of each data for each component the values are not weighted by the component weights Parameters ---------- x: array of shape (n_samples,self.dim) the data used in the estimation process Returns ------- like, array of shape(n_samples,self.k) unweighted component-wise likelihood """ n = x.shape[0] like = np.zeros((n, self.k)) for k in range(self.k): # compute the data-independent factor first w = -np.log(2 * np.pi) * self.dim m = np.reshape(self.means[k], (1, self.dim)) b = self.precisions[k] if self.prec_type == "full": w += np.log(eigvalsh(b)).sum() dx = m - x q = np.sum(np.dot(dx, b) * dx, 1) else: w += np.sum(np.log(b)) q = np.dot((m - x) ** 2, b) w -= q w /= 2 like[:, k] = np.exp(w) return like
def main(): L = 42 t = 1 h_0 = t*np.eye(L, k=1) ##Upper triagonal of hopping in y-direction h_0[0,L-1] = np.conjugate(t) ##Periodic boundary condition in -y-direction h_0 = h_0 + h_0.conj().T ##Full matrix for one slice in y h_0 = np.kron(np.eye(L), h_0) ##Put all slices together diag = np.eye(L, k=1) period = np.eye(L, k=L-1) ##Now only the hopping between 1d slices is missing the for loop will add these # ps = np.array([1, 2, 6, 8, 12, 14, 16, 21]) ps = np.linspace(0, 100, 50) ##All fluxes spectrum = [] for p in np.nditer(ps): t_mag = np.exp(2j*np.pi*np.arange(L)*p/L) ##Peierls phase for all fluxes X = t*np.diag(t_mag) X = np.kron(diag, X) + np.kron(period, X.conj().T) X = X + X.conj().T ##Construct the hopping matrix in x-direction between 1d slices H = h_0 + X ##Add the two hamiltonian parts spectrum.append(LA.eigvalsh(H)) ##Get eigenvalues for each flux ax = plt.subplot(111) ps = ps/L ax.plot(ps, spectrum, marker='.', markersize=0.1, linestyle='None', color='k') plt.show()
def get_vn_entropy(psi, spin, N=None, mode='1spin', base='e'): """ Compute the von Neumann entropy for a given state "psi". "psi" must be a column vector. Sparsity is optional. Available modes: "1spin" for the entanglement entropy for only the first spin, "eqsplit" for the entanglement entropy for an evenly split system. Available bases: "e" for natural log, "2" for log2 and "10" for log10. """ if N is None and mode == 'eqsplit': raise Exception("N cannot be 'None' for mode='eqsplit'.") if mode == '1spin': red_rho_A = red_rho_A_1spin(psi, spin) elif mode == 'eqsplit': red_rho_A = red_rho_eqsplit(psi, spin, N) lamb = eigvalsh(red_rho_A.todense()) # Eigenvalues of the reduced matrix. S_AB_terms = [] for i in range(np.shape(red_rho_A)[0]): if abs(lamb[i]) < 1e-6: # lim a->0 (alog(a)) = 0. It also removes some minuscule negative # lambda values resulting from rounding errors. S_AB_terms.append(0) else: if base == 'e': S_AB_terms.append(-lamb[i] * np.log(lamb[i])) elif base == '2' or base == 2: S_AB_terms.append(-lamb[i] * np.log2(lamb[i])) elif base == '10' or base == 10: S_AB_terms.append(-lamb[i] * np.log10(lamb[i])) else: raise Exception('Available bases are "e", "2" and "10"') return float(np.sum(S_AB_terms))
def genMulCov(size, numberOfCov, low, upper, mode, portion = 0.05): S_set = [] Cov_set = [] minEVal_set = [] # low = abs(low) # upper = abs(upper) m = size/3 mm = m/2 # print m, mm S_init = np.zeros((size,size)) for k in range(numberOfCov): S = np.zeros((size,size)) if k == 0: S = genInvCov(size, low, upper, portion) if mode == 5: ind_zero = np.where(spy.sparse.rand(m, size-m, 0.5).todense() == 0) value = np.multiply((np.random.randint(2, size = (m, size -m)) - 0.5)*2,(low + (upper - low)*np.random.rand(m,size -m))) value[ind_zero] = 0 hub = value S[:m, m:size] = hub S[m:size, :m] = hub.T minEVal_set.append(alg.eigvalsh(S)[0]) S_init = S elif mode == 3: #'laplacian' ind1 = range(m) ind2 = np.random.permutation(m) S = np.copy(S_init) S[ind1, :] = S[ind2, :] S[:, ind1] = S[:, ind2] elif mode == 5: #'perturbation' S = np.copy(S_init) ind_zero = np.where(spy.sparse.rand(mm, size-mm, 0.5).todense() == 0) pert = np.multiply((np.random.randint(2, size = (mm, size -mm)) - 0.5)*2,(low + (upper - low)*np.random.rand(mm,size -mm))) pert[ind_zero] = 0 S[:mm, mm:size] = pert S[mm:size, :mm] = pert.T minEVal_set.append(alg.eigvalsh(S)[0]) else: # print 'Activate normal mode' S = genInvCov(size, low, upper, portion) S_set.append(S) for k in range(numberOfCov): if mode == 5: S_set[k] = S_set[k] + (0.1 - min(minEVal_set))*np.identity(size) Cov_set.append(alg.inv(S_set[k])) return S_set, Cov_set
def prinvals(self): if self.type != SYMTENSOR: return None if self._prin is None: sx, sy, sz, txy, tyz, txz = self._tensor_components() s3, s2, s1 = sorted(eigvalsh([[sx,txy,txz],[txy,sy,tyz],[txz,tyz,sz]])) self._prin = array([s3, s2, s1]) return self._prin
def do(self, a, b): # note that eigenvalue arrays must be sorted since # their order isn't guaranteed. ev = linalg.eigvalsh(a) evalues, evectors = linalg.eig(a) ev.sort(axis=-1) evalues.sort(axis=-1) assert_almost_equal(ev, evalues)
def do(self, a): ev = linalg.eigvalsh(a) # flip resulting eigenvalue array, since they are returned in # reverse order from the values given by linal.eig ev = ev[::-1] evalues, evectors = linalg.eig(a) assert_almost_equal(ev, evalues)
def gaussian_latitudes(n): """Construct latitudes and latitude bounds for a Gaussian grid. Args: * n: The Gaussian grid number (half the number of latitudes in the grid. Returns: A 2-tuple where the first element is a length `n` array of latitudes (in degrees) and the second element is an `(n, 2)` array of bounds. """ if abs(int(n)) != n: raise ValueError('n must be a non-negative integer') nlat = 2 * n # Create the coefficients of the Legendre polynomial and construct the # companion matrix: cs = np.array([0] * nlat + [1], dtype=np.int) cm = legcompanion(cs) # Compute the eigenvalues of the companion matrix (the roots of the # Legendre polynomial) taking advantage of the fact that the matrix is # symmetric: roots = la.eigvalsh(cm) roots.sort() # Improve the roots by one application of Newton's method, using the # solved root as the initial guess: fx = legval(roots, cs) fpx = legval(roots, legder(cs)) roots -= fx / fpx # The roots should exhibit symmetry, but with a sign change, so make sure # this is the case: roots = (roots - roots[::-1]) / 2. # Compute the Gaussian weights for each interval: fm = legval(roots, cs[1:]) fm /= np.abs(fm).max() fpx /= np.abs(fpx).max() weights = 1. / (fm * fpx) # Weights should be symmetric and sum to two (unit weighting over the # interval [-1, 1]): weights = (weights + weights[::-1]) / 2. weights *= 2. / weights.sum() # Calculate the bounds from the weights, still on the interval [-1, 1]: bounds1d = np.empty([nlat + 1]) bounds1d[0] = -1 bounds1d[1:-1] = -1 + weights[:-1].cumsum() bounds1d[-1] = 1 # Convert the bounds to degrees of latitude on [-90, 90]: bounds1d = np.rad2deg(np.arcsin(bounds1d)) bounds2d = np.empty([nlat, 2]) bounds2d[:, 0] = bounds1d[:-1] bounds2d[:, 1] = bounds1d[1:] # Convert the roots from the interval [-1, 1] to latitude values on the # interval [-90, 90] degrees: latitudes = np.rad2deg(np.arcsin(roots)) return latitudes, bounds2d
def restricted_lovasz_DIMACS(G): H=nx.complement(o.Instance(G)) A=nx.adjacency_matrix(H) import numpy as np B=np.eye(len(H.nodes())) from numpy.linalg import eigvalsh L=list(eigvalsh(A+B)) L.sort(reverse=True) return int(np.floor(sum([L[k] for k in range(0,1)])))
def __init__(self,initmean,initvar,transgain,transnoise,measgain,measnoise): # Check the initial mean. try: numstate,=numpy.shape(initmean) except ValueError: raise Exception('Initial mean must be a vector.') # Check the initial variance. if numpy.shape(initvar)!=(numstate,numstate): raise Exception('Initial variance must be a {}-by-{} matrix.'.format(numstate,numstate)) if not numpy.allclose(numpy.transpose(initvar),initvar): raise Exception('Initial variance matrix must be symmetric.') try: cholfact=linalg.cholesky(initvar) except linalg.LinAlgError: raise Exception('Initial variance matrix must be positive-definite.') # Check the transition gain. if numpy.ndim(transgain)!=2 or numpy.shape(transgain)!=(numstate,numstate): raise Exception('Transition gain must be a {}-by-{} matrix.'.format(numstate,numstate)) # Check the transition noise. if numpy.ndim(transnoise)!=2 or numpy.shape(transnoise)!=(numstate,numstate): raise Exception('Transition noise must be a {}-by-{} matrix.'.format(numstate,numstate)) if not numpy.allclose(numpy.transpose(transnoise),transnoise): raise Exception('Transition noise matrix must be symmetric.') if numpy.any(linalg.eigvalsh(transnoise)<0.0): raise Exception('Transition noise matrix must be positive-semi-definite.') # Check the measurement gain. try: numobs,numcol=numpy.shape(measgain) except ValueError: raise Exception('Measurement gain must be a matrix.') if numcol!=numstate: raise Exception('Measurement gain matrix must have {} columns.'.format(numstate)) # Check the measurement noise. if numpy.ndim(measnoise)!=2 or numpy.shape(measnoise)!=(numobs,numobs): raise Exception('Measurement noise must be a {}-by-{} matrix.'.format(numobs,numobs)) if not numpy.allclose(numpy.transpose(measnoise),measnoise): raise Exception('Measurement noise matrix must be symmetric.') try: cholfact=linalg.cholesky(measnoise) except linalg.LinAlgError: raise Exception('Measurement noise matrix must be positive-definite.') # Set the model. self.initmean=numpy.asarray(initmean) self.initvar=numpy.asarray(initvar) self.transgain=numpy.asarray(transgain) self.transnoise=numpy.asarray(transnoise) self.measgain=numpy.asarray(measgain) self.measnoise=numpy.asarray(measnoise) self.__size__=numstate,numobs
def info_rate_expand( H_TX, H_CH, H_RX, P_vec, SCHEME, SIM ): #return R_vec #[U, S, V] = svd(H_RX); #svalue = diag(S); #SELECTED_COLS_IDX = find(svalue > max(svalue) * 1e-4); #H_RX_REDUCED = U(:,SELECTED_COLS_IDX); [U, svalue, V] = svd(H_RX); IS_ABOVE_THRESHOLD = svalue > max(svalue) * 1e-4; SELECTED_COLS_IDX = [i for i in range(len(IS_ABOVE_THRESHOLD)) if IS_ABOVE_THRESHOLD[i]==True]; H_RX_REDUCED = U[:,SELECTED_COLS_IDX]; #%------------------------------------------------------- N0 = SIM['N0']; dt = SIM['dt']; REAL_DIM_PER_SYM = SIM['REAL_DIM_PER_SYM']; T_TRANSMISSION = SIM['T_TRANSMISSION']; Sigma_X_NORMALIZED, layer = power_alloc(H_TX, SCHEME, SIM); H_RXCHTX = H_RX_REDUCED.transpose().dot(H_CH).dot(H_TX); sigma2_N = N0/2 * REAL_DIM_PER_SYM * (1/dt); # DEPENDS ON WHETHER NOISE IS REAL (PASSBAND) OR COMPLEX (BASEBAND) #trace(Sigma_N)*dt Sigma_Z = H_RX_REDUCED.transpose().dot(sigma2_N).dot(H_RX_REDUCED); trace(Sigma_Z)*dt HYX = sum(log(eigvalsh(Sigma_Z))) #H(Y|X) I_vec = zeros(len(P_vec)); loop_index = 0; for P in P_vec: Sigma_X = P * Sigma_X_NORMALIZED; #XXXXXXXXXXXXXXXXXXXXXXXXXXXX Sigma_S = H_RXCHTX.dot(Sigma_X).dot(H_RXCHTX.transpose()); HY = sum(log(eigvalsh(Sigma_S + Sigma_Z))) I = HY - HYX; I_vec[loop_index] = I; loop_index = loop_index + 1; R_vec = I_vec / 2 * REAL_DIM_PER_SYM / T_TRANSMISSION; return R_vec
def coth_poles_pade(N, use_scipy=False): """ Calculates the simple poles of the [N-1, N] Padé approximant to the hyperbolic cotangent function and the corresponding residues. The implementation follows Hu et al. JCP 134, 244106 (2011). Remarks: Pole at x = 0 is NOT included! Only poles with non-negative imaginary part are returned. The other ones can be obtained by either -poles or conj(poles). Arguments: 'N' -- number of expansion terms (integer) Return values: '(i·xi, eta)' -- tuple containing sorted np.array 'i·xi' of the purely imaginary poles and a sorted array 'eta' of the corresponding residues The hyperbolic cotangent is then approximated by coth(x) ≅ 1/x + sum( eta_j / (x - i xi_j) + eta_j / (x + i xi_j) ) """ # set-up the symmetric matrices A (2N,2N) and B (2N-1,2N-1) i = 1 + np.arange(2*N - 1) d = 1. / np.sqrt((2*i + 1) * (2*i + 3)) A = np.diag(d, 1) + np.diag(d, -1) B = A[1:, 1:] # find eigenvalues of matrices A and B if not use_scipy: AZ = la.eigvalsh(A) BZ = la.eigvalsh(B) else: AZ = sla.eigvalsh(A, overwrite_a=True) # gives no segfault BZ = sla.eigvalsh(B, overwrite_a=True) BZ = np.delete(-np.sort(-BZ), N - 1) # kick out the root at zero xi = np.sort(1. / AZ[AZ > 0.]); xi2 = np.square(xi) zeta = 1. / BZ[BZ > 0.]; zeta2 = np.square(zeta) nx = np.newaxis eta = (np.hstack([zeta2[nx, :] - xi2[:, nx], np.ones(N)[:, nx]]) / ((xi2[nx, :] - xi2[:, nx]) * (1. - np.identity(N)) + np.identity(N))).prod(-1) # The 'hstack' with 'ones' in the numerator of the product compensates for # smaller size of 'zeta' (N-1) compared to 'xi' (N). The 'identity' # construction in the denominator sets the main diagonal to unity, because # the product xi2_k - xi2_j is supposed to run over all k that are not equal # to j. eta *= N * (N + 1.5) return 1j * xi, eta # return poles and residues
def ml_function(Psi, S, q): sc = np.diag(1 / np.sqrt(Psi)) Sstar = sc.dot(S).dot(sc) eig_val = la.eigvalsh(Sstar) eig_val.sort() eig_val = eig_val[::-1] e = eig_val[-(eig_val.shape[0] - q):] e = np.sum(np.log(e) - e) - q + S.shape[0] return -e
def info_rate(G_RX,H,Sigma_Z): m, n = H.shape R_total = array(0) for i in range(n): G = G_RX[i,:].reshape((1,m)) R_xx = identity(n) Sigma_Y = G.dot( H.dot(R_xx).dot(H.conj().transpose()) + Sigma_Z ).dot( G.conj().transpose() ) R_xx_tilde = R_xx R_xx_tilde[i,i] = 0 Sigma_Y_X = G.dot( H.dot(R_xx_tilde).dot(H.conj().transpose()) + Sigma_Z ).dot( G.conj().transpose() ) H_Y = sum(log(eigvalsh(Sigma_Y))) H_Y_X = sum(log(eigvalsh(Sigma_Y_X))) R = H_Y - H_Y_X R_total = R_total + R return real(R_total)
def genInvCov(size, low = 0 , upper = 0.6, portion = 0.05): S = np.zeros((size,size)) G = GenRndGnm(PUNGraph, size, int((size*(size-1))*portion)) for EI in G.Edges(): value = (np.random.randint(2) - 0.5)*2*(low + (upper - low)*np.random.rand(1)[0]) S[EI.GetSrcNId(), EI.GetDstNId()] = value S = S + S.T vals = alg.eigvalsh(S) S = S + (0.1 - vals[0])*np.identity(size) return np.matrix(S)
cov_root = file_root + 'CovMatricesAll/' c2 = np.diag(np.loadtxt(cov_root + 'c2_n%d_m%d_11_%s.txt' % (n, m, index))) c3 = np.loadtxt(cov_root + 'c3_n%d_m%d_1,11_%s.txt' % (n, m, index)) c4 = np.loadtxt(cov_root + 'c4_n%d_m%d_11,11_%s.txt' % (n, m, index)) # Now symmetrize and return matrices return c2, 0.5 * (c3 + c3.T), 0.5 * (c4 + c4.T) # Load in full theoretical matrices print("Loading best estimate of covariance matrix") c2, c3, c4 = load_matrices('full') # Check matrix convergence from numpy.linalg import eigvalsh eig_c4 = eigvalsh(c4) eig_c2 = eigvalsh(c2) if min(eig_c4) < -1. * min(eig_c2): print( "4-point covariance matrix has not converged properly via the eigenvalue test. Exiting" ) sys.exit() # Compute full covariance matrices and precision full_cov = c4 + c3 * alpha + c2 * alpha**2. n_bins = len(c4) # Compute full precision matrix print("Computing the full precision matrix estimate:") # Load in partial theoretical matrices c2s, c3s, c4s = [], [], []
def get_prinmom(moi): prinmom = la.eigvalsh(moi) return prinmom
m = -1. tx = 0.5 t = 0.5 k0 = np.pi/3.*0. n=3 mg=0.9 rr=5. #fig1 = plt.figure(1) # axes.titlesize: large # fontsize of the axes title # axes.labelsize: medium # fontsize of the x any y labels for i, val in enumerate(k1): h1 = -(m * (2. - np.cos(k3)) + 2 * tx * (np.cos(k1[i]) - np.cos(k0)-mg)) * pm(1) - 2 * t * np.sin(k3) * pm(3) h2 = +m * pm(1) / 2 + t * pm(2) / 1j h3 = +m * pm(1) / 2 - t * pm(2) / 1j b = tridiag(h1, h2, h3, N) # this creates 2N*2N hamiltonian that describes the system for a GIVEN k_3 w = LA.eigvalsh(b) # this calculates the eigen values aka energies of the system for given k_3 #plt.plot(np.ones((np.size(w))) * k1[i], w, 'ko', # markersize=0.1) # this puts dots for each eigen value for a given k_3 n=np.arange(1,6,1) fig2 = plt.figure(2) for pi, val in enumerate(n): aa=250+n[pi] plt.subplot(aa) #super conductivity for i, val in enumerate(k1): h1=-(m*(2.-np.cos(k3))+2*tx*(np.cos(k1[i])-np.cos(k0)-mg))*pm(1)-2*t*np.sin(k3)*pm(3) h2=+m*pm(1)/2+t*pm(2)/1j h3=+m*pm(1)/2-t*pm(2)/1j H=tridiag(h1,h2,h3,N) #this creates 2N*2N hamiltonian that describes the system for a GIVEN k_3 hm1=-(m*(2.-np.cos(-k3))+2*tx*(np.cos(-k1[i])-np.cos(k0)-mg))*pm(1)-2*t*np.sin(-k3)*pm(3)
def myeigvalsh(v): return eigvalsh(v.reshape(N, N)).flatten()
a = np.arange(0.0, 1.01, 0.01) E1 = [] E2 = [] E3 = [] E4 = [] for i in range(101): x = a[i] # x är a y = 1 - x # y är b # print(x) H = np.array([[2 * x + y, 0, 0, 0], [0, -y, 2 * y, 0], [0, 2 * y, -y, 0], [0, 0, 0, -2 * x + y]]) E = LA.eigvalsh(H) # eigvalsh beräknar egenvärden till hermiteska matriser E1.append(E[0]) E2.append(E[1]) E3.append(E[2]) E4.append(E[3]) # print(x,E[0]) # print(E) plt.figure(num=None, figsize=(12, 8), dpi=80, facecolor='w', edgecolor='k') plt.plot(a, E1, 'r-', label='E_1') plt.plot(a, E2, 'g-', label='E_2') plt.plot(a, E3, 'b-', label='E_3') plt.plot(a, E4, 'k-', label='E_4')
def __init__(self, y, x, w, method='full', epsilon=0.0000001): # set up main regression variables and spatial filters self.y = y self.x = x self.n, self.k = self.x.shape self.method = method self.epsilon = epsilon #W = w.full()[0] #Wsp = w.sparse ylag = ps.lag_spatial(w, y) # b0, b1, e0 and e1 xtx = spdot(self.x.T, self.x) xtxi = la.inv(xtx) xty = spdot(self.x.T, self.y) xtyl = spdot(self.x.T, ylag) b0 = np.dot(xtxi, xty) b1 = np.dot(xtxi, xtyl) e0 = self.y - spdot(x, b0) e1 = ylag - spdot(x, b1) methodML = method.upper() # call minimizer using concentrated log-likelihood to get rho if methodML in ['FULL', 'LU', 'ORD']: if methodML == 'FULL': W = w.full()[0] # moved here res = minimize_scalar(lag_c_loglik, 0.0, bounds=(-1.0, 1.0), args=( self.n, e0, e1, W), method='bounded', tol=epsilon) elif methodML == 'LU': I = sp.identity(w.n) Wsp = w.sparse # moved here res = minimize_scalar(lag_c_loglik_sp, 0.0, bounds=(-1.0,1.0), args=(self.n, e0, e1, I, Wsp), method='bounded', tol=epsilon) elif methodML == 'ORD': # check on symmetry structure if w.asymmetry(intrinsic=False) == []: ww = symmetrize(w) WW = ww.todense() evals = la.eigvalsh(WW) else: W = w.full()[0] # moved here evals = la.eigvals(W) res = minimize_scalar(lag_c_loglik_ord, 0.0, bounds=(-1.0, 1.0), args=( self.n, e0, e1, evals), method='bounded', tol=epsilon) else: # program will crash, need to catch print("{0} is an unsupported method".format(methodML)) self = None return self.rho = res.x[0][0] # compute full log-likelihood, including constants ln2pi = np.log(2.0 * np.pi) llik = -res.fun - self.n / 2.0 * ln2pi - self.n / 2.0 self.logll = llik[0][0] # b, residuals and predicted values b = b0 - self.rho * b1 self.betas = np.vstack((b, self.rho)) # rho added as last coefficient self.u = e0 - self.rho * e1 self.predy = self.y - self.u xb = spdot(x, b) self.predy_e = inverse_prod( w.sparse, xb, self.rho, inv_method="power_exp", threshold=epsilon) self.e_pred = self.y - self.predy_e # residual variance self.sig2 = self.sig2n # no allowance for division by n-k # information matrix a = -self.rho * W np.fill_diagonal(a, 1.0) ai = la.inv(a) wai = np.dot(W, ai) tr1 = np.trace(wai) wai2 = np.dot(wai, wai) tr2 = np.trace(wai2) waiTwai = np.dot(wai.T, wai) tr3 = np.trace(waiTwai) wpredy = ps.lag_spatial(w, self.predy_e) wpyTwpy = np.dot(wpredy.T, wpredy) xTwpy = spdot(x.T, wpredy) # order of variables is beta, rho, sigma2 v1 = np.vstack( (xtx / self.sig2, xTwpy.T / self.sig2, np.zeros((1, self.k)))) v2 = np.vstack( (xTwpy / self.sig2, tr2 + tr3 + wpyTwpy / self.sig2, tr1 / self.sig2)) v3 = np.vstack( (np.zeros((self.k, 1)), tr1 / self.sig2, self.n / (2.0 * self.sig2 ** 2))) v = np.hstack((v1, v2, v3)) self.vm1 = la.inv(v) # vm1 includes variance for sigma2 self.vm = self.vm1[:-1, :-1] # vm is for coefficients only
def _p_mixed(self, state, sub_sys_A, return_rdm=None): """ This function calculates the eigenvalues of the reduced density matrix. It will first calculate the partial trace of the full density matrix and then diagonalizes it to get the eigenvalues. It will automatically choose the subsystem with the smaller hilbert space to do the diagonalization in order to reduce the calculation time but will only return the desired reduced density matrix. """ N = self.N sps = self.sps N_A = len(sub_sys_A) N_B = N - N_A proj = self.get_proj(_dtypes[state.dtype.char]) state = state.transpose((2, 0, 1)) Ns_full = proj.shape[0] n_states = state.shape[0] gen = (proj * s * proj.H for s in state[:]) proj_state = _np.zeros((n_states, Ns_full, Ns_full), dtype=_dtypes[state.dtype.char]) for i, s in enumerate(gen): proj_state[i, ...] += s[...] rdm_A, p_A = None, None rdm_B, p_B = None, None if return_rdm == 'both': rdm_A, rdm_B = _lattice_partial_trace_mixed(proj_state, sub_sys_A, N, sps, return_rdm="both") p_A = eigvalsh(rdm_A) + _np.finfo(rdm_A.dtype).eps p_B = eigvalsh(rdm_B) + _np.finfo(rdm_B.dtype).eps elif return_rdm == 'A': rdm_A, rdm_B = _lattice_partial_trace_mixed(proj_state, sub_sys_A, N, sps, return_rdm="A") p_A = eigvalsh(rdm_A) + _np.finfo(rdm_A.dtype).eps elif return_rdm == 'B': rdm_A, rdm_B = _lattice_partial_trace_mixed(proj_state, sub_sys_A, N, sps, return_rdm="B") p_B = eigvalsh(rdm_B) + _np.finfo(rdm_B.dtype).eps else: rdm_A, rdm_B = _lattice_partial_trace_mixed(proj_state, sub_sys_A, N, sps, return_rdm="A") p_A = eigvalsh(rdm_A) + _np.finfo(rdm_A.dtype).eps return p_A, p_B, rdm_A, rdm_B
if (m + n) % 2 == 0: return 0.0 return -8*a*m*n/(pi**2*((m**2-n**2)**2)) # construct the matrix, note that m & n in these expressions are one less than # in the original formulas because python numbering starts at 0, not 1 Hhat = empty([N, N]) for m in range(N): for n in range(N): Hhat[m, n] = H(m+1, n+1) # calculate the values and the vectors value = eigvalsh(Hhat) # print the results for n in range(to_print): print("E[", n+1, "] = ", value[n]/q, "eV") if part in ['e']: clf colors = ['r-', 'g-', 'b-'] wave = linspace(0, L, 100) x = linspace(0, L, 100) for n in range(3): # plot each wave function value for each i in x for i in range(len(wave)):
def band_structure(self, path_kc, modes=False, born=False, verbose=True): """Calculate phonon dispersion along a path in the Brillouin zone. The dynamical matrix at arbitrary q-vectors is obtained by Fourier transforming the real-space force constants. In case of negative eigenvalues (squared frequency), the corresponding negative frequency is returned. Frequencies and modes are in units of eV and Ang/sqrt(amu), respectively. Parameters: path_kc: ndarray List of k-point coordinates (in units of the reciprocal lattice vectors) specifying the path in the Brillouin zone for which the dynamical matrix will be calculated. modes: bool Returns both frequencies and modes when True. born: bool Include non-analytic part given by the Born effective charges and the static part of the high-frequency dielectric tensor. This contribution to the force constant accounts for the splitting between the LO and TO branches for q -> 0. verbose: bool Print warnings when imaginary frequncies are detected. """ assert self.D_N is not None if born: assert self.Z_avv is not None assert self.eps_vv is not None # Lattice vectors -- ordered as illustrated in class docstring R_cN = self.lattice_vectors() # Dynamical matrix in real-space D_N = self.D_N # Lists for frequencies and modes along path omega_kl = [] u_kl = [] # Reciprocal basis vectors for use in non-analytic contribution reci_vc = 2 * pi * la.inv(self.atoms.cell) # Unit cell volume in Bohr^3 vol = abs(la.det(self.atoms.cell)) / units.Bohr**3 for q_c in path_kc: # Add non-analytic part if born: # q-vector in cartesian coordinates q_v = np.dot(reci_vc, q_c) # Non-analytic contribution to force constants in atomic units qdotZ_av = np.dot(q_v, self.Z_avv).ravel() C_na = (4 * pi * np.outer(qdotZ_av, qdotZ_av) / np.dot(q_v, np.dot(self.eps_vv, q_v)) / vol) self.C_na = C_na / units.Bohr**2 * units.Hartree # Add mass prefactor and convert to eV / (Ang^2 * amu) M_inv = np.outer(self.m_inv_x, self.m_inv_x) D_na = C_na * M_inv / units.Bohr**2 * units.Hartree self.D_na = D_na D_N = self.D_N + D_na / np.prod(self.N_c) # if np.prod(self.N_c) == 1: # # q_av = np.tile(q_v, len(self.indices)) # q_xx = np.vstack([q_av]*len(self.indices)*3) # D_m += q_xx # Evaluate fourier sum phase_N = np.exp(-2.j * pi * np.dot(q_c, R_cN)) D_q = np.sum(phase_N[:, np.newaxis, np.newaxis] * D_N, axis=0) if modes: omega2_l, u_xl = la.eigh(D_q, UPLO='U') # Sort eigenmodes according to eigenvalues (see below) and # multiply with mass prefactor u_lx = (self.m_inv_x[:, np.newaxis] * u_xl[:, omega2_l.argsort()]).T.copy() u_kl.append(u_lx.reshape((-1, len(self.indices), 3))) else: omega2_l = la.eigvalsh(D_q, UPLO='U') # Sort eigenvalues in increasing order omega2_l.sort() # Use dtype=complex to handle negative eigenvalues omega_l = np.sqrt(omega2_l.astype(complex)) # Take care of imaginary frequencies if not np.all(omega2_l >= 0.): indices = np.where(omega2_l < 0)[0] if verbose: print('WARNING, %i imaginary frequencies at ' 'q = (% 5.2f, % 5.2f, % 5.2f) ; (omega_q =% 5.3e*i)' % (len(indices), q_c[0], q_c[1], q_c[2], omega_l[indices][0].imag)) omega_l[indices] = -1 * np.sqrt(np.abs(omega2_l[indices].real)) omega_kl.append(omega_l.real) # Conversion factor: sqrt(eV / Ang^2 / amu) -> eV s = units._hbar * 1e10 / sqrt(units._e * units._amu) omega_kl = s * np.asarray(omega_kl) if modes: return omega_kl, np.asarray(u_kl) return omega_kl
def update_prim_var_by_PALM(self, W_init=None, H_init=None, max_iter=1000, tol=1e-1, verbose=False): ''' This function alternatively updates the primal variables in a Gauss-Seidel fasion. Each update is performed using the proximal gradient method Input: k ------ the outer iteration number W_init ------ the initialization for W H_init ------ the initialization for H max_iter ------ the max number of iterations for PALM tol ------ the tolerance for stopping PALM ''' if W_init is None or H_init is None: raise ValueError( 'Error: inner iterations by PLAM are lack of initializations!') (ha, hb) = H_init.shape start_time = time.time() #H_j_pre, W_j_pre, H_j_cur, W_j_cur = np.asmatrix(np.copy(H_init)), np.asmatrix(np.copy(W_init)), np.asmatrix(np.copy(H_init)), np.asmatrix(np.copy(W_init)) H_j_pre, W_j_pre = H_init, W_init tmp = self.rho * self.all_1_mat + (self.nu - self.rho) * self.I_ha end_time = time.time() self.time_used += end_time - start_time for j in range(max_iter): # update H and W by proximal gradient method respectively start_time = time.time() Hessian = 2 * W_j_pre.transpose() * W_j_pre / self.n_factor + tmp #egenvals = LA.eigvalsh(Hessian) t = 0.51 * LA.eigvalsh(Hessian)[ha - 1] #t = 0.51 * LA.norm(Hessian, 'fro') grad_H_pre = Hessian * H_j_pre - 2 * W_j_pre.transpose( ) * self.data_mat / self.n_factor #H_j_cur = np.maximum(0, H_j_pre - grad_H_pre / t) H_j_cur = np.maximum(0, H_j_pre - grad_H_pre / t) Hessian = H_j_cur * H_j_cur.transpose() #c = 0.5 * LA.norm(Hessian, 'fro') c = 0.51 * LA.eigvalsh(Hessian)[ha - 1] grad_W_pre = W_j_pre * Hessian - self.data_mat * H_j_cur.transpose( ) #W_j_cur = np.maximum(0, W_j_pre - grad_W_pre / c) if self.W_bound: W_j_cur = np.minimum(self.max_val, np.maximum(0, W_j_pre - grad_W_pre / c)) else: W_j_cur = np.maximum(0, W_j_pre - grad_W_pre / c) end_time = time.time() self.time_used += end_time - start_time # check the convergence H_j_change = LA.norm(H_j_cur - H_j_pre, 'fro') / LA.norm( H_j_pre, 'fro') W_j_change = LA.norm(W_j_cur - W_j_pre, 'fro') / LA.norm( W_j_pre, 'fro') # update the pres H_j_pre = np.asmatrix(np.copy(H_j_cur)) W_j_pre = np.asmatrix(np.copy(W_j_cur)) if W_j_change + H_j_change < tol: break return (W_j_cur, H_j_cur, j + 1)
def Heigenvalues(a, UPLO='L'): return linalg.eigvalsh(a, UPLO)
def count(self): evs = eigvalsh( self.matrix() ) non_zero_evs = [ v for v in evs if v > EPSILON ] return int(round( reduce(lambda x,y: x*y, non_zero_evs, 1) / (1 + len(non_zero_evs)) ))
#### compute the laplacian matrix lm = [[0 for row in range(N)] for col in range(N)] for j in range(N): for k in range(N): if j == k: lm[j][k] = 1 ######### for isolated nodes if degrees[j] == 0: lm[j][k] = 0 else: if inter_matrix[j][k] > 0: lm[j][k] = -1 * inter_matrix[j][k] * 1.0 / math.sqrt( degrees[j] * degrees[k]) tmp_eig = LA.eigvalsh(lm) tmp_eig.sort() eigenvalues.append(tmp_eig) #### get the connectivity j = 0 while tmp_eig[j] < 0.001: j += 1 connectivity = tmp_eig[j] #### compute isolated nodes isolated_count = 0 for j in range(N): if degrees[j] == 0: isolated_count += 1
left_on = 0 right_on = 1 center_on = 0 initialize_on = 1 # define hamiltonian and do 2-to-1 blocking chi_b = 4 sX = np.array([[0, 1], [1, 0]]) sY = np.array([[0, -1j], [1j, 0]]) sZ = np.array([[1, 0], [0, -1]]) ham_s = np.real(np.kron(sX, sX) + np.kron(sY, sY)) ham_init = (0.5 * np.kron(np.eye(8), np.kron(ham_s, np.eye(2))) + np.kron(np.eye(4), np.kron(ham_s, np.eye(4))) + 0.5 * np.kron(np.eye(2), np.kron(ham_s, np.eye(8)))) bias_shift = max(LA.eigvalsh(ham_init)) - min(LA.eigvalsh(ham_init)) if initialize_on: # initialize tensors u = [0] * n_levels w = [0] * n_levels u[0] = np.eye(chi_b**2, chi_b**2).reshape(chi_b, chi_b, chi_b, chi_b) w[0] = orthog(np.random.rand(chi_b, chi_b, chi), pivot=2) for k in range(n_levels - 1): u[k + 1] = (np.eye(chi**2, chi_p**2)).reshape(chi, chi, chi_p, chi_p) w[k + 1] = orthog(np.random.rand(chi_p, chi_p, chi), pivot=2) v = np.random.rand(chi, chi, chi, 1) v = v / LA.norm(v) else:
def _p_pure_sparse(self, state, sub_sys_A, return_rdm=None, sparse_diag=True, maxiter=None): partial_trace_args = dict(sub_sys_A=sub_sys_A, sparse=True, enforce_pure=True) N_A = len(sub_sys_A) N_B = self.N - N_A rdm_A = None rdm_B = None if return_rdm is None: if N_A <= N_B: partial_trace_args["return_rdm"] = "A" rdm = self._partial_trace(state, **partial_trace_args) else: partial_trace_args["return_rdm"] = "B" rdm = self._partial_trace(state, **partial_trace_args) elif return_rdm == 'A' and N_A <= N_B: partial_trace_args["return_rdm"] = "A" rdm_A = self._partial_trace(state, **partial_trace_args) rdm = rdm_A elif return_rdm == 'B' and N_B <= N_A: partial_trace_args["return_rdm"] = "B" rdm_B = self._partial_trace(state, **partial_trace_args) rdm = rdm_B else: partial_trace_args["return_rdm"] = "both" rdm_A, rdm_B = self._partial_trace(state, **partial_trace_args) if N_A < N_B: rdm = rdm_A else: rdm = rdm_B if sparse_diag and rdm.shape[0] > 16: def get_p_patchy(rdm): n = rdm.shape[0] p_LM = eigsh(rdm, k=n // 2 + n % 2, which="LM", maxiter=maxiter, return_eigenvectors=False) # get upper half p_SM = eigsh(rdm, k=n // 2, which="SM", maxiter=maxiter, return_eigenvectors=False) # get lower half p = _np.concatenate( (p_LM[::-1], p_SM)) + _np.finfo(p_LM.dtype).eps return p if _sp.issparse(rdm): p = get_p_patchy(rdm) p = p.reshape((1, -1)) else: p_gen = [get_p_patchy(dm) for dm in rdm[:]] p = _np.stack(p_gen) else: if _sp.issparse(rdm): p = eigvalsh(rdm.todense())[::-1] + _np.finfo(rdm.dtype).eps p = p.reshape((1, -1)) else: p_gen = [ eigvalsh(dm.todense())[::-1] + _np.finfo(dm.dtype).eps for dm in rdm[:] ] p = _np.stack(p_gen) return p, rdm_A, rdm_B
def Berry_path_plot(self, angle, N, typ, ax=None): """ Plot Berry curvature as colormap of bands :param angle: field shift angle for K-path :param N: number of evaluation points :param typ: which bands to color, choose from: 'middle','all' & 'occ/unocc' :param ax: axis object if applicable, otherwise function will create one :return: Plot of Berry curvature """ if self.Hamiltonian.angle == 0: kx, ky = path_theta_0(N) elif self.Hamiltonian.angle == np.pi / 6: kx, ky = path_theta_pi_6(N) else: kx, ky = path(N) ev = [] bc = [] bc_o = np.zeros(len(kx)) bc_u = np.zeros(len(kx)) for i in range(len(kx)): ev.append(eigvalsh(H.get_Hamiltonian(kx[i], ky[i]))) if typ == 'middle': bc.append( inv.berry_curvature_middle_states(np.array([kx[i], ky[i]]), 0.05)) elif typ == 'all': bc.append( inv.berry_curvature_per_band(np.array([kx[i], ky[i]]), 0.05)) else: bc_o[i] = inv.berry_curvature(np.array([kx[i], ky[i]]), 0.05) bc_u[i] = inv.berry_curvature_unoccupied( np.array([kx[i], ky[i]]), 0.05) bc = np.array(bc) ev = np.array(ev) ev = ev.reshape((3 * N, len(H.lattice.orb))) axis = np.arange(0, 3 * N, 1) CMAP = plt.get_cmap('coolwarm') s = len(axis) def myCMAP(x): return CMAP((s * x + 1) / 2) if not ax: fig = plt.figure(figsize=(16, 8)) ax0 = fig.add_subplot(1, 1, 1) else: ax0 = ax if typ == 'middle': colors = [myCMAP(v) for v in bc] # if i == 1 or i == 2: # colors = 'lightgrey' ax0.scatter(axis, ev[:, 1], c=colors, s=4.0, rasterized=True) ax0.scatter(axis, ev[:, 2], c=colors, s=4.0, rasterized=True) elif typ == 'all': for i in range(len(bc[0, :])): colors = [myCMAP(v) for v in bc[:, i]] # if i == 1 or i == 2: # colors = 'lightgrey' ax0.scatter(axis, ev[:, i], c=colors, s=4.0, rasterized=True) else: colors_o = [myCMAP(v) for v in bc_o] colors_u = [myCMAP(v) for v in bc_u] ax0.scatter(axis, ev[:, 1], c=colors_o, s=4.0, rasterized=True) ax0.scatter(axis, ev[:, 2], c=colors_u, s=4.0, rasterized=True) ax0.set_title('Plot along path in k-space', fontsize=10) ax0.set_xticks([0, N, 2 * N, 3 * N]) ax0.set_xticklabels(["$\Gamma$", "$K$", "$K'$", "$\Gamma$"]) ax0.set_ylabel("$\epsilon_{k}$") ax0.set_yticks([-5, 0, 5]) txt = 'B = {}'.format(B) ax0.text(1.5 * N, 5.5, txt, ha="center", va="center", bbox=dict(boxstyle="square", ec='black', fc='white')) if not ax: ax0.show()
En2, A, sWeight, B = dmrg_two_sites(A, WL, M, WR, chi, numsweeps=OPTS_numsweeps, dispon=OPTS_dispon, updateon=OPTS_updateon, maxit=OPTS_maxit, krydim=OPTS_krydim) #### Compare with exact results (computed from free fermions) from numpy import linalg as LA import matplotlib.pyplot as plt H = np.diag(np.ones(Nsites - 1), k=1) + np.diag(np.ones(Nsites - 1), k=-1) D = LA.eigvalsh(H) EnExact = 2 * sum(D[D < 0]) ##### Plot results plt.figure(1) plt.yscale('log') plt.plot(range(len(En1)), En1 - EnExact, 'b', label="chi = 16") plt.plot(range(len(En2)), En2 - EnExact, 'r', label="chi = 32") plt.legend() plt.title('DMRG for XX model') plt.xlabel('Update Step') plt.ylabel('Ground Energy Error') plt.show() ''' def gs_Arnoldi(psivec, A_funct, functArgs, maxit=2, krydim=4): col_vec = cytnx.zeros([len(psivec), krydim +1]).astype(cytnx.Type.ComplexDouble)
iz, ip, im = get_spin_ops(imult) Hhfi = np.kron(iz, sz) + 0.5 * (np.kron(ip, sm) + np.kron(im, sp)) Hhfi *= A H = ge * muB * B * np.kron(np.identity( imult), sz) - gn * muN * B * np.kron(iz, np.identity(2)) + Hhfi return H gausstoau = 1. / 2.35e+9 bfield = np.linspace(0, 2000, num=150, dtype=float) evalsLi = np.empty((len(bfield), ILimult * 2), dtype=float) evalsRb = np.empty((len(bfield), IRbmult * 2), dtype=float) for i in range(len(bfield)): print(i) evalsLi[i, :] = npl.eigvalsh( get_H(ALi, gnLi, ILimult, bfield[i] * gausstoau)) / mhztoau evalsRb[i, :] = npl.eigvalsh( get_H(ARb, gnRb, IRbmult, bfield[i] * gausstoau)) / mhztoau plt.clf() for i in range(ILimult * 2): plt.plot(bfield, evalsLi[:, i]) plt.savefig("li.png") plt.clf() for i in range(IRbmult * 2): plt.plot(bfield, evalsRb[:, i]) plt.savefig("rb.png")
def laggauss(deg): """ Gauss-Laguerre quadrature. Computes the sample points and weights for Gauss-Laguerre quadrature. These sample points and weights will correctly integrate polynomials of degree :math:`2*deg - 1` or less over the interval :math:`[0, \\inf]` with the weight function :math:`f(x) = \\exp(-x)`. Parameters ---------- deg : int Number of sample points and weights. It must be >= 1. Returns ------- x : ndarray 1-D ndarray containing the sample points. y : ndarray 1-D ndarray containing the weights. Notes ----- .. versionadded:: 1.7.0 The results have only been tested up to degree 100 higher degrees may be problematic. The weights are determined by using the fact that .. math:: w_k = c / (L'_n(x_k) * L_{n-1}(x_k)) where :math:`c` is a constant independent of :math:`k` and :math:`x_k` is the k'th root of :math:`L_n`, and then scaling the results to get the right value when integrating 1. """ ideg = pu._deprecate_as_int(deg, "deg") if ideg <= 0: raise ValueError("deg must be a positive integer") # first approximation of roots. We use the fact that the companion # matrix is symmetric in this case in order to obtain better zeros. c = np.array([0]*deg + [1]) m = lagcompanion(c) x = la.eigvalsh(m) # improve roots by one application of Newton dy = lagval(x, c) df = lagval(x, lagder(c)) x -= dy/df # compute the weights. We scale the factor to avoid possible numerical # overflow. fm = lagval(x, c[1:]) fm /= np.abs(fm).max() df /= np.abs(df).max() w = 1/(fm * df) # scale w to get the right value, 1 in this case w /= w.sum() return x, w
def fg(k): # minimize the gap es = lg.eigvalsh(hkgen(k)) # eigenvalues return np.min(es[es>0.])-np.max(es[es<0.]) # return gap
bfield = np.linspace(0, 2000, num=150, dtype=float) stotvals = np.arange(-4.5, 4.51, step=0.5) scount = np.zeros(len(stotvals), dtype=int) evals = np.empty((len(stotvals)), dtype=object) SzLi = np.kron(get_spin_ops(ILimult)[0], np.identity(2)) + np.kron(np.identity(ILimult), get_spin_ops(2)[0]) SzRb = np.kron(get_spin_ops(IRbmult)[0], np.identity(2)) + np.kron(np.identity(IRbmult), get_spin_ops(2)[0]) Sztot = np.kron(SzLi, np.identity(IRbmult*2)) + np.kron(np.identity(ILimult*2), SzRb) Sdiag = np.diagonal(Sztot) for i in range(1, len(bfield)): print(i) H = np.kron(get_H(ALi, gnLi, ILimult, bfield[i] * gausstoau), np.identity(IRbmult*2)) H += np.kron(np.identity(ILimult*2), get_H(ARb, gnRb, IRbmult, bfield[i] * gausstoau)) for s in range(len(stotvals)): egvs, vecs = npl.eigvalsh(hblock) egvs /= mhztoau spins = np.diagonal(vecs.transpose() @ Sztot @ vecs) if i == 0: evals[s] = np.zeros((len(bfield), len(egvs)), dtype=float) scount[s] = len(egvs) evals[s][i, :] = egvs else: if i == 0: evals[s] = np.zeros((len(bfield), 0), dtype=float) scount[s] = 0 print(scount) for s in range(len(stotvals)): plt.clf()
def norm(matrix): e = linalg.eigvalsh(matrix) size = len(e) e = NP.sort(e) norm = e[size - 1] return norm
def fg(k): # minimize the gap es1 = lg.eigvalsh(hkgen(k)) # eigenvalues es2 = lg.eigvalsh(hkgen(k)) # eigenvalues return np.min(es1[es1>0.])-np.max(es2[es2<0.]) # return gap
avgVariable_26 *= 1.0/numRows avgVariable_27 *= 1.0/numRows # Reynolds stresses stuff # Calculate Reynolds stress tensor reynolds_stress_tensor = matrix( [[ avgVariable_8 , avgVariable_9 , avgVariable_10 ],[ avgVariable_9 , avgVariable_11 , avgVariable_12 ],[ avgVariable_10 , avgVariable_12 , avgVariable_13 ]]) # Calculate trace trace = avgVariable_8 + avgVariable_11 + avgVariable_13 + 1.0e-20 # Calculate anisotropy tensor anisotropy_tensor = (1.0/trace)*reynolds_stress_tensor - (1.0/3.0)*matrix( [[ 1.0 , 0.0 , 0.0 ],[ 0.0 , 1.0 , 0.0 ],[ 0.0 , 0.0 , 1.0 ]]) # Calculate tensor eigenvalues eigenvalues_anisotropy_tensor = linalg.eigvalsh(anisotropy_tensor) sorted_eigenvalues_anisotropy_tensor = sorted(eigenvalues_anisotropy_tensor, reverse=True) # Calculate barycentric map points x = x1c*( sorted_eigenvalues_anisotropy_tensor[0] - sorted_eigenvalues_anisotropy_tensor[1] ) + x2c*( 2.0*sorted_eigenvalues_anisotropy_tensor[1] - 2.0*sorted_eigenvalues_anisotropy_tensor[2] ) + x3c*( 3.0*sorted_eigenvalues_anisotropy_tensor[2] + 1 ) # Create string string = '%f %f %f %f %f' %(avgVariable_25, avgVariable_26, avgVariable_27, x.item(0), x.item(1)) print(string) outputFile.write(string) outputFile.write('\n') # Close input file for processing inputFile.close()
# 1) Compute the arithmetic center of the atomic coordinates. center = mol.coordinates.mean(axis=0) # Without the axis=0 argument, the average over all X, Y and Z components would # be computed. Now it just computes the averages for each column. axis=1 would # refer to averaging over rows. # 2) Move the arithmetic center of the coordinates to the origin. The same # comments from the b_com.py apply. centered = mol.coordinates - mol.coordinates.mean(axis=0) # 3) Compute the covariance matrix of the centered coordinates. covar = dot(centered.transpose(), centered) / mol.size # 4) Compute the eigenvalues of the symmetric covariance matrix. evals = eigvalsh(covar) # 5) The spread along the three eigenvectors is computed as the standard deviation # of the atomic coordinates along that direction: c, b, a = sqrt(evals) print("Spread along the long axis [A]:", a / angstrom) print("Spread along the intermediate axis [A]:", b / angstrom) print("Spread along the short axis [A]:", c / angstrom) # 6) Test in which category this shape belongs. The factor R is set to 1.5. R = 1.5 if b < R * c: if a < R * b: shape = 'equant' # sphere-like else: shape = 'prolate' # sigar-like
# for i in range(N): # newline = nodeids[i] + ': ' # for j in range(N): # if i == j: # lm[i][j] = degrees[i] # else: # if am[i][j] > 0: # lm[i][j] = -1*am[i][j] # # newline += str(lm[i][j]) + ' ' # newline += '\n' # outf.writelines(newline) # outf.writelines('\n') ### Now we can compute the eigen values of the laplacian matrix eigenvals = LA.eigvalsh(lm) eigenvals.sort() newline = '' for i in range(N): newline += str(eigenvals[i]) + ' ' newline += '\n\n' outf_eig.writelines(newline) ######################################################################## ### add a label about the PRR, isolated nodes, avg prnt size, number of ### shortcuts, and smallest non-zero eigenvalue for each cycle # connectivity = 0 # i = 0 # while eigenvals[i] < 0.001: # i += 1
ax12.plot(dmm2.E, prop_dmm2, '*-', label='DMM2 prop') ax12.legend(numpoints = 1) ''' exact_dmm = np.empty(numobjects, dtype=object) prop_dmm = np.empty(numobjects, dtype=object) fig1 = plt.figure(1) fig1.clf() ax1 = fig1.add_subplot(111) ax1.set_xlabel('Population') ax1.set_ylabel('Energy') ax1.set_ylim([-0.2, 1.2]) for i in range(numobjects): dmm_list[i].propagate_beta1(numsteps) prop_dmm[i] = linalg.eigvalsh(dmm_list[i].rhocopy)[::-1] exact_dmm[i] = dmm_list[i].get_exact_pop() ax1.plot(dmm_list[i].E, exact_dmm[i], '*-', label='Exact') ax1.plot(dmm_list[i].E, prop_dmm[i], '*-', label='Prop') ax1.set_title("Population of DMM at $\\beta = %.2f$, $\mu = %.2f$" % (dmm_list[0].beta, dmm_list[0].mu)) ax1.legend(numpoints = 1) ########################################################################### # # Compare RK4 methods # ########################################################################### ''' dmm1.beta = 0.0 dmm1.rk4(dmm1.deriv, numsteps)
def check_rdm(rdm): assert np.trace(rdm)==pytest.approx(1.0) assert np.trace(rdm@rdm)<=1.0+1e-15 assert rdm==pytest.approx(rdm.T.conj()) assert (la.eigvalsh(rdm)>-1e-15).all()
def blubb(t, t1, t2): N = 256 #construct unit cell from intra and inter h hintra1 = np.array([[0, t], [t, 0]]) hintra2 = np.array([[0, t2], [t2, 0]]) hinter1 = np.array([[t, 0], [0, t1]]) hinter2 = hinter1.T #stack little hs to get unit cell intras M1 = np.hstack((hintra1, hinter1)) M2 = np.hstack((hinter2, hintra2)) M = np.vstack((M1, M2)) heinheitintra = np.kron(np.eye(2), M) #build stack for inters for 8x8 unit cell hinter3 = np.array([[t1, 0], [0, t]]) Z = np.zeros((2, 2)) K1 = np.hstack((Z, Z)) K2 = np.hstack((hinter3, Z)) K = np.vstack((K1, K2)) K_T = K.T heinheitinter1 = np.kron(np.eye(2, k=+1), K) heinheitinter2 = np.kron(np.eye(2, k=-1), K_T) #put together to get h einheit heinheit = heinheitintra + heinheitinter1 + heinheitinter2 # print(heinheit) #construct inter for chi the big hamiltonian ribbon c1 = np.array([[0, 0], [t2, 0]]) c2 = np.array([[0, 0], [t, 0]]) chi1 = np.hstack((c1, Z)) chi2 = np.hstack((Z, c2)) chi = np.vstack((chi1, chi2)) Z2 = np.zeros((4, 4)) heinheitinter = np.vstack((np.hstack((chi, Z2)), np.hstack((Z2, chi)))) # print(heinheitinter) #now put it all together + boundary conditions H = np.kron(np.eye(N), heinheit) H += np.kron(np.eye(N, k=1), heinheitinter.T) H += np.kron(np.eye(N, k=-1), heinheitinter) H += np.kron(np.eye(N, k=N - 1), heinheitinter.T) H += np.kron(np.eye(N, k=-N + 1), heinheitinter) # print(H) hmfft = (1 / N) * fftshift(mfft(mfft(H.conj().T, 8).conj().T, 8)) # print(hmfft) eigenwerte = [] for l in range(N): block = hmfft[l * 8:8 + l * 8:, l * 8:8 + l * 8:] eigenwerte.append(LA.eigvalsh(block)) # print(eigenwerte) k = np.linspace(-np.pi, np.pi, N) y = np.array(eigenwerte) # define dos k2 = np.linspace(-np.pi, np.pi, N) e = np.linspace(-5, 5, N) eta = 0.1 ew = y.flatten() def delta_1(ew, e): return (1 / N) * np.sum((1 / math.pi) * (eta / (eta**2 + (e - ew)**2))) def delta_2(ew, e): return (1 / N) * np.sum((1 / (eta * math.sqrt(math.pi))) * np.exp( (-(e - ew)**2) / (eta**2))) lorenz_liste = [] gauss_liste = [] for i in e: lorenz_liste.append(delta_1(ew, i)) for l in e: gauss_liste.append(delta_2(ew, l)) plt.subplot(1, 2, 1) plt.plot(k, y) plt.xlabel('k') plt.ylabel('E') plt.subplot(1, 2, 2) plt.xlabel('dos') plt.ylabel('E') plt.plot(lorenz_liste, e) plt.plot(gauss_liste, e) plt.show()
# ----------------- # define hamiltonian and do 2-to-1 blocking chi_b = 4 sX = np.array([[0, 1], [1, 0]]) sY = np.array([[0, -1j], [1j, 0]]) sZ = np.array([[1, 0], [0, -1]]) ham_s = np.real(np.kron(sX, sX) + np.kron(sY, sY)) # ham_s = (-np.kron(sX, sX) + 0.5 * np.kron(np.eye(2), sZ) + # 0.5 * np.kron(np.eye(2), sZ)) ham_temp = (0.5 * np.kron(np.eye(8), np.kron(ham_s, np.eye(2))) + np.kron(np.eye(4), np.kron(ham_s, np.eye(4))) + 0.5 * np.kron(np.eye(2), np.kron(ham_s, np.eye(8)))) ham_init = BT.fromdense([ind_chib1] * 3 + [ind_chib0] * 3, ham_temp.reshape([chi_b] * 6)) bias_shift = max(LA.eigvalsh(ham_temp)) - min(LA.eigvalsh(ham_temp)) ham = [0] * (n_levels + 1) ham[0] = ham_init.copy() if initialize_on: # initialize tensors u = [0] * n_levels w = [0] * n_levels utemp = np.eye(chi_b**2, chi_b**2).reshape(chi_b, chi_b, chi_b, chi_b) u[0] = BT.fromdense([ind_chib1] * 2 + [ind_chib0] * 2, utemp) w[0] = BT.randn([ind_chib1] * 2 + [ind_chib0], dtype='float64') for k in range(n_levels - 1): utemp = (np.eye(chi**2, chi_p**2)).reshape(chi, chi, chi_p, chi_p) u[k + 1] = BT.fromdense([ind_chi1] * 2 + [ind_chip0] * 2, utemp) w[k + 1] = BT.randn([ind_chip1] * 2 + [ind_chi0], dtype='float64')