def OkButtonClicked(self): """listwidgitem = QListWidgetItem() listwidgitem.setSizeHint(QtCore.QSize(self.listWidget.width(), 100)) listwidgitem.setText("ress") self.listWidget.addItem(listwidgitem) self.listWidget.setItemWidget(self.listWidget.item(1), QTextEdit("1)<html><head/><body><p>x<span style=\" vertical-align:sub;\">0</span></p></body></html>")) """ a = np.empty((self.Dim, self.Dim)) b = np.empty((self.Dim)) for i in range(self.Dim): for j in range(self.Dim): try: a[i, j] = np.float64(self.InputTableWidget.item(i, j).text()) self.InputTableWidget.item(i,j).setBackground(QtGui.QColor(255,255,255)) except: self.InputTableWidget.setItem(i, j, QTableWidgetItem()) self.InputTableWidget.item(i,j).setBackground(QtGui.QColor(255,128,128)) return -1; if self.methodBox.currentIndex() != 3: for i in range(self.Dim): try: b[i] = np.float64(self.InputTableWidget.item(i, self.Dim).text()) self.InputTableWidget.item(i,self.Dim).setBackground(QtGui.QColor(255,255,255)) except: self.InputTableWidget.setItem(i, self.Dim, QTableWidgetItem()) self.InputTableWidget.item(i, self.Dim).setBackground(QtGui.QColor(255,128,128)) return -1; if self.methodBox.currentIndex()==0: tabels = [] tabels.append(genTable(a, b, np.sum(a, 1)+b, np.sum(a, 1)+b)) gauss_d = gauss_det(a) a, b, Sum, S, tabels1 = gauss(a, b) tabels += tabels1 html = genHtml(tables=tabels) self.textBrowser.setText(html.replace('{%det%}','Det(A) = {0}'.format(gauss_d))) elif self.methodBox.currentIndex() == 1: for i in range(self.Dim): for j in range(self.Dim): if a[i, j] != a[j, i]: QtGui.QMessageBox.warning(None, 'Warning', 'Matrix is asymetric') return x, L, D = sqrt_method(a, b) Dtmp = np.zeros((len(D), len(D))) for i in range(len(D)): Dtmp[i, i] = D[i] tabels = [] tabels.append(genMatrix(L)) tabels.append(genMatrix(Dtmp)) tabels.append(genVector(x)) self.textBrowser.setText(genHtml(tabels, labels=['L', 'D', 'X']).replace('{%det%}','Det(A) = {0}'.format(np.prod(D)))) elif self.methodBox.currentIndex() == 2: C = np.zeros(self.Dim) B = np.zeros(self.Dim) A = np.zeros(self.Dim) for i in range(self.Dim): C[i] = a[i, i] if i!= self.Dim-1: B[i] = a[i, i+1] A[i+1] = a[i+1, i] x = TDMA(A, B, C, b) tabels = [] tabels.append(genVector(x)) self.textBrowser.setText(genHtml(tabels, ['X']).replace('{%det%}','Det(A) = {0}'.format(np.linalg.det(a)))) elif self.methodBox.currentIndex() == 3: inverse = inverse_matrix(a) self.textBrowser.setText(genHtml(np.array([genMatrix(inverse)]), ['Inverse Matrix']).replace('{%det%}', '')) elif self.methodBox.currentIndex() == 4: x0 = np.zeros(self.Dim) for i in range(self.Dim): try: x0[i] = np.float64(self.InputTableWidget.item(i, self.Dim+1).text()) except: continue try: N = np.int32(self.InputTableWidget.item(0, self.Dim+2).text()) except: pass x = jacobi(a, b, N, x0) self.textBrowser.setText(genHtml(np.array([genVector(x)]), ['X']).replace('{%det%}', '')) elif self.methodBox.currentIndex() == 5: try: eps = np.float64(self.InputTableWidget.item(0, self.Dim+1).text()) except: eps = 10**(-10) x, N = seidel(a, b, eps) self.textBrowser.setText(genHtml(np.array([genVector(x)]), ['X']).replace('{%det%}', str(N)))
def solovaystrassen(n,k=2,bases=[],seed=time.time()): if(n&1==0 || n<2): return (n==2) random.seed(time.time()) if(bases==[]): # if bases not given, use random 'a' for i in range(k): a = 0 while(True): # generate 'a' that hasn't been used already a = random.randint(1,n-1) #print "New 'a'" if not (a in bases): break #print a x=jacobi(a,n)%n if x==0 or pow(a,(n-1)/2,n) != x: return False return True else: # if bases given, use bases 'a' from the array basesTested = 0 # makes sure that all bases given are NOT larger than n-1 for a in bases: if a > n-1: continue x=jacobi(a,n) if x==0 or pow(a,(n-1)/2,n) != x: return False basesTested = basesTested+1 if basesTested == 0: return "Bases too large for number to be tested." return True
def test_method(method): d = {} fp, fpe = jacobi(lambda x: x, 0, method=method, diagnostic=d) assert_equal(d["method"], [method]) assert_allclose(fp, 1) assert_allclose(fpe, 0, atol=1e-10) fp, fpe = jacobi(lambda x: x if x >= 0 else np.nan, 0, method=method, diagnostic=d) assert_equal(d["method"], [method]) if method == 1: assert_allclose(fp, 1) assert_allclose(fpe, 0, atol=1e-10) else: assert_equal(fp, np.nan) assert_equal(fpe, np.inf) fp, fpe = jacobi(lambda x: x if x <= 0 else np.nan, 0, method=method, diagnostic=d) assert_equal(d["method"], [method]) if method == -1: assert_allclose(fp, 1) assert_allclose(fpe, 0, atol=1e-10) else: assert_equal(fp, np.nan) assert_equal(fpe, np.inf)
def cfd(iterations, edge, inlet_x, inlet_width, outlet_y, outlet_height, dat_file, quiet=True): """ Run simulation and output stream function data into a file. Keyword arguments: iterations -- number of iterations to update stream function over. edge -- width and height of box. inlet_x -- point on top edge of box where inlet begins. inlet_width -- inlet width. inlet_y -- point on right edge where outlet begins. inlet_height -- outlet height. dat_file -- stream function data output file name. quiet -- if True then no status information is printed. """ width = edge height = edge assert inlet_x <= width assert inlet_x + inlet_width < width assert outlet_y <= height assert outlet_y + outlet_height < height if (not quiet): sys.stdout.write("\n2D CFD Simulation\n") sys.stdout.write("=================\n") sys.stdout.write(" Iterations = {0}\n".format(iterations)) sys.stdout.write(" Edge = {0}\n".format(edge)) sys.stdout.write(" Inlet X = {0}\n".format(inlet_x)) sys.stdout.write(" Inlet width = {0}\n".format(inlet_width)) sys.stdout.write(" Outlet Y = {0}\n".format(outlet_y)) sys.stdout.write("Outlet height = {0}\n".format(outlet_height)) sys.stdout.write("Grid size = {0} x {1}\n".format(width, height)) time_starts = time.time() # Initialise stream function, psi, to 0. psi = [[0 for col in range(width+2)] for row in range(height+2)] # Set the boundary conditions. set_inlet_boundary(psi, width, inlet_x, inlet_width) set_outlet_boundary(psi, width, outlet_y, outlet_height) time_ends = time.time() if (not quiet): sys.stdout.write("\nInitialisation took {0:.5f}s\n".format(time_ends-time_starts)) # Call the Jacobi iterative loop (and calculate timings). if (not quiet): sys.stdout.write("\nStarting main Jacobi loop...\n") time_starts = time.time() jacobi(iterations, psi) time_ends = time.time() if (not quiet): sys.stdout.write("...finished\n") sys.stdout.write("\nCalculation took {0:.5f}s\n\n".format(time_ends-time_starts)) write_data(width, height, psi, dat_file)
def sqrt_mod(a,p): """ Calcula la raiz cuadrada modular de a módulo p Args: a(int): Entero p(int): Entero primo Returns: r(int): Raiz de a modulo p Examples: sqrt_mod(319,353) 242 """ if jacobi(a,p) == -1: return -1 n=1 while jacobi(n,p) != -1: n+=1 u=0 s=p-1 while s%2==0: u=u+1 s=s//2 print(u,s); if u == 1: r=exp_mod(a,(p+1)/4,p) elif u >= 2: r=exp_mod(a,(s+1)/2,p) b=exp_mod(n,s,p) j=0 while j<= u-2: base = (inverso_mod(a,p)*r*r)%p exp = exp_mod(2,u-2-j,p) if exp_mod(base,exp,p) == (-1%p): r=(r*b)%p b=(b*b)%p j+=1 return r
def jacobi_test ( ): #*****************************************************************************80 # ## JACOBI_TEST tests JACOBI. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 16 February 2015 # # Author: # # John Burkardt # from r8mat_print import r8mat_print print '' print 'JACOBI_TEST' print ' JACOBI computes the JACOBI matrix.' m = 4 n = m a = jacobi ( m, n ) r8mat_print ( m, n, a, ' JACOBI matrix:' ) print '' print 'JACOBI_TEST' print ' Normal end of execution.' return
def solovay_stassen(n: int, iterations: int) -> bool: if (n == 1): return False if (n == 2) or (n == 3) or (n == 5): return True if (n % 2 == 0): return False for i in range(iterations): # [0, n-5) -> [0, n-4] -> [2, n-2] b = secrets.randbelow(n - 5) b += 2 r = modular_exp.modular_exp(b, (n - 1) // 2, n) # 如果 r 是 n - 1,把 r 设为 -1,以与 Jacobi 符号匹配 if (r == n - 1): r = -1 if (r != 1) and (r != -1): return False s = jacobi.jacobi(b, n) if (r != s): return False return True
def main(): """Using jacobi's algorithm to estimate the eigenvalues of the Hamiltonian for a one-electron system with a HO-potential.""" N = int(eval(input("Number of grid points: "))) rho_max = 12.5 # 6.25 # setting max value for position. rho = np.linspace(0, rho_max, N) # step-variable. h = (rho[-1] - rho[0]) / N # step size. e = -1 / h**2 # off-diagonal elements. d = 2 / h**2 + rho[1:-1]**2 # diagonal elements. # creating matrix: A = np.diag(d) + sp.diags([e, e], [-1, 1], [N - 2, N - 2]).toarray() mask = np.ones(A.shape, dtype=bool) # creating mask to conceal diagonal. np.fill_diagonal(mask, 0) a = np.linalg.norm(A[mask]) # norm of non-diagonal elements. A = jac.jacobi(A, mask, a, N - 2) # diagonalizing matrix. eigvals = np.sort(np.diag(A))[:4] print(eigvals) # printing first 4 eigenvalues. # print(np.sort(np.linalg.eig(A)[0])[:4]) anal_eigvals = np.array([3, 7, 11, 15]) error = abs((eigvals - anal_eigvals) / anal_eigvals) # relative error. print(error)
def main(): inicializar() M = gauss.gauss(n + 1, Matriz, d) A = parametros.parametroA(x, M, h, n) B = parametros.parametroB(x, M, h, n) print("Sistema resolvido pelo método de Gauss: \n") for i in range(n + 1): print("M[" + str(i) + "]: " + str(M[i]) + "\n") for i in range(n): print("A[" + str(i) + "]: " + str(A[i]) + "\n") for i in range(n): print("B[" + str(i) + "]: " + str(B[i]) + "\n") print("\n") inicializar() M = jacobi.jacobi(n, Matriz, d, 0.00000000000001, 40) A = parametros.parametroA(x, M, h, n) B = parametros.parametroB(x, M, h, n) print("Sistema resolvido pelo método de Jacobi: \n") for i in range(n + 1): print("M[" + str(i) + "]: " + str(M[i]) + "\n") for i in range(n): print("A[" + str(i) + "]: " + str(A[i]) + "\n") for i in range(n): print("B[" + str(i) + "]: " + str(B[i]) + "\n") print("\n")
def PKG(email, p, q): # Calculate modulus n = p * q # Hash the identity a = sha1(email.encode('utf-8')).digest() a_int = int.from_bytes(a, 'big') # Keep hashing id until the jacobi symbol is not equal 1 while jacobi(a_int, n) != 1: a = sha1(a).digest() a_int = int.from_bytes(a, 'big') # Calculate r based on the identity hash, p, q and n r = pow(a_int, (n + 5 - (p + q)) // 8, n) r2 = (r * r) % n # Check that r satisfies the requirements if r2 != (a_int % n) and r2 != (-a_int % n): raise Exception("Error deriving r!") # Return the private key and the hashed identity, fill with 0 if r is not 64 long r = hex(r)[2:].zfill(64) return (r, r2, a, n)
def jacobi_test(): #*****************************************************************************80 # ## JACOBI_TEST tests JACOBI. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 16 February 2015 # # Author: # # John Burkardt # from r8mat_print import r8mat_print print '' print 'JACOBI_TEST' print ' JACOBI computes the JACOBI matrix.' m = 4 n = m a = jacobi(m, n) r8mat_print(m, n, a, ' JACOBI matrix:') print '' print 'JACOBI_TEST' print ' Normal end of execution.' return
def check(N, a, o): alfa = a A = np.zeros((N, N), float) AA = np.zeros((N, N), float) b = np.zeros(N) bb = np.zeros(N, float) x0 = np.zeros(N) A[0, 0] = 2 A[0, 1] = -1 + alfa A[N - 1, N - 1] = 2 A[N - 1, N - 2] = -1 + alfa b[0] = 1 - alfa b[N - 1] = 1 + alfa x0[0] = 0.7 x0[N - 1] = 0.8 for i in range(1, N - 1, 1): A[i, i] = 2 A[i, i + 1] = -1 + alfa A[i, i - 1] = -1 + alfa b[i] = 0 x0[i] = 0.1 * i xj, kj, tj = jacobi.jacobi(A, b, x0, 0.00001, 1000) xjv, kjv, tjv = jacobi.jacobi_vec(A, b, x0, 0.00001, 1000) xs, ks, tjs = seidel.seidel(A, b, x0, 0.00001, 1000) xsv, ksv, tsv = seidel.seidel_vec(A, b, x0, 0.00001, 1000) xsor, ksor, tsor = sor.sor(A, b, x0, o, 0.00001, 1000) xsorv, ksorv, tsorv = sor.sor_vec(A, b, x0, o, 0.00001, 1000) xcg, kcg, tcg = cg.cg(A, b, 0.00001, 1000) return kj, kjv, ks, ksv, ksor, ksorv, kcg
def newton(F,x0,eps=1e-5,alpha=1.05e-4): it=int(1e2) x=np.copy(x0) Fx=F(x) breakit=int(argv[2]) if len(argv) > 2 else 5 residuum2=0 residuum=np.linalg.norm(Fx,np.inf) diff=abs(residuum-residuum2) while residuum > eps and it > 0 and diff > eps and breakit > 0: dFx = jacobi(F, x) # Tikhonov regularisation A = dFx R = np.dot(np.linalg.inv(np.dot(A.T, A) + alpha * np.eye(A.shape[1])), A.T) xalpha = np.dot(R, Fx) x -= xalpha Fx = F(x) residuum2=np.linalg.norm(Fx) diff=abs(residuum-residuum2) if residuum2 > residuum: x+=xalpha Fx=F(x) alpha/=2 alpha=min(1,abs(alpha)) breakit-=1 else: residuum=residuum2 breakit=int(argv[2]) if len(argv) > 2 else 5 it-=1 return x, residuum
def test_method_auto(): d = {} fp, fpe = jacobi(lambda x: x, 0, diagnostic=d) assert_equal(d["method"], [0]) assert_allclose(fp, 1) assert_allclose(fpe, 0, atol=1e-10) fp, fpe = jacobi(lambda x: x if x >= 0 else np.nan, 0, diagnostic=d) assert_equal(d["method"], [1]) assert_allclose(fp, 1) assert_allclose(fpe, 0, atol=1e-10) fp, fpe = jacobi(lambda x: x if x <= 0 else np.nan, 0, diagnostic=d) assert_equal(d["method"], [-1]) assert_allclose(fp, 1) assert_allclose(fpe, 0, atol=1e-10)
def gen_QNR(p, d): ''' generating quardratic residue p -- prime ''' # generate random number g g = random.randrange(2, p) # 1. g has to be quadratic nonresidue # 2. repeat if p = 1 (mod 3) and g^((p-1)/3) = 1 (mod p) ''' while jacobi(g, p) != -1 \ or (p % 3 == 1 and pow(g, (p-1)/3, p) == 1): g = random.randrange(2, p) return g ''' #while True: # g = random.randrange(2, p) for g in bigrange.range(2, p): if jacobi(g, p) != -1: continue if p%3 != 1: return g cube = pow(g, (p-1)/3, p) if cube != 1: if d==-3 and pow(cube, 3, p) != 1: continue return g
def jacob(): data = request.json a = data["a"] b = data["b"] x = data["x"] tol = data["tol"] iters = data["iters"] return dict(jacobi(a, b, x, 2, tol, iters))
def test_jacobi(): A, b = generate_problem(0.5, 3) max_it = 1 x, it = jacobi(A, b, max_it=max_it) expected = np.array([0.25, 1.25, 0.75]) success = (x == expected).any() msg = "x = %s, expected = %s, b = %s, it = %s" % (x, expected, b, it) assert success, msg
def test_convergence(): A, b = generate_problem(0.5, 100) exact = np.linalg.solve(A, b) tol = 1e-15 x, it = jacobi(A, b, tol=tol) error = np.linalg.norm(exact - x) success = (error - tol*np.linalg.norm(A)) < tol msg = "error = %s, tol*norm(A) = %s, " % (error, tol*np.linalg.norm(A)) assert success, msg
def find_max_from_env(inp_matrix): eival, eivect = j.jacobi(inp_matrix) maxim = inp_matrix[0][0] for i in range(1, len(eival)): if eival[i] > maxim: maxim = eival[i] return maxim
def find_min_from_env(inp_matrix): eival, eivect = j.jacobi(inp_matrix) minimal = inp_matrix[0][0] for i in range(1, len(eival)): if eival[i] < minimal: minimal = eival[i] return minimal
def errcon(n, ievt, se, prax): #n - number of phases used to calculate error ellipse (??) #ievt - boolean whether depth was fixed or free (do I know this?) #se - std error from origin quality #prax - Matrix with values: #[minorazimuth minorplunge minorlength; # interazimuth interplunge interlength; # majorazimuth majorplunge majorlength] #output - 2x2 # /* initialize some values */ nFree = 8 tol = 1.0e-15 tol2 = 2.0e-15 m = 3 m1 = 2 m2 = 4 a = np.zeros((2, 2)) s2 = (nFree + (n - m2) * se * se) / (nFree + n - m2) f10 = Fisher10(m, nFree + n - m2) fac = 1.0 / (m * s2 * f10) x = np.zeros((2, 1)) for k in range(0, m): ce = np.cos(DEG2RAD * prax[k][1]) x[0] = -ce * np.cos(DEG2RAD * prax[k][0]) x[1] = ce * np.sin(DEG2RAD * prax[k][0]) ce = fac * prax[k][2] * prax[k][2] for j in range(0, m1): for i in range(0, m1): a[j][i] = a[j][i] + ce * x[i] * x[j] ellipse2d = np.zeros((3, 3)) #we're running into a problem with jacobi - namely, the diagonal values aren't exactly #equal (differ at 15th decimal). We'll round them both to nearest billionth. a[0][1] = text.roundToNearest(a[0][1], 1e-9) a[1][0] = text.roundToNearest(a[0][1], 1e-9) eigenvalue, eigenvector, sweeps = jacobi.jacobi(a) idx = eigenvalue.argsort()[::-1] eigenvalue = eigenvalue[idx] eigenvector = eigenvector[:, idx] for i in range(0, m1): ce = 1.0 if np.fabs(eigenvector[0][i]) + np.fabs(eigenvector[1][i]) > tol2: ellipse2d[i][0] = RAD2DEG * np.arctan2(ce * eigenvector[1][i], -ce * eigenvector[0][i]) if (ellipse2d[i][0] < 0.0): ellipse2d[i][0] += 360.0 ellipse2d[i][2] = np.sqrt(fac * max(eigenvalue[i], 0.0)) return ellipse2d
def exercicio3(): print("Exercicio 3") tol = 10**-8 inicializar() k = util.estimarIteracao(n, Matriz, d, tol) inicializar() y_gauss = gauss.gauss(n, Matriz, d) inicializar() y_jacobi = jacobi.jacobi(n, Matriz, d, tol, k) print("Distância entre y(N) e y* com N=" + str(k) + ": " + str(norma.norma(y_gauss, y_jacobi, n)) + "\n")
def errcon(n,ievt,se,prax): #n - number of phases used to calculate error ellipse (??) #ievt - boolean whether depth was fixed or free (do I know this?) #se - std error from origin quality #prax - Matrix with values: #[minorazimuth minorplunge minorlength; # interazimuth interplunge interlength; # majorazimuth majorplunge majorlength] #output - 2x2 # /* initialize some values */ nFree = 8 tol = 1.0e-15 tol2 = 2.0e-15 m = 3 m1 = 2 m2 = 4 a = np.zeros((2,2)) s2 = (nFree + (n-m2)*se*se)/(nFree + n - m2) f10 = Fisher10(m, nFree + n - m2) fac = 1.0/(m * s2 * f10) x = np.zeros((2,1)) for k in range(0,m): ce = np.cos(DEG2RAD * prax[k][1]) x[0] = -ce * np.cos(DEG2RAD * prax[k][0]) x[1] = ce * np.sin(DEG2RAD * prax[k][0]) ce = fac * prax[k][2] * prax[k][2] for j in range(0,m1): for i in range(0,m1): a[j][i] = a[j][i] + ce * x[i] * x[j] ellipse2d = np.zeros((3,3)) #we're running into a problem with jacobi - namely, the diagonal values aren't exactly #equal (differ at 15th decimal). We'll round them both to nearest billionth. a[0][1] = text.roundToNearest(a[0][1],1e-9) a[1][0] = text.roundToNearest(a[0][1],1e-9) eigenvalue,eigenvector,sweeps = jacobi.jacobi(a) idx = eigenvalue.argsort()[::-1] eigenvalue = eigenvalue[idx] eigenvector = eigenvector[:,idx] for i in range(0,m1): ce = 1.0 if np.fabs(eigenvector[0][i]) + np.fabs(eigenvector[1][i]) > tol2: ellipse2d[i][0] = RAD2DEG * np.arctan2(ce * eigenvector[1][i], -ce * eigenvector[0][i]) if (ellipse2d[i][0] < 0.0): ellipse2d[i][0] += 360.0 ellipse2d[i][2] = np.sqrt(fac * max(eigenvalue[i], 0.0)) return ellipse2d
def random_point(self): """ Returns: A random point on the curve. """ x = random.randrange(self.p) y_square = x**3 + self.a * x + self.b while jacobi(y_square, self.p) == -1: x = random.randrange(self.p) y_square = x**3 + self.a * x + self.b y = modsqrt(y_square, self.p) return x,
def choose_discriminant(n, start=0): ''' First step of Algorithm Args: n: start: Returns: d: The discriminant ms: The possible orders ''' d = gen_discriminant(start) uv = cornacchia_smith(n, d) jac = jacobi(d, n) if jac == 0: raise ValueError("n is not prime.") while jac != 1 or uv is None: if n % d == 0: raise ValueError("n is not prime.") d = gen_discriminant(d) if d < -10**6: raise ValueError("Discriminant cannot be found under bound 10^7.") uv = cornacchia_smith(n, d) jac = jacobi(d, n) if jac == 0: raise ValueError("n is not prime.") u, v = uv default = [n+1+u, n+1-u] if d == -4: ms = default + [n+1+2*v, n+1-2*v] elif d == -3: ms = default + [n+1+(u+3*v)/2, n+1-(u+3*v)/2, n+1+(u-3*v)/2, n+1-(u-3*v)/2] else: ms = default return d, ms
def cb_angles(data): global thetas global torque_arr global last_time # thetas = data.data thetas[0] = (data.data[0] - ZERO_OFFSET) * POS2RAD thetas[1] = (data.data[1] - ZERO_OFFSET) * POS2RAD thetas[2] = (data.data[2] - ZERO_OFFSET) * POS2RAD j_mat = jacobi(thetas) force = force_calc(j_mat, torque_arr, thetas) force_msg.data = force rospy.loginfo(force_msg) pub_torque.publish(force_msg)
def jacobiVsGE(): for i in [10, 25, 70, 100, 500]: mat = symmPosDefMat(i) vec = [[1] for j in range(i)] time0 = time.time() x, count = jacobi(mat, vec, vec, .0001, 10000, True) print("A matrix of size " + str(i) + " by " + str(i) + " takes Jacobi's method " + str(time.time() - time0) + " seconds to converge after " + str(count) + " iterations.") time1 = time.time() x = matGE(mat, vec) print("A matrix of size " + str(i) + " by " + str(i) + " takes the Gaussian Elimination method " + str(time.time() - time1) + " seconds to solve.")
def jacobiVsCG(): for i in [10, 25, 70, 100, 500]: mat = symmPosDefMat(i) vec = [[1] for j in range(i)] time0 = time.time() x, count = jacobi(mat, vec, vec, .0001, 10000, True) print("A matrix of size " + str(i) + " by " + str(i) + " takes Jacobi's method " + str(time.time() - time0) + " seconds to converge after " + str(count) + " iterations.") time1 = time.time() x, count, error = conGradient(mat, vec, vec, .0001, 10000, True) print("A matrix of size " + str(i) + " by " + str(i) + " takes the Conjugate Gradient method " + str(time.time() - time1) + " seconds to converge after " + str(count) + " iterations.") return
def generate_curve(p, d): ''' Essentially Algorithm 7.5.9 Args: p: Returns: parameters a, b for the curve ''' # calculate quadratic nonresidue g = gen_QNR(p, d) # find discriminant new_d = gen_discriminant(0) uv = cornacchia_smith(p, new_d) while jacobi(new_d, p) != 1 or uv is None: new_d = gen_discriminant(new_d) uv = cornacchia_smith(p, new_d) u, v = uv # storing the result of cornacchia. u^2 + v^2 * |D| = 4*p # check for -d = 3 or 4 # Choose one possible output # Look at param_gen for comparison. answer = [] if new_d == -3: x = -1 for i in range(0, 6): answer.append((0, x)) x = (x * g) % p return answer if new_d == -4: x = -1 for i in range(0, 4): answer.append((x, 0)) x = (x * g) % p return answer # otherwise compute the hilbert polynomial _, t, _ = hilbert(new_d) s = [i % p for i in t] j = equation.root_Fp(s, p) # Find a root for s in Fp. Algorithm 2.3.10 c = j * inverse(j - 1728, p) % p r = -3 * c % p s = 2 * c % p return [(r, s), (r * g * g % p, s * (g**3) % p)]
def cb_angles(data): global thetas global tourqe_arr global last_time # thetas = data.data thetas[0] = (data.data[0] - ZERO_OFFSET) * POS2RAD # <TODO> modulo or subtraction ? thetas[1] = (data.data[1] - ZERO_OFFSET) * POS2RAD thetas[2] = (data.data[2] - ZERO_OFFSET) * POS2RAD j_mat = jacobi(thetas) force = force_calc(j_mat, tourqe_arr, thetas) force_msg.data = force rospy.loginfo(force_msg) pub_tourqe.publish(force_msg) create(force, 'force.csv') # write to file create(tourqe_arr, 'tourqe.csv') # write to file
def deflect(n): x, b = load(n) A = cstruc(n) print(A) ya, itr = jacobi(A, b, np.zeros(n)) #yxv = np.vectorize(yx) #ye = yxv(x) #con = LA.cond(A, np.inf) return x, ya
def curve_parameters(d, p): ''' Modified Algorithm 7.5.9 for the use of ecpp Args: d: discriminant p: number for prime proving Returns: a list of (a, b) parameters for ''' g = gen_QNR(p, d) #g = nzmath.ecpp.quasi_primitive(p, d==-3) u, v = cornacchia_smith(p, d) # go without the check for result of cornacchia because it's done by previous methods. if jacobi(d, p) != 1: raise ValueError('jacobi(d, p) not equal to 1.') # check for -d = 3 or 4 # Choose one possible output # Look at param_gen for comparison. answer = [] if d == -3: x = -1 % p for i in range(0, 6): answer.append((0, x)) x = (x * g) % p return answer if d == -4: x = -1 % p for i in range(0, 4): answer.append((x, 0)) x = (x * g) % p return answer # otherwise compute the hilbert polynomial _, t, _ = hilbert(d) s = [int(i % p) for i in t] j = equation.root_Fp(s, p) # Find a root for s in Fp. Algorithm 2.3.10 c = j * inverse(j - 1728, p) % p r = -3 * c % p s = 2 * c % p return [(r, s), (r * g * g % p, s * (g**3) % p)]
def test_jacobi_orthogonality(n): """ Tests if the orthogonality is preserved for the eigenvectors calculated by the Jacobi method Input: n - size of matrix """ A = make_matrix(n, 1) eigval_np, teigvec_np = np.linalg.eig(A) eigval_J, eigvec_J, a, r, t = jacobi(A) err = 1E-5 assert 1 - np.dot(eigvec_J[0], eigvec_J[0]) <= err assert np.dot(eigvec_J[0], eigvec_J[1]) <= err assert 1 - np.dot(eigvec_J[3], eigvec_J[3]) <= err assert np.dot(eigvec_J[3], eigvec_J[1]) <= err print('test_jacobi_eigvec passed')
def test_largest_elem(n): """ Tests if the largest element on the non-diagonal that was picked on the last iteration in the Jacobi method was indeed the largest element on the rotated matrix Input: n - size of matrix """ A = make_matrix(n, 1) eigval_J, eigvec_J, AMax, r, t = jacobi(A) maxelem = 0.0 for i in range(n): for j in range(i + 1, n): if abs(A[i, j]) >= maxelem: maxelem = abs(A[i, j]) assert maxelem == AMax print('test_largest_elem passed')
def cornacchia_smith(p, d): ''' modified Cornacchia's Algorithm to solve a^2 + b^2 |D| = 4p for a and b Args: p: d: Returns: a, b such that a^2 + b^2 |D| = 4p ''' # check input if not -4 * p < d < 0: raise ValueError(" -4p < D < 0 not true.") elif not (d % 4 in {0, 1}): raise ValueError(" D = 0, 1 (mod 4) not true.") # case where p=2 if p == 2: r = sqrt(d + 8) if r != -1: return r, 1 else: return None # test for solvability if jacobi(d % p, p) < 1: return None x = modsqrt(d, p) if (x % 2) != (d % 2): x = p - x # euclid chain a, b = (2 * p, x) c = floorsqrt(4 * p) while b > c: a, b = b, a % b t = 4 * p - b * b if t % (-d) != 0: return None if not issquare(t / (-d)): return None return b, int(mpmath.sqrt(t / -d))
def jacobi_determinant_test(): #*****************************************************************************80 # ## JACOBI_DETERMINANT_TEST tests JACOBI_DETERMINANT. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 16 February 2015 # # Author: # # John Burkardt # from jacobi import jacobi from r8mat_print import r8mat_print print '' print 'JACOBI_DETERMINANT_TEST' print ' JACOBI_DETERMINANT computes the determinant of the JACOBI matrix.' print '' m = 4 n = m a = jacobi(m, n) r8mat_print(m, n, a, ' JACOBI matrix:') value = jacobi_determinant(n) print '' print ' Value = %g' % (value) print '' print 'JACOBI_DETERMINANT_TEST' print ' Normal end of execution.' return
def jacobi_determinant_test ( ): #*****************************************************************************80 # ## JACOBI_DETERMINANT_TEST tests JACOBI_DETERMINANT. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 16 February 2015 # # Author: # # John Burkardt # from jacobi import jacobi from r8mat_print import r8mat_print print '' print 'JACOBI_DETERMINANT_TEST' print ' JACOBI_DETERMINANT computes the determinant of the JACOBI matrix.' print '' m = 4 n = m a = jacobi ( m, n ) r8mat_print ( m, n, a, ' JACOBI matrix:' ) value = jacobi_determinant ( n ) print '' print ' Value = %g' % ( value ) print '' print 'JACOBI_DETERMINANT_TEST' print ' Normal end of execution.' return
def test_jacobi_eigvec(n): """ Tests if the Jacobi method yields the same eigenvalues as numpy.linalg.eig and the analytical eigenvalues Input: n - size of matrix """ A = make_matrix(n, 1) eigval = analytical_eig(A) eigval_np, teigvec_np = np.linalg.eig(A) eigval_J, eigvec_J, a, r, t = jacobi(A) np.testing.assert_allclose( sorted(eigval), sorted(eigval_np), rtol=1e-08, atol=0) #rtol - relative tolerance, atol - absolute tolerance np.testing.assert_allclose(sorted(eigval), sorted(eigval_J), rtol=1e-08, atol=0) print('test_jacobi_eigvec passed')
def choose_point(ec): """ Choose a random point on EC. Adapted from random_point function. With the additional check for modsqrt. Args: ec: an elliptic curve by the equation y^2 = x^3 + a * x + b Returns: a valid point on the curve. """ x = random.randrange(ec.p) y_square = (x**3 + ec.a * x + ec.b) % ec.p while jacobi(y_square, ec.p) == -1: x = random.randrange(ec.p) y_square = (x**3 + ec.a * x + ec.b) % ec.p y = modsqrt(y_square, ec.p) if (y**2 % ec.p) != y_square: raise ValueError("Error computing square root.") return x, y
def main(): """Using jacobi's algorithm to estimate the eigenvalues of the Hamiltonian for a non-interacting, two-electron system with a HO-potential.""" N = int(eval(input("Number of grid points: "))) rho_max = 15.794 rho = np.linspace(0, rho_max, N) # step-variable. h = (rho[-1]-rho[0])/N # step size. omega_r = int(eval(input("Omega_r: "))) e = -1/h**2 # off-diagonal elements. d = 2/h**2 + (omega_r**2)*rho[1:-1]**2 + 1/rho[1:-1] # diagonal elements. # creating matrix: A = np.diag(d) + sp.diags([e, e], [-1, 1], [N-2, N-2]).toarray() mask = np.ones(A.shape, dtype=bool) # creating mask to conceal diagonal. np.fill_diagonal(mask, 0) a = np.linalg.norm(A[mask]) # norm of non-diagonal elements. A = jac.jacobi(A, mask, a, N-2) # finding eigenvalues. print(np.sort(np.diag(A))[0]) # printing lowest eigenvalue.
import jacobi n = 69 epps = list() for a in [3, 11, 22, 68]: js = jacobi.jacobi(a,n) if (js%n != 0) and (a**((n-1)/2)%n == js %n): epps.append(a) print epps
#main import jacobi M=[[3,1],[1,7]] print 'matrix som diagonaliseres' print M [A,V,c] = jacobi.jacobi(M) print 'egenvaerdierne' print A a1=5+5**0.5 a2=5-5**0.5 print 'The precise eigenvalues are 5+-sqrt(5)='+str(a2)+', '+str(a1) print 'number of sweeps' print c print 'with eps of 1e-12' M=[[1,2,3],[2,4,-5],[3,-5,6]] print 'matrix som diagonaliseres' print M [A,V,c] = jacobi.jacobi(M) print 'egenvaerdierne' print A print 'antallet af sweeps' print c