def align_magnetism(m, vectors): """ Rotates a matrix, to align its components with the direction of the magnetism """ if not len(m) == 2 * len(vectors): # stop if they don't have # compatible dimensions raise # pauli matrices from scipy.sparse import csc_matrix, bmat sx = csc_matrix([[0.0, 1.0], [1.0, 0.0]]) sy = csc_matrix([[0.0, -1j], [1j, 0.0]]) sz = csc_matrix([[1.0, 0.0], [0.0, -1.0]]) n = len(m) / 2 # number of sites R = [[None for i in range(n)] for j in range(n)] # rotation matrix from scipy.linalg import expm # exponenciate matrix for (i, v) in zip(range(n), vectors): # loop over sites vv = np.sqrt(v.dot(v)) # norm of v if vv > 0.000001: # if nonzero scale u = v / vv else: # if zero put to zero u = np.array([0.0, 0.0, 0.0]) # rot = u[0]*sx + u[1]*sy + u[2]*sz uxy = np.sqrt(u[0] ** 2 + u[1] ** 2) # component in xy plane phi = np.arctan2(u[1], u[0]) theta = np.arctan2(uxy, u[2]) r1 = phi * sz / 2.0 # rotate along z r2 = theta * sy / 2.0 # rotate along y # a factor 2 is taken out due to 1/2 of S rot = expm(1j * r2) * expm(1j * r1) R[i][i] = rot # save term R = bmat(R) # convert to full sparse matrix mout = R * csc_matrix(m) * R.H # rotate matrix return mout.todense() # return dense matrix
def _solve_numericaly(self, u, x0, t, t_list, t0, dps=2): """ returns the numeric evaluation of the system for input u, know state x0 at time t0 and times t_list """ result = [] for t_i in t_list: # we use the arbitrary precision module mpmath for numercial evaluation of the matrix exponentials first = ( np.array(np.array(self.represent[2]), np.float) .dot(expm(np.array(np.array((self.represent[0] * (t_i - t0)).evalf()), np.float))) .dot(np.array(np.array(x0), np.float)) ) second = np.array(np.array((self.represent[3] * u.subs(t, t_i)).evalf()), np.float) integrand = ( lambda tau: np.array(np.array(self.represent[2]), np.float) .dot(expm(np.array(np.array((self.represent[0] * (t_i - tau)).evalf()), np.float))) .dot(np.array(np.array(self.represent[1]), np.float)) .dot(np.array(np.array(u.subs(t, tau).evalf()), np.float)) ) # the result must have the same shape as D: integral = zeros(self.represent[2].rows, 1) # Loop through every entry and evaluate the integral using mpmath.quad() for row_idx in xrange(self.represent[2].rows): integral[row_idx, 0] = quad(lambda x: integrand(x)[row_idx, 0], t0, t_i)[0] result.append(Matrix(first) + Matrix(second) + integral) # return sum of results return result
def make_propagators(pb=0.0, kex=0.0, dw=0.0, r_coxy=5.0, dr_coxy=0.0, r_nz=1.5, r_2coznz=0.0, etaxy=0.0, etaz=0.0, j_nco=0.0, dj_nco=0.0, cs_offset=0.0): w1 = 2.0 * pi / (4.0 * pwco90) l_free, l_w1x, l_w1y = compute_liouvillians(pb=pb, kex=kex, dw=dw, r_coxy=r_coxy, dr_coxy=dr_coxy, r_nz=r_nz, r_2coznz=r_2coznz, etaxy=etaxy, etaz=etaz, j_nco=j_nco, dj_nco=dj_nco, cs_offset=cs_offset, w1=w1) p_equil = expm(l_free * time_equil) p_taucc = expm(l_free * taucc) p_neg = expm(l_free * -2.0 * pwco90 / pi) p_90py = expm((l_free + l_w1y) * pwco90) p_90my = expm((l_free - l_w1y) * pwco90) p_180px = P180X # Perfect 180 for CPMG blocks p_180py = matrix_power(p_90py, 2) p_180my = matrix_power(p_90py, 2) ps = (p_equil, p_taucc, p_neg, p_90py, p_90my, p_180px, p_180py, p_180my) return l_free, ps
def _learnStep(self): """ Main part of the algorithm. """ I = eye(self.numParameters) self._produceSamples() utilities = self.shapingFunction(self._currentEvaluations) utilities /= sum(utilities) # make the utilities sum to 1 if self.uniformBaseline: utilities -= 1./self.batchSize samples = array(map(self._base2sample, self._population)) dCenter = dot(samples.T, utilities) covGradient = dot(array([outer(s,s) - I for s in samples]).T, utilities) covTrace = trace(covGradient) covGradient -= covTrace/self.numParameters * I dA = 0.5 * (self.scaleLearningRate * covTrace/self.numParameters * I +self.covLearningRate * covGradient) self._lastLogDetA = self._logDetA self._lastInvA = self._invA self._center += self.centerLearningRate * dot(self._A, dCenter) self._A = dot(self._A, expm(dA)) self._invA = dot(expm(-dA), self._invA) self._logDetA += 0.5 * self.scaleLearningRate * covTrace if self.storeAllDistributions: self._allDistributions.append((self._center.copy(), self._A.copy()))
def transfer_f(dw,aas,aai,eps,deltaw,f): """ Args: dw: size of the grid spacing aas=relative slowness of the signal mode aai=relative slowness of the idler mode lnl=inverse of the strength of the nonlinearity deltaw: specifies the size of the frequency grid going from -deltaw to deltaw for each frequency f: shape of the pump function """ ddws=np.arange(-deltaw-dw/2,deltaw+dw/2,dw) deltaks=aas*ddws ddwi=np.arange(-deltaw-dw/2,deltaw+dw/2,dw) deltaki=aai*ddwi ds=np.diag(deltaks) di=np.diag(deltaki) def ff(x,y): return f(x+y) v=eps*(dw)*ff(ddwi[:,None],ddws[None,:]) G=1j*np.concatenate((np.concatenate((ds,v),axis=1),np.concatenate((-v,-di),axis=1)),axis=0) z=1; dsi=np.concatenate((deltaks,-deltaki),axis=0) U0=linalg.expm(-1j*np.diag(dsi)*z/2) GG=np.dot(np.dot(U0,linalg.expm(G)),U0) n=len(ddws) return (GG[0:n,0:n],GG[n:2*n,0:n],GG[0:n,n:2*n],GG[n:2*n,n:2*n])
def make_random_su(N): A = spla.expm(2 * np.pi * 1j * npr.random((N, N))) B = (A - np.trace(A) * np.identity(N) / N) C = 0.5 * (B - np.conj(B.T)) return spla.expm(C)
def Iterate_LS_Strain(xys0_pix, xys1_pix, num = 10): solve = Get_LS_DGradient(xys0_pix, xys1_pix) for j in range(0,num): xy_pix = Simulate_Shifted_Spots(xys0_pix, linalg.expm(solve), det2lab_mat) dsolve = Get_LS_DGradient(xy_pix, xys1_pix) solve = solve+dsolve return linalg.expm(solve)
def Char_Gate(NV,res ,B_field=400): """ Characterize the gate, take the NV centre, the resonance paramters and the Bfield as input returns the fidelity with which an x-gate can be implemented. """ #data = np.loadtxt("NV_Sim_8.dat") #Placeholder data to test the script #NV = np.vstack((data[:,3],data[:,4])) #physical constants gamma_c = 1.071e3 #g-factor for C13 in Hz/G #Model parameters omega_larmor = 2*np.pi*gamma_c*B_field tau_larmor = 2*np.pi/omega_larmor tau = res[0] n_pulses = int(res[1]*2) #So that we do a pi -pulse Ix = 0.5 * np.array([[0,1],[1,0]]) Iz = 0.5* np.array([[1,0],[0,-1]]) H0 = (omega_larmor)*Iz exH0 =linalg.expm(-1j*H0*tau) S_final =1 for idC in range(np.shape(NV)[1]): A= 2*np.pi*NV[0,idC] B= 2*np.pi*NV[1,idC] #Converts to radial frequency in Hz/G H1 = (A+omega_larmor) *Iz +B*Ix exH1 = linalg.expm(-1j*H1*tau) V0 = exH0.dot(exH1.dot(exH1.dot(exH0))) V1 = exH1.dot(exH0.dot(exH0.dot(exH1))) S = np.real(np.trace(np.dot(np.linalg.matrix_power(V0,n_pulses),np.linalg.matrix_power(V1,n_pulses)))/2) S_final = S_final *S F = (1-(S_final+1)/2) #Converting from probability of measuring +X to fidelity of -X (x-rotation) return F
def ghz_simult_trajectory(stages): rhos = [] for stage in stages: U = np.eye(8, dtype=complex) I = pyle.tomo.sigmaI X = pyle.tomo.sigmaX Y = pyle.tomo.sigmaY couple = (pyle.tensor((X,X,I)) + pyle.tensor((Y,Y,I)) + pyle.tensor((X,I,X)) + pyle.tensor((Y,I,Y)) + pyle.tensor((I,X,X)) + pyle.tensor((I,Y,Y))) / 2.0 if stage > 0: fraction = np.clip(stage-0, 0, 1) H = -1j * (np.pi/2)/2 * (pyle.tensor((Y,I,I)) + pyle.tensor((I,Y,I)) + pyle.tensor((I,I,Y))) U = np.dot(expm(fraction * H), U) if stage > 1: fraction = np.clip(stage-1, 0, 1) H = -1j * np.pi/2 * couple U = np.dot(expm(fraction * H), U) if stage > 2: fraction = np.clip(stage-2, 0, 1) H = -1j * (np.pi/2)/2 * (pyle.tensor((X,I,I)) + pyle.tensor((I,X,I)) + pyle.tensor((I,I,X))) U = np.dot(expm(fraction * H), U) psi0 = np.array([1,0,0,0,0,0,0,0], dtype=complex) psi_th = np.dot(U, psi0) rho_th = pyle.ket2rho(psi_th) rhos.append(rho_th) return np.array(rhos)
def pdf(self, x): """ probability density function """ if not np.isscalar(x): x = np.asarray(x) res = np.zeros_like(x) nz = (x > 0) if np.any(nz): if self.method == 'sum': factor = np.exp(-x[nz, None] * self.rates[..., :]) \ / self.rates[..., :] res[nz] = np.sum(self._terms[..., :] * factor, axis=1) else: Theta = (np.diag(-self.rates, 0) + np.diag(self.rates[:-1], 1)) for i in np.flatnonzero(nz): res.flat[i] = \ 1 - linalg.expm(x.flat[i]*Theta)[0, :].sum() elif x == 0: res = 0 else: if self.method == 'sum': factor = np.exp(-x*self.rates)/self.ratesx res[nz] = np.sum(self._terms * factor) else: Theta = np.diag(-self.rates, 0) + np.diag(self.rates[:-1], 1) res = 1 - linalg.expm(x*Theta)[0, :].sum() return res
def linear_ode_discretation(F, L=None, Q=None, dt=1): n = F.shape[0] if L is None: L = eye(n) if Q is None: Q = zeros((n,n)) A = expm(F*dt) phi = zeros((2*n, 2*n)) phi[0:n, 0:n] = F phi[0:n, n:2*n] = L.dot(Q).dot(L.T) phi[n:2*n, n:2*n] = -F.T zo = vstack((zeros((n,n)), eye(n))) CD = expm(phi*dt).dot(zo) C = CD[0:n,:] D = CD[n:2*n,:] q = C.dot(inv(D)) return (A, q)
def make_propagators(pb=0.0, kex=0.0, dw=0.0, r_hxy=5.0, dr_hxy=0.0, r_cz=1.5, r_2hzcz=0.0, etaxy=0.0, etaz=0.0, j_hc=0.0, cs_offset=0.0): w1 = 2.0 * pi / (4.0 * pw) l_free, l_w1x, l_w1y = compute_liouvillians( pb=pb, kex=kex, dw=dw, r_hxy=r_hxy, dr_hxy=dr_hxy, r_cz=r_cz, r_2hzcz=r_2hzcz, etaxy=etaxy, etaz=etaz, j_hc=j_hc, cs_offset=cs_offset, w1=w1 ) p_neg = expm(l_free * -2.0 * pw / pi) p_90px = expm((l_free + l_w1x) * pw) p_90py = expm((l_free + l_w1y) * pw) p_90mx = expm((l_free - l_w1x) * pw) p_180py = matrix_power(p_90py, 2) p_180pmx = 0.5 * (matrix_power(p_90px, 2) + matrix_power(p_90mx, 2)) ps = p_neg, p_90px, p_90py, p_90mx, p_180py, p_180pmx return l_free, ps
def discretize(F,G,Q,Ts): Phi = sp_linalg.expm(F*Ts) # Control matrix Lambda, not to be used L = np.zeros((F.shape[0],1)) A_z = np.zeros((L.shape[1], F.shape[1]+L.shape[1])) A1 = np.vstack((np.hstack((F,L)),A_z)) Loan1 = sp_linalg.expm(A1*Ts) Lambda = Loan1[0:L.shape[0], F.shape[1]:F.shape[1]+L.shape[1]] # Covariance Qc = symmetrize(np.dot(G, np.dot(Q, G.T))) dim = F.shape[0] A2 = np.vstack((np.hstack((-F, Qc)), np.hstack((np.zeros((dim,dim)), F.T)))) Loan2 = sp_linalg.expm(A2*Ts) G2 = Loan2[0:dim, dim:2*dim] F3 = Loan2[dim:2*dim, dim:2*dim] # Calculate Gamma*Gamma.T Qd = symmetrize(np.dot(F3.T, G2)) L = np.linalg.cholesky(Qd) return Phi, Qd, L
def test_padecases_float(self): # test single-precision cases a1 = eye(3, dtype=float)*1e-1; e1 = exp(1e-1)*eye(3) a2 = eye(3, dtype=float); e2 = exp(1.0)*eye(3) a3 = eye(3, dtype=float)*10; e3 = exp(10.)*eye(3) assert_array_almost_equal(expm(a1),e1) assert_array_almost_equal(expm(a2),e2) assert_array_almost_equal(expm(a3),e3)
def test_consistency(self): a = array([[0.,1],[-1,0]]) assert_array_almost_equal(expm(a), expm2(a)) assert_array_almost_equal(expm(a), expm3(a)) a = array([[1j,1],[-1,-2j]]) assert_array_almost_equal(expm(a), expm2(a)) assert_array_almost_equal(expm(a), expm3(a))
def test_QobjExpmExplicitDense(): "Qobj expm (explicit dense)" data = np.random.random( (15, 15)) + 1j * np.random.random((15, 15)) - (0.5 + 0.5j) A = Qobj(data) B = A.expm(method='dense') assert_((B.data.todense() - np.matrix(la.expm(data)) < 1e-10).all()) B = A.expm(method='scipy-delse') assert_((B.data.todense() - np.matrix(la.expm(data)) < 1e-10).all())
def KPMF(input_matrix, approx=50, iterations=30, learning_rate=.001, adjacency_width=5, adjacency_strength=.5): A = input_matrix Z = np.asarray(A > 0,dtype=np.int) A1d = np.ravel(A) mean = np.mean(A1d) A = A-mean K = approx R = itr = iterations l = learning_rate N = A.shape[0] M = A.shape[1] U = np.random.randn(N,K) V = np.random.randn(K,M) #KPMF using gradient descent as per paper #Kernelized Probabilistic Matrix Factorization: Exploiting Graphs and Side Information #T. Zhou, H. Shan, A. Banerjee, G. Sapiro #Using diffusion kernel #U are the rows, we use an adjacency matrix CU to reprent connectivity #This matrix connects rows +-adjacency_width #V are the columns, connected columns are CV #Operate on graph laplacian L, which is the degree matrix D - C #Applying the diffusion kernel to L, this forms a spatial smoothness graph bw = adjacency_width #Use scipy.sparse.diags to generate band matrix with bandwidth = 2*adjacency_width+1 #Example of adjacency_width = 1, N = 4 #[1 1 0 0] #[1 1 1 0] #[0 1 1 1] #[0 0 1 1] print "Running KPMF with:" print "learning rate=" + `l` print "bandwidth=" + `bw` print "beta=" + `b` print "approximation rank=" + `K` print "iterations=" + `R` print "" CU = sp.diags([1]*(2*bw+1),range(-bw,bw+1),shape=(N,N)).todense() DU = np.diagflat(np.sum(CU,1)) CV = sp.diags([1]*(2*bw+1),range(-bw,bw+1),shape=(M,M)).todense() DV = np.diagflat(np.sum(CV,1)) LU = DU - CU LV = DV - CV beta = adjacency_strength KU = sl.expm(beta*LU) KV = sl.expm(beta*LV) SU = np.linalg.pinv(KU) SV = np.linalg.pinv(KV) for r in range(R): for i in range(N): for j in range(M): if Z[i,j] > 0: e = A[i,j] - np.dot(U[i,:],V[:,j]) U[i,:] = U[i,:] + l*(e*V[:,j] - np.dot(SU[i,:],U)) V[:,j] = V[:,j] + l*(e*U[i,:] - np.dot(V,SV[:,j])) A_ = np.dot(U,V) return A_+mean
def get_symmetry(self,x): """Return the symmetry operator""" if self.real: M = v2O(x,exp=self.discrete) if self.discrete: return M # return the operator else: return lg.expm(M) # return the operator else: M = v2U(x,exp=self.discrete) if self.discrete: return M # return the operator else: return lg.expm(1j*M) # return the operator
def test_consistency(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", DeprecationWarning) a = array([[0.,1],[-1,0]]) assert_array_almost_equal(expm(a), expm2(a)) assert_array_almost_equal(expm(a), expm3(a)) a = array([[1j,1],[-1,-2j]]) assert_array_almost_equal(expm(a), expm2(a)) assert_array_almost_equal(expm(a), expm3(a))
def gibbsstate(self): nb=self.p.nbar hbar=self.p.hbar kb=self.p.kb nu=self.p.nu T=hbar*nu/(kb*np.log((nb + 1.)/nb)) Z=np.trace(expm(-hbar*nu*self.ada/(kb*T))) result = np.kron(expm(-hbar*nu*self.ada/(kb*T)),[[0,0],[0,1]])/Z if result[2*(self.p.nmax+1)-1,2*(self.p.nmax+1)-1]>0.0001: print 'Warning: nmax may not be high enough for chosen value of nbar' return result
def get_plot_array(N_diploid, Nr, theta_values, Ns_values): """ Compute expected hitting times. Theta is 4*N*mu, and the units of time are 4*N*mu generations. @param N_diploid: diploid population size @param Nr: recombination rate @param theta_values: mutation rates @param Ns_values: selection values @return: arr[i][j] gives time for Ns_values[i] and theta_values[j] """ # set up the state space k = 4 M = multinomstate.get_sorted_states(2 * N_diploid, k) T = multinomstate.get_inverse_map(M) nstates = M.shape[0] lmcs = wfengine.get_lmcs(M) # precompute rate matrices R_rate = wfcompens.create_recomb(M, T) M_rate = wfcompens.create_mutation(M, T) # precompute a recombination probability matrix R_prob = linalg.expm(Nr * R_rate / float((2 * N_diploid) ** 2)) # arr = [] for theta in theta_values: # Compute the expected number of mutation events per generation. mu = theta / 2 # Precompute the mutation matrix # and the product of mutation and recombination. M_prob = linalg.expm(mu * M_rate / float(2 * 2 * N_diploid)) MR_prob = np.dot(M_prob, R_prob) # row = [] for Ns in Ns_values: s = Ns / float(N_diploid) lps = wfcompens.create_selection(s, M) S_prob = np.exp(wfengine.create_genic(lmcs, lps, M)) P = np.dot(MR_prob, S_prob) # compute the stationary distribution v = MatrixUtil.get_stationary_distribution(P) # compute the transition matrix limit at time infinity # P_inf = np.outer(np.ones_like(v), v) # compute the fundamental matrix Z # Z = linalg.inv(np.eye(nstates) - (P - P_inf)) - P_inf # # Use broadcasting instead of constructing P_inf. Z = linalg.inv(np.eye(nstates) - (P - v)) - v # compute the hitting time from state AB to state ab. i = 0 j = 3 hitting_time_generations = (Z[j, j] - Z[i, j]) / v[j] hitting_time = hitting_time_generations * theta row.append(hitting_time) arr.append(row) return arr
def test_padecases_double(self): # test double-precision cases a1 = eye(3, dtype=double)*1e-2; e1 = exp(1e-2)*eye(3) a2 = eye(3, dtype=double)*1e-1; e2 = exp(1e-1)*eye(3) a3 = eye(3, dtype=double)*5e-1; e3 = exp(5e-1)*eye(3) a4 = eye(3, dtype=double); e4 = exp(1.)*eye(3) a5 = eye(3, dtype=double)*10; e5 = exp(10.)*eye(3) assert_array_almost_equal(expm(a1),e1) assert_array_almost_equal(expm(a2),e2) assert_array_almost_equal(expm(a3),e3) assert_array_almost_equal(expm(a4),e4) assert_array_almost_equal(expm(a5),e5)
def q(dt, prmtr, num_states, prmtr_size_dict,skip_mapping=0): '''computing Q matrix''' if num_states == 4: a, Kp, lmda, Phi, sigma11, sigma22, sigma33, sigma44, Sigma, thetap = extract_vars(prmtr, num_states, prmtr_size_dict, skip_mapping=skip_mapping) elif num_states == 6: a, Kp, lmda, lmda2, Phi, sigma11, sigma22, sigma22_2, sigma33, sigma33_2, sigma44, Sigma, thetap = extract_vars(prmtr, num_states, prmtr_size_dict, skip_mapping=skip_mapping) qout = np.empty((num_states,num_states)) * np.nan tempfunc = lambda x, r, c: (expm(-Kp * x)*Sigma*(Sigma.transpose())*(expm(-Kp * x).transpose()))[r, c] for r in range(num_states): for c in range(num_states): qout[r, c] = integrate.quad(tempfunc, 0, dt, args=(r, c))[0] return qout
def __get_ps(self): """ Return the list of probabilities for each time slice :return: the list of probabilities for each time slice """ to_return = [expm(self.q_iso * self.sin_breaks[0])] to_return.extend([expm(self.q_sin * (self.sin_breaks[i + 1] - self.sin_breaks[i])) for i in xrange(len(self.sin_breaks) - 1)]) p_end = numpy.zeros(shape=self.q_sin.shape) p_end[:, END[PS.single][0]] = 1.0 to_return.append(p_end) return to_return
def get_plot_array(N_diploid, Nr, theta_values, Ns_values): """ @param N_diploid: diploid population size @param Nr: recombination rate @param theta_values: mutation rates @param Ns_values: selection values @return: arr[i][j] gives time for Ns_values[i] and theta_values[j] """ # set up the state space k = 4 M = multinomstate.get_sorted_states(2 * N_diploid, k) T = multinomstate.get_inverse_map(M) nstates = M.shape[0] lmcs = wfengine.get_lmcs(M) # precompute rate matrices R_rate = wfcompens.create_recomb(M, T) M_rate = wfcompens.create_mutation(M, T) # precompute a recombination probability matrix R_prob = linalg.expm(Nr * R_rate / float((2 * N_diploid) ** 2)) # arr = [] for theta in theta_values: # Compute the expected number of mutation events per generation. mu = theta / 2 # Precompute the mutation matrix # and the product of mutation and recombination. M_prob = linalg.expm(mu * M_rate / float(2 * 2 * N_diploid)) MR_prob = np.dot(M_prob, R_prob) # row = [] for Ns in Ns_values: s = Ns / float(N_diploid) lps = wfcompens.create_selection(s, M) S_prob = np.exp(wfengine.create_genic(lmcs, lps, M)) P = np.dot(MR_prob, S_prob) # compute the stochastic complement X = linalg.solve(np.eye(nstates - k) - P[k:, k:], P[k:, :k]) H = P[:k, :k] + np.dot(P[:k, k:], X) # condition on not looping np.fill_diagonal(H, 0) v = np.sum(H, axis=1) H /= v[:, np.newaxis] # let ab be an absorbing state # and compute the expected number of returns to AB Q = H[:3, :3] I = np.eye(3) N = linalg.inv(I - Q) # row.append(N[0, 0] - 1) arr.append(row) return arr
def _B2formula(Ac, t1, t2, B2): if t1 == 0 and t2 == 0: term = B2 return term n = Ac.shape[0] tmp = np.eye(n) - expm(-Ac) if cond(tmp) < 1000000.0: term = np.dot(((expm(-Ac * t1) - expm(-Ac * t2)) * inv(tmp)), B2) return term # Numerical trouble. Perturb slightly and check the result ntry = 0 k = np.sqrt(eps) Ac0 = Ac while ntry < 2: Ac = Ac0 + k * rand(n, n) tmp = np.eye(n) - expm(-Ac) if cond(tmp) < 1 / np.sqrt(eps): ntry = ntry + 1 if ntry == 1: term = np.dot(np.dot(expm(-Ac * t1) - expm(-Ac * t2), inv(tmp)), B2) else: term1 = np.dot(np.dot(expm(-Ac * t1) - expm(-Ac * t2), inv(tmp)), B2) k = k * np.sqrt(2) if norm(term1 - term) > 0.001: warn("Inaccurate calculation in mapCtoD.") return term
def test_opposite_sign_complex_eigenvalues(self): # See gh-6113 E = [[0, 1], [-1, 0]] L = [[0, np.pi*0.5], [-np.pi*0.5, 0]] assert_allclose(expm(L), E, atol=1e-14) assert_allclose(logm(E), L, atol=1e-14) E = [[1j, 4], [0, -1j]] L = [[1j*np.pi*0.5, 2*np.pi], [0, -1j*np.pi*0.5]] assert_allclose(expm(L), E, atol=1e-14) assert_allclose(logm(E), L, atol=1e-14) E = [[1j, 0], [0, -1j]] L = [[1j*np.pi*0.5, 0], [0, -1j*np.pi*0.5]] assert_allclose(expm(L), E, atol=1e-14) assert_allclose(logm(E), L, atol=1e-14)
def test_PHS_TRIM(): """Test the function that makes particle-hole symmetric modes at a TRIM. """ np.random.seed(10) for n in (4, 8, 16, 40, 60): for sym in kwant.rmt.sym_list: if kwant.rmt.p(sym): p_mat = np.array(kwant.rmt.h_p_matrix[sym]) p_mat = np.kron(np.identity(n // len(p_mat)), p_mat) P_squared = 1 if np.all(np.abs(p_mat.conj().dot(p_mat) - np.eye(*p_mat.shape)) < 1e-10) else -1 if P_squared == 1: for nmodes in (1, 3, n//4, n//2, n): # Random matrix of 'modes.' Take part of a unitary matrix to # ensure that the modes form a basis. modes = np.random.rand(n, n) + 1j*np.random.rand(n, n) modes = la.expm(1j*(modes + modes.T.conj()))[:n, :nmodes] # Ensure modes are particle-hole symmetric and normalized modes = modes + p_mat.dot(modes.conj()) modes = np.array([col/np.linalg.norm(col) for col in modes.T]).T # Mix the modes with a random unitary transformation U = np.random.rand(nmodes, nmodes) + 1j*np.random.rand(nmodes, nmodes) U = la.expm(1j*(U + U.T.conj())) modes = modes.dot(U) # Make the modes PHS symmetric using the method for a TRIM. phs_modes = leads.phs_symmetrization(modes, p_mat)[0] assert_almost_equal(phs_modes, p_mat.dot(phs_modes.conj()), err_msg='PHS broken at a TRIM in ' + sym) assert_almost_equal(phs_modes.T.conj().dot(phs_modes), np.eye(phs_modes.shape[1]), err_msg='Modes are not orthonormal, TRIM PHS in ' + sym) elif P_squared == -1: # Need even number of modes =< n for nmodes in (2, 4, n//2, n): # Random matrix of 'modes.' Take part of a unitary matrix to # ensure that the modes form a basis. modes = np.random.rand(n, n) + 1j*np.random.rand(n, n) modes = la.expm(1j*(modes + modes.T.conj()))[:n, :nmodes] # Ensure modes are particle-hole symmetric and orthonormal. modes[:, nmodes//2:] = p_mat.dot(modes[:, :nmodes//2].conj()) modes = la.qr(modes, mode='economic')[0] # Mix the modes with a random unitary transformation U = np.random.rand(nmodes, nmodes) + 1j*np.random.rand(nmodes, nmodes) U = la.expm(1j*(U + U.T.conj())) modes = modes.dot(U) # Make the modes PHS symmetric using the method for a TRIM. phs_modes = leads.phs_symmetrization(modes, p_mat)[0] assert_almost_equal(phs_modes[:, 1::2], p_mat.dot(phs_modes[:, ::2].conj()), err_msg='PHS broken at a TRIM in ' + sym) assert_almost_equal(phs_modes.T.conj().dot(phs_modes), np.eye(phs_modes.shape[1]), err_msg='Modes are not orthonormal, TRIM PHS in ' + sym)
def Find_Res(HyperfineStr=[1.4680e+4,2.9361e3] ,B_field =400 ,tau_max=6*1e-6,tau_step = 0.005*1e-6, max_gate_time = 8000*1e-6): """ Finds resonant driving conditions and number of pulses required for a hyperfine strength input HyperfineStr in real freq but number of pulses unreliable because of dependency on timestep """ #physical constants gamma_c = 1.071e3 #g-factor for C13 in MHz/G #Model parameters timesteps = np.arange(tau_step,tau_max,tau_step) omega_larmor = 2*np.pi*gamma_c*B_field tau_larmor = 2*np.pi/omega_larmor A= 2*np.pi*HyperfineStr[0] B= 2*np.pi*HyperfineStr[1] #Converts to radial frequency in Hz Ix = 0.5 * np.array([[0,1],[1,0]]) Iz = 0.5* np.array([[1,0],[0,-1]]) H0 = (omega_larmor)*Iz H1 = (A+omega_larmor) *Iz +B*Ix li_n0 = [] li_n1=[] ax_prod = np.zeros(np.size(timesteps)) #Char evolution for idt, tau in enumerate(timesteps): exH0 =linalg.expm(-1j*H0*tau) exH1 = linalg.expm(-1j*H1*tau) V0 = exH0.dot(exH1.dot(exH1.dot(exH0))) V1 = exH1.dot(exH0.dot(exH0.dot(exH1))) #li_V0.append(V0)#appending takes shitloads of time. Maybe dump this line #li_V1.append(V1) n0 = Calc_axis(V0) n1 =Calc_axis(V1) ax_prod[idt] = np.dot(n0,n1) #Find Resonances as minima dip_ind = find_mins(ax_prod) theta = np.zeros(np.size(dip_ind)) for idi, ind in enumerate(dip_ind): #Either save V0's and calc only needed theta or calc all and not save V0 tau = timesteps[ind] exH0 =linalg.expm(-1j*H0*tau) exH1 = linalg.expm(-1j*H1*tau) V0 = exH0.dot(exH1.dot(exH1.dot(exH0))) theta[idi] = np.real(2*np.arccos(np.trace(V0)/2)) n_pulses = np.divide(np.pi,(2*(np.pi-np.abs(np.pi-theta)))).astype(int) tlist = timesteps[dip_ind] res = check_pulse_t(tlist, n_pulses, max_gate_time) return res
def help_get_lhood_diff(T, root, root_distn1d, node_to_data_fvec1d, edge_to_Q, edge_to_rate, special_edge): edge_to_P = {} for edge in T.edges(): edge_rate = edge_to_rate[edge] edge_Q = edge_to_Q[edge] Q = edge_rate * edge_Q if edge == special_edge: P = np.dot(edge_Q, expm(Q)) else: P = expm(Q) edge_to_P[edge] = P lhood = get_lhood(T, edge_to_P, root, root_distn1d, node_to_data_fvec1d) return lhood
def mat_exp(mat): return expm(mat)
def continous_time_least_norm_input(A, B, xr, t1, dt): times = np.arange(0, t1, dt) Gc = gram_ctrb(A, B) uln_t = [B.T * la.expm(A.T * (t1 - t)) * Gc.I * xr for t in times] return uln_t
length = int(107) elif protein == '1pek': pi_nuc = [0.20853, 0.34561, 0.25835, 0.18750] GTR = helpers.MutationMatrix(pi_nuc, 0.90382, 1, 1, 1, 1, 0.90382) num_taxa = int(12) length = int(279) Neff = int(1e2) IN, IS = IndicatorMatrix() M = Q_matrix(np.ones(61), GTR, Neff) #Calculate neutral frequencies based on GTR model F_neutral = np.ones((61)) Q_neutral = Q_matrix(F_neutral, GTR, Neff) P_neutral = linalg.expm(np.multiply(Q_neutral, 40)) p_neutral = P_neutral[0] #%%############################################################################ #### calculate E[dN/dS] for S-SI #### ############################################################################### full_Kn = np.zeros((50, length)) full_Ln = np.zeros((50, length)) for trial in range(1, 51): KN = [] LN = [] print(trial) full_ssFit = pickle.load( open(path_to_ssFit + 'ssFit_seqfile' + str(trial) + '.pkl', 'rb')) ssFit = np.mean(full_ssFit, axis=1) for site in range(length):
affine = np.identity(4) rot = np.radians(fitpars[3:]) rotation_matrices = np.apply_along_axis(create_rotation_matrix_3d, axis=0, arr=rot).transpose([-1, 0, 1]) tt = fitpars[0:3, :].transpose([1, 0]) affs = np.tile(affine, [fitpars.shape[1], 1, 1]) affs[:,0:3,0:3] = rotation_matrices affs[:, 0:3, 3] = tt from scipy.linalg import logm, expm weights, matrices = ss[0], affs logs = [w * logm(A) for (w, A) in zip(weights, matrices)] logs = np.array(logs) logs_sum = logs.sum(axis=0) expm(logs_sum/np.sum(weights, axis=0) ) #a 10-2 pres c'est bien l'identite ! rp_files = gfile('/data/romain/HCPdata/suj_274542/Motion_ms','^rp') rp_files = gfile('/data/romain/HCPdata/suj_274542/mot_separate','^rp') rpf = rp_files[10] res = pd.DataFrame() for rpf in rp_files: dirpath,name = get_parent_path([rpf]) fout = dirpath[0] + '/check/'+name[0][3:-4] + '.nii' t = RandomMotionFromTimeCourse(fitpars=rpf, nufft=True, oversampling_pct=0, keep_original=True, verbose=True) dataset = ImagesDataset(suj, transform=t) sample = dataset[0] dicm = sample['T1']['metrics']
def spectralrad(M): """M is a matrix : returns the spectral radius""" return(np.absolute(LA.eigvals(M)).max()) def vecetspectralrad(M): l,w=LA.eig(M) al=np.absolute(l) im=np.where(al==al.max())[0][0] v=w[:,im] v=v/sum(v) return(al[im],v) #et on teste D=np.array([[-2, 2], [1, -1]]) E=expm((2*np.log(2)/3)*D) spectralrad(E.transpose()) A=np.array([[1, -1], [4, 2]]) B=np.diag((1, 2, 3)) C=np.array([[0.1,0.9],[0.3,0.7]]) ei=LA.eigvals(A) z=ei[0] rei=ei.real np.exp(spectralabc(A)) spectralrad(expm(A)) #doit donner la même chose #un premier modele de covid avec deux classes Asymptomatique et Infectieux def tauxcontacper(beta,p,cbeta,T):
def step(self, niter): """ xNES """ f = self.f mu, sigma, bmat = self.mu, self.sigma, self.bmat eta_mu, eta_sigma, eta_bmat = self.eta_mu, self.eta_sigma, self.eta_bmat npop = self.npop dim = self.dim sigma_old = self.sigma_old eyemat = eye(dim) with joblib.Parallel(n_jobs=self.n_jobs) as parallel: for i in range(niter): s_try = randn(npop, dim) z_try = mu + sigma * dot(s_try, bmat) # broadcast f_try = parallel(joblib.delayed(f)(z) for z in z_try) f_try = asarray(f_try) # save if best fitness = mean(f_try) if fitness - 1e-8 > self.fitness_best: self.fitness_best = fitness self.mu_best = mu.copy() self.counter = 0 else: self.counter += 1 if self.counter > self.patience: self.done = True return isort = argsort(f_try) f_try = f_try[isort] s_try = s_try[isort] z_try = z_try[isort] u_try = self.utilities if self.use_fshape else f_try if self.use_adasam and sigma_old is not None: # sigma_old must be available eta_sigma = self.adasam(eta_sigma, mu, sigma, bmat, sigma_old, z_try) dj_delta = dot(u_try, s_try) dj_mmat = dot(s_try.T, s_try*u_try.reshape(npop,1)) - sum(u_try)*eyemat dj_sigma = trace(dj_mmat)*(1.0/dim) dj_bmat = dj_mmat - dj_sigma*eyemat sigma_old = sigma # update mu += eta_mu * sigma * dot(bmat, dj_delta) sigma *= exp(0.5 * eta_sigma * dj_sigma) bmat = dot(bmat, expm(0.5 * eta_bmat * dj_bmat)) # logging self.history['fitness'].append(fitness) self.history['sigma'].append(sigma) self.history['eta_sigma'].append(eta_sigma) # keep last results self.mu, self.sigma, self.bmat = mu, sigma, bmat self.eta_sigma = eta_sigma self.sigma_old = sigma_old
def ExpMatrix(self, *time): self.Solution = self.eAt = numpy.array([ (linalg.expm(self.A * _t)).dot(self.u0) for _t in time ]) self.t = numpy.array([time]) return self.eAt
def VISLAM(self): time = np.transpose(self.t) velocity = np.transpose(self.linear_velocity) omega = np.transpose(self.rotational_velocity) #EKF prediction of the IMU mu_list, cov_list = self.prediction( ) #world in imu prediction (imu state) noise_w = 1e-5 * np.eye(6) #imu noise covariance #Initialize EKF update M = getM(self.K, self.b) mu_world_feature_0 = np.zeros( (4, self.feature_num )) #initial state of the landmark --> visualization mu = np.zeros((4, self.feature_num + 4)) #fused state: 4 x num of features, 4 x 4 for pose cov = np.eye( 3 * self.feature_num + 6) #fused observation covariance 3 x num of features + 6 DOF noise_v = 1e1 * np.eye(4) #landmarks noise covariance #Save the pose world_T_imu pose_list = [] world_T_imu = np.linalg.inv(mu_list[0]) pose_list.append(world_T_imu) #Update landmarks for first observation (first frame) indices = np.flatnonzero(self.features[0, :, 0] != -1) feature = self.features[:, indices, 0] #feature in image frame Z = getz(feature, M) x = (feature[0] - M[0, 2]) * Z / M[0, 0] y = (feature[1] - M[1, 2]) * Z / M[1, 1] feature_cam = np.vstack( (x, y, Z, np.ones(x.shape))) #feature in camera frame imu_T_cam = np.linalg.inv(self.cam_T_imu) world_T_imu = np.linalg.inv(mu_list[0]) feature_world = world_T_imu @ imu_T_cam @ feature_cam #feature in world frame mu_world_feature_0[:, indices] = feature_world mu[:, indices] = feature_world for i in range(self.t_len - 2): #EKF IMU pose prediction dt = time[i + 1] - time[i] omega_hat = gethatmap(omega[i]) u_head = getu_head(omega_hat, velocity[i]) v_hat = gethatmap(velocity[i]) u_vee = getu_vee(omega_hat, v_hat) mu_list[i + 1] = getpredict_mu(dt, u_head, mu_list[i]) #world to body cov_list[i + 1] = getpredict_cov(dt, u_vee, cov_list[i], noise_w) #Update covariance in fused state cov[-6:, -6:] = cov_list[i] cov[:3 * self.feature_num, 3 * self.feature_num:] = cov[:3 * self.feature_num, 3 * self.feature_num:] @ np.transpose( expm(-dt * u_vee)) cov[3 * self.feature_num:, :3 * self.feature_num] = np.transpose( cov[:3 * self.feature_num, 3 * self.feature_num:]) #EKF mean update landmarks and pose indices = np.flatnonzero(self.features[0, :, i + 1] != -1) z = self.features[:, indices, i + 1] N_t = len(indices) if N_t: #First observed new features indices_new = indices[np.flatnonzero( mu_world_feature_0[-1, indices] == 0)] z_new = self.features[:, indices_new, i + 1] #new feature in image frame if len(z_new): Z = getz(z_new, M) x = (z_new[0] - M[0, 2]) * Z / M[0, 0] y = (z_new[1] - M[1, 2]) * Z / M[1, 1] feature_cam = np.vstack( (x, y, Z, np.ones(x.shape))) #new feature in camera frame imu_T_cam = np.linalg.inv(self.cam_T_imu) world_T_imu = np.linalg.inv(mu_list[i + 1]) feature_world = world_T_imu @ imu_T_cam @ feature_cam #new feature in world frame mu_world_feature_0[:, indices_new] = feature_world mu[:, indices_new] = feature_world #EKF update landmarks and pose H = np.zeros((4 * N_t, 3 * self.feature_num + 6)) cam_T_imu_T_world = self.cam_T_imu @ mu_list[i + 1] z_hat = M @ cam_T_imu_T_world @ mu[:, indices] z_hat = z_hat / z_hat[2] for j in range(N_t): #landmarks update of H H[4*j:4*j+4, 3*indices[j]:3*indices[j]+3] = M @ jacobian(self.cam_T_imu @ mu_list[i+1] @ mu[:,indices[j]].reshape(4,-1)) @ \ self.cam_T_imu @ mu_list[i+1] @ self.D #imu pose update of H H[4*j:4*j+4, -6:] = M @ jacobian(self.cam_T_imu @ mu_list[i+1] @ mu[:, indices[j]]) @ \ self.cam_T_imu @ getcircle(mu_list[i+1] @ mu[:, indices[j]].reshape(4, -1)) k_gain = cov @ np.transpose(H) @ np.linalg.pinv( H @ cov @ np.transpose(H) + np.kron(np.eye(N_t), noise_v)) #Update landmarks mean mu[:, :self.feature_num] = (mu[:, :self.feature_num].flatten('F') + np.kron(np.eye(self.feature_num), self.D) @ k_gain[:3*self.feature_num, :] @ \ (z - z_hat).flatten('F')).reshape(self.feature_num, 4).T #Update IMU pose mean mu[:, self.feature_num:] = expm( hatoperation(k_gain[-6:, :] @ (z - z_hat).flatten('F'))) @ mu_list[i + 1] #Update fused state covariance cov = (np.eye(3 * self.feature_num + 6) - k_gain @ H) @ cov #Update all mu_list[i + 1] = mu[:, self.feature_num:] pose_list.append(np.linalg.inv(mu_list[i + 1])) cov_list[i + 1] = cov[-6:, -6:] feature_list = mu[:, :self.feature_num] poses_list = np.stack((pose_list), axis=-1) plt.scatter(feature_list[0, :], feature_list[1, :], label="updated feature with VISLAM") visualize_trajectory_2d(poses_list, path_name="VISLAM", show_ori=True) return poses_list
def test_multiexp(self): A = multisym(rnd.randn(self.k, self.m, self.m)) e = np.zeros((self.k, self.m, self.m)) for i in range(self.k): e[i] = expm(A[i]) np_testing.assert_allclose(multiexp(A, sym=True), e)
def van_loan_discretization(F, G, dt): """ Discretizes a linear differential equation which includes white noise according to the method of C. F. van Loan [1]. Given the continuous model x' = Fx + Gu where u is the unity white noise, we compute and return the sigma and Q_k that discretizes that equation. Examples -------- Given y'' + y = 2u(t), we create the continuous state model of x' = [ 0 1] * x + [0]*u(t) [-1 0] [2] and a time step of 0.1: >>> F = np.array([[0,1],[-1,0]], dtype=float) >>> G = np.array([[0.],[2.]]) >>> phi, Q = van_loan_discretization(F, G, 0.1) >>> phi array([[ 0.99500417, 0.09983342], [-0.09983342, 0.99500417]]) >>> Q array([[ 0.00133067, 0.01993342], [ 0.01993342, 0.39866933]]) (example taken from Brown[2]) References ---------- [1] C. F. van Loan. "Computing Integrals Involving the Matrix Exponential." IEEE Trans. Automomatic Control, AC-23 (3): 395-404 (June 1978) [2] Robert Grover Brown. "Introduction to Random Signals and Applied Kalman Filtering." Forth edition. John Wiley & Sons. p. 126-7. (2012) """ n = F.shape[0] A = zeros((2*n, 2*n)) # we assume u(t) is unity, and require that G incorporate the scaling term # for the noise. Hence W = 1, and GWG' reduces to GG" A[0:n, 0:n] = -F.dot(dt) A[0:n, n:2*n] = G.dot(G.T).dot(dt) A[n:2*n, n:2*n] = F.T.dot(dt) B=expm(A) sigma = B[n:2*n, n:2*n].T Q = sigma.dot(B[0:n, n:2*n]) return (sigma, Q)
def _get_heat_matrix(self, adj_matrix, t=5.0): num_nodes = adj_matrix.shape[0] A_tilde = adj_matrix + np.eye(num_nodes) D_tilde = np.diag(1 / np.sqrt(A_tilde.sum(axis=1))) H = D_tilde @ A_tilde @ D_tilde return expm(-t * (np.eye(num_nodes) - H))
return v/norm if(deltap1+deltap2+deltap3+deltap4==0): #evitar que la normalización se indefina si ambos deltap son 0 deltasum = 0.001 else: deltasum = deltap1+deltap2+deltap3+deltap4 if(rn1<deltasum): if(rn2<=(deltap1/deltasum)): vec=tongo(np.matmul(S1,vec)) elif(rn2<=((deltap1+deltap2)/deltasum)): vec=tongo(np.matmul(S2,vec)) elif(rn2<=((deltap1+deltap2+deltap3)/deltasum)): vec=tongo(np.matmul(S3,vec)) else: vec=tongo(np.matmul(S4,vec)) else: vec=tongo(np.matmul(expm(-1j*deltat*Hju),vec)) aver_gg= np.matmul(sigmen,vec) aver_ee= np.matmul(sigmas,vec) aver_00= np.matmul(a,vec) aver_11= np.matmul(adag,vec) eqju_gg.append(np.abs(np.dot(aver_gg,aver_gg))) eqju_ee.append(np.abs(np.dot(aver_ee,aver_ee))) eqju_00.append(np.abs(np.dot(aver_00,aver_00))) eqju_11.append(np.abs(np.dot(aver_11,aver_11))) e1 = vec eqav_gg[n]=eqav_gg[n]+(np.abs(np.dot(aver_gg,aver_gg)))/nst eqav_ee[n]=eqav_ee[n]+(np.abs(np.dot(aver_ee,aver_ee)))/nst eqav_00[n]=eqav_00[n]+(np.abs(np.dot(aver_00,aver_00)))/nst eqav_11[n]=eqav_11[n]+(np.abs(np.dot(aver_11,aver_11)))/nst e1 = np.array([0,1,0,0])
F = open("MathLinDiss.txt","r") HDISS = F.read() HDISS = eval(HDISS) HDISS=np.transpose(HDISS) File1 = open("MathLinDiss3.txt","r") HMain = File1.read() HMain = eval(HMain) Heff = np.asarray(HDISS) + np.asarray(HMain) Czas = [] Evolution1 = [] for i in range(0,1000): t = h * i Czas.append(t) wykladnik = np.asarray(Heff) * t NonUnitary = SLA.expm(wykladnik) NewState = mulvec(NonUnitary,InitTaon) Density = F0 * NewState[0] + F1 * NewState[1] + F2 * NewState[2] + F3 * NewState[3] + F4 * NewState[4] +\ F5 * NewState[5] + F6 * NewState[6] + F7 * NewState[7] + F8 * NewState[8] ExpW1 = np.trace(mulmul3(Density,A1,A2)) ExpW2 = np.trace(mulmul3(Density,A2,A3)) ExpW3 = np.trace(mulmul3(Density,A3,A4)) ExpW4 = np.trace(mulmul3(Density,A4,A5)) ExpW5 = np.trace(mulmul3(Density,A5,A1)) suma = ExpW1 + ExpW2 + ExpW3 + ExpW4 + ExpW5 Evolution1.append(suma) Evolution.append(Evolution1) stop = time.time() czas = stop-start print("czas = {}".format(czas))
def _decompose_(self, qubits): """The goal is to effect a rotation around an axis in the XY plane in each of three orthogonal 2-dimensional subspaces. First, the following basis change is performed: 0000 ↦ 0001 0001 ↦ 1111 1111 ↦ 0010 1110 ↦ 1100 0010 ↦ 0000 0110 ↦ 0101 1101 ↦ 0011 1001 ↦ 0110 0100 ↦ 0100 1010 ↦ 1001 1011 ↦ 0111 0101 ↦ 1010 1000 ↦ 1000 1100 ↦ 1101 0111 ↦ 1011 0011 ↦ 1110 Note that for each 2-dimensional subspace of interest, the first two qubits are the same and the right two qubits are different. The desired rotations thus can be effected by a complex-version of a partial SWAP gate on the latter two qubits, controlled on the first two qubits. This partial SWAP-like gate can be decomposed such that it is parameterized solely by a rotation in the ZY plane on the third qubit. These are the `individual_rotations`; call them U0, U1, U2. To decompose the double controlled rotations, we use four other rotations V0, V1, V2, V3 (the `combined_rotations`) such that U0 = V3 · V1 · V0 U1 = V3 · V2 · V1 U2 = V2 · V0 """ if self._is_parameterized_(): return NotImplemented individual_rotations = [ la.expm(0.5j * self.exponent * np.array([ [np.real(w), 1j * s * np.imag(w)], [-1j * s * np.imag(w), -np.real(w)]])) for s, w in zip([1, -1, -1], self.weights)] combined_rotations = {} combined_rotations[0] = la.sqrtm(np.linalg.multi_dot([ la.inv(individual_rotations[1]), individual_rotations[0], individual_rotations[2]])) combined_rotations[1] = la.inv(combined_rotations[0]) combined_rotations[2] = np.linalg.multi_dot([ la.inv(individual_rotations[0]), individual_rotations[1], combined_rotations[0]]) combined_rotations[3] = individual_rotations[0] controlled_rotations = {i: cirq.ControlledGate( cirq.MatrixGate(combined_rotations[i], qid_shape=(2,))) for i in range(4)} a, b, c, d = qubits basis_change = list(cirq.flatten_op_tree([ cirq.CNOT(b, a), cirq.CNOT(c, b), cirq.CNOT(d, c), cirq.CNOT(c, b), cirq.CNOT(b, a), cirq.CNOT(a, b), cirq.CNOT(b, c), cirq.CNOT(a, b), [cirq.X(c), cirq.X(d)], [cirq.CNOT(c, d), cirq.CNOT(d, c)], [cirq.X(c), cirq.X(d)], ])) controlled_rotations = list(cirq.flatten_op_tree([ controlled_rotations[0](b, c), cirq.CNOT(a, b), controlled_rotations[1](b, c), cirq.CNOT(b, a), cirq.CNOT(a, b), controlled_rotations[2](b, c), cirq.CNOT(a, b), controlled_rotations[3](b, c) ])) controlled_swaps = [ [cirq.CNOT(c, d), cirq.H(c)], cirq.CNOT(d, c), controlled_rotations, cirq.CNOT(d, c), [cirq.inverse(op) for op in reversed(controlled_rotations)], [cirq.H(c), cirq.CNOT(c, d)], ] return [basis_change, controlled_swaps, basis_change[::-1]]
def lrsp(p): fbetaA=tauxcontacper(betaA,p,cbeta,T) fbetaS=tauxcontacper(betaS,p,cbeta,T) a=matcroissance(fbetaA,fbetaS,piS,gammaS,gammaA) phiT=np.dot(expm(a(0.99*T)*(1-p)*T),expm(a(0.01*T)*p*T)) return((np.log(spectralrad(phiT)))/T)
def _grad_theta(self, dis, real_state): G_list = self.getGen() Q = real_state phi = dis.getPhi() psi = dis.getPsi() grad = list() zero_state = get_zero_state(self.size) try: A = expm((-1 / lamb) * phi) except Exception: print('grad_gen -1/lamb:\n', (-1 / lamb)) print('size of phi:\n', phi.shape) try: B = expm((1 / lamb) * psi) except Exception: print('grad_gen 1/lamb:\n', (1 / lamb)) print('size of psi:\n', psi.shape) for G, j in zip(G_list, range(len(self.qc_list))): fake_state = np.matmul(G, zero_state) grad_g_psi = list() grad_g_phi = list() grad_g_reg = list() for i in range(self.qc_list[j].depth): grad_i = self.qc_list[j].get_grad_mat_rep(i) # for psi term grad_g_psi.append(0) # for phi term fake_grad = np.matmul(grad_i, zero_state) g_Gi = self.prob_gen[j] * ( np.matmul(fake_grad, fake_state.getH()) + np.matmul(fake_state, fake_grad.getH())) grad_g_phi.append(np.trace(np.matmul(g_Gi, phi))) # for reg term term1 = np.trace(np.matmul(A, g_Gi)) * np.trace(np.matmul( B, Q)) term2 = np.trace(np.matmul(A, np.matmul(g_Gi, np.matmul(B, Q)))) term3 = np.trace(np.matmul(g_Gi, np.matmul(A, np.matmul(Q, B)))) term4 = np.trace(np.matmul(B, g_Gi)) * np.trace(np.matmul( A, Q)) tmp_reg_grad = lamb / np.e * (cst1 * term1 - cst2 * term2 - cst2 * term3 + cst3 * term4) grad_g_reg.append(tmp_reg_grad) g_psi = np.asarray(grad_g_psi) g_phi = np.asarray(grad_g_phi) g_reg = np.asarray(grad_g_reg) grad.append(np.real(g_psi - g_phi - g_reg)) # print("grad:\n",grad) return grad
def heat_kernel(s): h_of_t = linalg.expm(-1 * (t - s) * scriptLaplacian)[ subgraph.vertices.index(x)][subgraph.vertices.index(y)] return h_of_t
def u_true(self, x, t): return -self.sigma(x).cpu().numpy().T.dot( expm(self.A.cpu().numpy().T * (self.T - t)).dot(self.alpha.cpu().numpy()) * np.ones(x.shape).T)
def test_multiexp_singlemat(self): # A is a positive definite matrix A = rnd.randn(self.m, self.m) A = A + A.T np_testing.assert_allclose(multiexp(A, sym=True), expm(A))
def test_expm(rng): pytest.importorskip('scipy') import scipy.linalg as linalg for a in [np.eye(3), rng.randn(10, 10)]: assert np.allclose(linalg.expm(a), expm(a))
dict(name="sigx0_w", value=1.0), dict(name="sigx0_i", value=1.0) ] reg = Regressor(TwTi_RoRi(parameters)) reg.ss.jacobian = False reg.ss.update() dt = 600 hold = 'foh' Ad, B0d, B1d, Qd = reg.ss.discretization(dt, hold) AA = np.zeros((reg.ss.Nx + reg.ss.Nu, reg.ss.Nx + reg.ss.Nu)) AA[:reg.ss.Nx, :reg.ss.Nx] = reg.ss.A AA[:reg.ss.Nx, reg.ss.Nx:] = reg.ss.B AAd = expm(AA * dt) Ad2 = AAd[:reg.ss.Nx, :reg.ss.Nx] B0d2 = AAd[:reg.ss.Nx, reg.ss.Nx:] assert np.allclose(Ad, Ad2) assert np.allclose(B0d, B0d2) print('\nTest zero order hold: OK') AA = np.zeros((reg.ss.Nx + 2 * reg.ss.Nu, reg.ss.Nx + 2 * reg.ss.Nu)) AA[:reg.ss.Nx, :reg.ss.Nx] = reg.ss.A AA[:reg.ss.Nx, reg.ss.Nx:reg.ss.Nx + reg.ss.Nu] = reg.ss.B AA[:reg.ss.Nx, -reg.ss.Nu:] = reg.ss.B AA[reg.ss.Nx:reg.ss.Nx + reg.ss.Nu, -reg.ss.Nu:] = np.eye(reg.ss.Nu) # AA[-reg.ss.Nu:, -2 * reg.ss.Nu:-reg.ss.Nu] = -np.eye(reg.ss.Nu) AA[-reg.ss.Nu:, -reg.ss.Nu:] = np.eye(reg.ss.Nu)
def exchange_and_transition_matrices(n, exch_mat_opt, exch_range, f_vec=None): """ Compute the exchange matrix and the Markov chain transition matrix from given number of objects :param n: the number of objects :type n: int :param exch_mat_opt: option for the exchange matrix, "s" = standard, "u" = uniform, "d" = diffusive, "r" = ring :type exch_mat_opt: str :param exch_range: range of the exchange matrix :type exch_range: int :param f_vec: an optional vector of relative weight :type f_vec: list[int] :return: the (n x n) exchange matrix and the (n x n) markov transition matrix :rtype: (numpy.ndarray, numpy.ndarray) """ # To manage other options if exch_mat_opt not in ["s", "u", "d", "r"]: warnings.warn( "Exchange matrix option ('exch_mat_opt') not recognized, setting it to 's'" ) exch_mat_opt = "s" # Weights if None if f_vec is None: f_vec = np.ones(n) / n # Computation regarding options if exch_mat_opt == "s": exch_mat = np.abs(np.add.outer(np.arange(n), -np.arange(n))) <= exch_range np.fill_diagonal(exch_mat, 0) exch_mat = exch_mat / np.sum(exch_mat) elif exch_mat_opt == "u": adj_mat = np.abs(np.add.outer(np.arange(n), -np.arange(n))) <= exch_range np.fill_diagonal(adj_mat, 0) g_vec = np.sum(adj_mat, axis=1) / np.sum(adj_mat) k_vec = f_vec / g_vec b_mat = np.array([[min(v1, v2) for v2 in k_vec] for v1 in k_vec]) * adj_mat / np.sum(adj_mat) exch_mat = np.diag(f_vec) - np.diag(np.sum(b_mat, axis=1)) + b_mat elif exch_mat_opt == "d": adj_mat = np.abs(np.add.outer(np.arange(n), -np.arange(n))) <= 1 np.fill_diagonal(adj_mat, 0) l_adj_mat = np.diag(np.sum(adj_mat, axis=1)) - adj_mat pi_outer_mat = np.outer(np.sqrt(f_vec), np.sqrt(f_vec)) phi_mat = (l_adj_mat / pi_outer_mat) / np.trace(l_adj_mat) exch_mat = expm(-exch_range * phi_mat) * pi_outer_mat else: exch_mat = np.abs(np.add.outer(np.arange(n), -np.arange(n))) <= exch_range if exch_range == 1: np.fill_diagonal(exch_mat, 0) else: to_remove = np.abs(np.add.outer(np.arange(n), -np.arange(n))) <= (exch_range - 1) exch_mat = exch_mat ^ to_remove exch_mat = exch_mat / np.sum(exch_mat) w_mat = (exch_mat / np.sum(exch_mat, axis=1)).T # Return the transition matrix return exch_mat, w_mat
def integrate(self, t_final, atol=1e-18, rtol=1e-10): """ Adaptively integrate the system of equations assuming self.t and self.y set the initial value. :param t_final: (scalar) the final time to be reached. :param atol: the absolute tolerance parameter :param rtol: the relative tolerance parameter :return: current value of y """ if not np.isscalar(t_final): raise ValueError( "t_final must be a scalar. If t_final is iterable consider using " "the list comprehension [integrate(t) for t in times].") sign_dt = np.sign(t_final - self.t) # Loop util the final time moment is reached while sign_dt * (t_final - self.t) > 0: ####################################################################################### # # Description of numerical methods # # A formal solution of the system of linear ode y'(t) = M(t) y(t) reads as # # y(t) = T exp[ \int_{t_init}^{t_fin} M(\tau) d\tau ] y(t_init) # # where T exp is a Dyson time-ordered exponent. Hence, # # y(t + dt) = T exp[ \int_{t}^{t+dt} M(\tau) d\tau ] y(t). # # Dropping the time ordering operation leads to the cubic error # # y(t + dt) = exp[ \int_{t}^{t+dt} M(\tau) d\tau ] y(t) + O( dt^3 ). # # Employing the mid-point rule for the integration also leads to the cubic error # # y(t + dt) = exp[ M(t + dt / 2) dt ] y(t) + O( dt^3 ). # # Therefore, we finally get the linear equation w.r.t. unknown y(t + dt) [note y(t) is known] # # exp[ -M(t + dt / 2) dt ] y(t + dt) = y(t) + O( dt^3 ), # # which can be solved by scipy.optimize.nnls ensuring the non-negativity constrain for y(t + dt). # ####################################################################################### # Initial guess for the time-step dt = 0.25 / norm(self.M(self.t, *self.M_args)) # time step must not take as above t_final dt = sign_dt * min(dt, abs(t_final - self.t)) # Loop until optimal value of dt is not found (adaptive step size integrator) while True: M = self.M(self.t + 0.5 * dt, *self.M_args) M = np.array(M, copy=False) M *= -dt new_y, residual = nnls(expm(M), self.y) # Adaptive step termination criterion if np.allclose(residual, 0., rtol, atol): # residual is small it seems we got the solution # Additional check: If M is a transition rate matrix, # then the sum of y must be preserved if np.allclose(M.sum(axis=0), 0., rtol, atol): # exit only if sum( y(t+dt) ) = sum( y(t) ) if np.allclose(sum(self.y), sum(new_y), rtol, atol): break else: # M is not a transition rate matrix, thus exist break if np.allclose(dt, 0., rtol, atol): # print waring if dt is very small print( "Warning in nnl_ode: adaptive time-step became very small." \ "The numerical result may not be trustworthy." ) break else: # half the time-step dt *= 0.5 # the dt propagation is successfully completed self.t += dt self.y = new_y return self.y
def _grad_beta(self, gen, real_state): psi = self.getPsi() phi = self.getPhi() zero_state = get_zero_state(gen.size) G_list = gen.getGen() P = np.zeros_like(G_list[0]) for p, g in zip(gen.prob_gen, G_list): state_i = np.matmul(g, zero_state) P += p * (np.matmul(state_i, state_i.getH())) Q = real_state try: A = expm((-1 / lamb) * phi) except Exception: print('grad_beta -1/lamb:\n', (-1 / lamb)) print('size of phi:\n', phi.shape) try: B = expm((1 / lamb) * psi) except Exception: print('grad_beta 1/lamb:\n', (1 / lamb)) print('size of psi:\n', psi.shape) grad_psi_term = np.zeros_like(self.beta, dtype=complex) grad_phi_term = np.zeros_like(self.beta, dtype=complex) grad_reg_term = np.zeros_like(self.beta, dtype=complex) for type in range(len(self.herm)): gradphi = self._grad_phi(type) gradpsi_list = list() gradphi_list = list() gradreg_list = list() for grad_phi in gradphi: gradpsi_list.append(0) gradphi_list.append(np.trace(np.matmul(P, grad_phi))) tmp_grad_phi = -1 / lamb * np.matmul(grad_phi, A) term1 = np.trace(np.matmul(tmp_grad_phi, P)) * np.trace( np.matmul(B, Q)) term2 = np.trace( np.matmul(tmp_grad_phi, np.matmul(P, np.matmul(B, Q)))) term3 = np.trace( np.matmul(P, np.matmul(tmp_grad_phi, np.matmul(Q, B)))) term4 = np.trace(np.matmul(B, P)) * np.trace( np.matmul(tmp_grad_phi, Q)) gradreg_list.append( lamb / np.e * (cst1 * term1 - cst2 * term2 - cst2 * term3 + cst3 * term4)) # calculate grad of psi term grad_psi_term[:, type] += np.asarray(gradpsi_list) # calculate grad of phi term grad_phi_term[:, type] += np.asarray(gradphi_list) # calculate grad of reg term grad_reg_term[:, type] += np.asarray(gradreg_list) # print("grad_beta:\n",np.real(grad_psi_term - grad_phi_term - grad_reg_term)) return np.real(grad_psi_term - grad_phi_term - grad_reg_term)
def exact_update_method(J,rhov,dt = 1e-4): rhov = np.dot(spla.expm(J*dt),rhov) assert_probability_mass_conserved(rhov) return rhov
NUM_POINTS = 100 X0s = [] Xs = [] for ii in range(NUM_POINTS): # X0 = np.random.uniform(low=-1, high=1, size=(2)) X0 = np.dot(vec, np.random.uniform(low=-1, high=1, size=(2))) X0s.append(X0) Xs.append([]) for step in range(steps): t = Ts[step] # eat = np.dot(vec, np.dot(la.expm(val * t), invvec)) eat = la.expm(A * t) for ii in range(NUM_POINTS): X = np.dot(eat, X0s[ii]) Xs[ii].append(X) ########################################## points = np.linspace(-100, 100, 100) print("basis 0: ", vec[0][0], vec[1][0]) basis0_x = points * vec[0][0] basis0_y = points * vec[1][0] print("basis 1: ", vec[0][1], vec[1][1]) basis1_x = points * vec[0][1]
def get_random_transformation(dim): herm = get_random_hermitian(dim) T = expm(1.0j * herm) return T
def test_logm_nearly_singular(self): M = np.array([[1e-100]]) expected_warning = _matfuncs_inv_ssq.LogmNearlySingularWarning L, info = _assert_warns(expected_warning, logm, M, disp=False) E = expm(L) assert_allclose(E, M, atol=1e-14)
def lrsp(p): betaa=tauxcontacper(betaamax,p,cbeta,T) betai=tauxcontacper(betaimax,p,cbeta,T) a=matcroissance(betaa,betai,pii,gammai,gammaa) phiT=np.dot(expm(a(0.01*T)*p*T),expm(a(0.99*T)*(1-p)*T)) return((np.log(spectralrad(phiT)))/T)
def _grad_prob(self, dis, real_state): G_list = self.getGen() psi = dis.getPsi() phi = dis.getPhi() Q = real_state zero_state = get_zero_state(self.size) try: A = expm((-1 / lamb) * phi) except Exception: print('grad_gen -1/lamb:\n', (-1 / lamb)) print('size of phi:\n', phi.shape) try: B = expm((1 / lamb) * psi) except Exception: print('grad_gen 1/lamb:\n', (1 / lamb)) print('size of psi:\n', psi.shape) grad_psi_term = np.zeros_like(self.W_classical, dtype=complex) grad_phi_term = np.zeros_like(self.W_classical, dtype=complex) grad_reg_term = np.zeros_like(self.W_classical, dtype=complex) # (#mix,(#output,#input)) grad = np.zeros((self.num_to_mix, self.num_output, self.num_input)) for k in range(self.num_output): for l in range(self.num_input): for i in range(self.num_to_mix): tmp = 0 for j in range(self.num_output): # to calculate {\partial prob_gen[i]}{\partial W_classical[b][a]} # \[\frac{{\partial {g_i}}}{{\partial {z_j}}} \cdot \frac{{\partial {z_j}}}{{\partial {w_{ba}}}}\] # because j can be different so we fix i,k,l if j == i: if j == k: tmp_equal = ( self.prob_gen[i] - self.prob_gen[i]**2) * self.input[l] tmp += tmp_equal else: tmp_equal = 0 tmp += tmp_equal else: if j == k: tmp_notequal = -self.prob_gen[ i] * self.prob_gen[j] * self.input[l] tmp += tmp_notequal else: tmp_notequal = 0 tmp += tmp_notequal grad[i][k][l] = tmp for b in range(self.num_to_mix): for a in range(self.num_input): gW = np.zeros(G_list[0].shape, dtype=complex) for i in range(self.num_to_mix): state_i = np.matmul(G_list[i], zero_state) gW += grad[i][b][a] * (np.matmul(state_i, state_i.getH())) # calculate grad of psi term grad_psi_term[b][a] = 0 # calculate grad of phi term grad_phi_term[b][a] = np.trace(np.matmul(gW, phi)) # calculate grad of reg term term1 = np.trace(np.matmul(A, gW)) * np.trace(np.matmul(B, Q)) term2 = np.trace(np.matmul(A, np.matmul(gW, np.matmul(B, Q)))) term3 = np.trace(np.matmul(gW, np.matmul(A, np.matmul(Q, B)))) term4 = np.trace(np.matmul(B, gW)) * np.trace(np.matmul(A, Q)) grad_reg_term[b][a] = lamb / np.e * ( cst1 * term1 - cst2 * term2 - cst2 * term3 + cst3 * term4) grad_w = np.real(grad_psi_term - grad_phi_term - grad_reg_term) return grad_w