def test_cornercase(self): np.random.seed(1234) # Rounding error may prevent convergence with tol=0 --- ensure # that the return values in this case are correct, and no # exceptions are raised for n in [3, 5, 10, 100]: A = 2*eye(n) b = np.ones(n) x, info = lgmres(A, b, maxiter=10) assert_equal(info, 0) assert_allclose(A.dot(x) - b, 0, atol=1e-14) x, info = lgmres(A, b, tol=0, maxiter=10) if info == 0: assert_allclose(A.dot(x) - b, 0, atol=1e-14) b = np.random.rand(n) x, info = lgmres(A, b, maxiter=10) assert_equal(info, 0) assert_allclose(A.dot(x) - b, 0, atol=1e-14) x, info = lgmres(A, b, tol=0, maxiter=10) if info == 0: assert_allclose(A.dot(x) - b, 0, atol=1e-14)
def test_breakdown_underdetermined(self): # Should find LSQ solution in the Krylov span in one inner # iteration, despite solver breakdown from nilpotent A. A = np.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 0, 0, 0]], dtype=float) bs = [ np.array([1, 1, 1, 1]), np.array([1, 1, 1, 0]), np.array([1, 1, 0, 0]), np.array([1, 0, 0, 0]), ] for b in bs: with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") xp, info = lgmres(A, b, maxiter=1) resp = np.linalg.norm(A.dot(xp) - b) K = np.c_[b, A.dot(b), A.dot(A.dot(b)), A.dot(A.dot(A.dot(b)))] y, _, _, _ = np.linalg.lstsq(A.dot(K), b, rcond=-1) x = K.dot(y) res = np.linalg.norm(A.dot(x) - b) assert_allclose(resp, res, err_msg=repr(b))
def test_arnoldi(self): np.random.rand(1234) A = eye(2000) + rand(2000, 2000, density=5e-4) b = np.random.rand(2000) # The inner arnoldi should be equivalent to gmres with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") x0, flag0 = lgmres(A, b, x0=zeros(A.shape[0]), inner_m=15, maxiter=1) x1, flag1 = gmres(A, b, x0=zeros(A.shape[0]), restart=15, maxiter=1) assert_equal(flag0, 1) assert_equal(flag1, 1) assert_(np.linalg.norm(A.dot(x0) - b) > 4e-4) assert_allclose(x0, x1)
def test_nans(self): A = eye(3, format='lil') A[1,1] = np.nan b = np.ones(3) x, info = lgmres(A, b, tol=0, maxiter=10) assert_equal(info, 1)
def test_breakdown_underdetermined(self): # Should find LSQ solution in the Krylov span in one inner # iteration, despite solver breakdown from nilpotent A. A = np.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 0, 0, 0]], dtype=float) bs = [ np.array([1, 1, 1, 1]), np.array([1, 1, 1, 0]), np.array([1, 1, 0, 0]), np.array([1, 0, 0, 0]), ] for b in bs: xp, info = lgmres(A, b, maxiter=1) resp = np.linalg.norm(A.dot(xp) - b) K = np.c_[b, A.dot(b), A.dot(A.dot(b)), A.dot(A.dot(A.dot(b)))] y, _, _, _ = np.linalg.lstsq(A.dot(K), b) x = K.dot(y) res = np.linalg.norm(A.dot(x) - b) assert_allclose(resp, res, err_msg=repr(b))
def test_breakdown_underdetermined(self): # Should find LSQ solution in the Krylov span in one inner # iteration, despite solver breakdown from nilpotent A. A = np.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 0, 0, 0]], dtype=float) bs = [ np.array([1, 1, 1, 1]), np.array([1, 1, 1, 0]), np.array([1, 1, 0, 0]), np.array([1, 0, 0, 0]), ] for b in bs: with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") xp, info = lgmres(A, b, maxiter=1) resp = np.linalg.norm(A.dot(xp) - b) K = np.c_[b, A.dot(b), A.dot(A.dot(b)), A.dot(A.dot(A.dot(b)))] y, _, _, _ = np.linalg.lstsq(A.dot(K), b, rcond=-1) x = K.dot(y) res = np.linalg.norm(A.dot(x) - b) assert_allclose(resp, res, err_msg=repr(b))
def do_solve(**kw): count[0] = 0 with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") x0, flag = lgmres(A, b, x0=zeros(A.shape[0]), inner_m=6, tol=1e-14, **kw) count_0 = count[0] assert_(allclose(A@x0, b, rtol=1e-12, atol=1e-12), norm(A@x0-b)) return x0, count_0
def do_solve(**kw): count[0] = 0 with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") x0, flag = lgmres(A, b, x0=zeros(A.shape[0]), inner_m=6, tol=1e-14, **kw) count_0 = count[0] assert_(allclose(A*x0, b, rtol=1e-12, atol=1e-12), norm(A*x0-b)) return x0, count_0
def test_nans(self): A = eye(3, format='lil') A[1, 1] = np.nan b = np.ones(3) with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") x, info = lgmres(A, b, tol=0, maxiter=10) assert_equal(info, 1)
def test_nans(self): A = eye(3, format='lil') A[1, 1] = np.nan b = np.ones(3) with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") x, info = lgmres(A, b, tol=0, maxiter=10) assert_equal(info, 1)
def test_breakdown_with_outer_v(self): A = np.array([[1, 2], [3, 4]], dtype=float) b = np.array([1, 2]) x = np.linalg.solve(A, b) v0 = np.array([1, 0]) # The inner iteration should converge to the correct solution, # since it's in the outer vector list xp, info = lgmres(A, b, outer_v=[(v0, None), (x, None)], maxiter=1) assert_allclose(xp, x, atol=1e-12)
def test_denormals(self): # Check that no warnings are emitted if the matrix contains # numbers for which 1/x has no float representation, and that # the solver behaves properly. A = np.array([[1, 2], [3, 4]], dtype=float) A *= 100 * np.nextafter(0, 1) b = np.array([1, 1]) xp, info = lgmres(A, b) if info == 0: assert_allclose(A.dot(xp), b)
def test_breakdown_with_outer_v(self): A = np.array([[1, 2], [3, 4]], dtype=float) b = np.array([1, 2]) x = np.linalg.solve(A, b) v0 = np.array([1, 0]) # The inner iteration should converge to the correct solution, # since it's in the outer vector list with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") xp, info = lgmres(A, b, outer_v=[(v0, None), (x, None)], maxiter=1) assert_allclose(xp, x, atol=1e-12)
def fd_solve(self): """ w = fd_solve() where coeff is the sparse coefficient matrix output from function coeff_matrix and qs is the array of loads (stresses) Sparse solver for one-dimensional flexure of an elastic plate """ if self.Debug: print("qs", self.qs.shape) print("Te", self.Te.shape) self.calc_max_flexural_wavelength() print( "maxFlexuralWavelength_ncells', self.maxFlexuralWavelength_ncells" ) if self.Solver == "iterative" or self.Solver == "Iterative": if self.Debug: print( "Using generalized minimal residual method for iterative solution" ) if self.Verbose: print("Converging to a tolerance of", self.iterative_ConvergenceTolerance, "m between iterations") # qs negative so bends down with positive load, bends up with neative load # (i.e. material removed) w = isolve.lgmres(self.coeff_matrix, -self.qs, tol=self.iterative_ConvergenceTolerance) self.w = w[0] # Reach into tuple to get my array back else: if self.Solver == 'direct' or self.Solver == 'Direct': if self.Debug: print("Using direct solution with UMFpack") else: print("Solution type not understood:") print("Defaulting to direct solution with UMFpack") # UMFpack is now the default, but setting true just to be sure in case # anything changes # qs negative so bends down with positive load, bends up with neative load # (i.e. material removed) self.w = spsolve(self.coeff_matrix, -self.qs, use_umfpack=True) if self.Debug: print("w.shape:") print(self.w.shape) print("w:") print(self.w)
def test_breakdown_with_outer_v(self): A = np.array([[1, 2], [3, 4]], dtype=float) b = np.array([1, 2]) x = np.linalg.solve(A, b) v0 = np.array([1, 0]) # The inner iteration should converge to the correct solution, # since it's in the outer vector list with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") xp, info = lgmres(A, b, outer_v=[(v0, None), (x, None)], maxiter=1) assert_allclose(xp, x, atol=1e-12)
def test_arnoldi(self): np.random.rand(1234) A = eye(10000) + rand(10000,10000,density=1e-4) b = np.random.rand(10000) # The inner arnoldi should be equivalent to gmres x0, flag0 = lgmres(A, b, x0=zeros(A.shape[0]), inner_m=15, maxiter=1) x1, flag1 = gmres(A, b, x0=zeros(A.shape[0]), restart=15, maxiter=1) assert_equal(flag0, 1) assert_equal(flag1, 1) assert_(np.linalg.norm(A.dot(x0) - b) > 1e-3) assert_allclose(x0, x1)
def test_denormals(self): # Check that no warnings are emitted if the matrix contains # numbers for which 1/x has no float representation, and that # the solver behaves properly. A = np.array([[1, 2], [3, 4]], dtype=float) A *= 100 * np.nextafter(0, 1) b = np.array([1, 1]) with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") xp, info = lgmres(A, b) if info == 0: assert_allclose(A.dot(xp), b)
def test_denormals(self): # Check that no warnings are emitted if the matrix contains # numbers for which 1/x has no float representation, and that # the solver behaves properly. A = np.array([[1, 2], [3, 4]], dtype=float) A *= 100 * np.nextafter(0, 1) b = np.array([1, 1]) with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") xp, info = lgmres(A, b) if info == 0: assert_allclose(A.dot(xp), b)
def test_arnoldi(self): np.random.rand(1234) A = eye(2000) + rand(2000, 2000, density=5e-4) b = np.random.rand(2000) # The inner arnoldi should be equivalent to gmres with suppress_warnings() as sup: sup.filter(DeprecationWarning, ".*called without specifying.*") x0, flag0 = lgmres(A, b, x0=zeros(A.shape[0]), inner_m=15, maxiter=1) x1, flag1 = gmres(A, b, x0=zeros(A.shape[0]), restart=15, maxiter=1) assert_equal(flag0, 1) assert_equal(flag1, 1) assert_(np.linalg.norm(A.dot(x0) - b) > 4e-4) assert_allclose(x0, x1)
def fd_solve(self): """ w = fd_solve() where coeff is the sparse coefficient matrix output from function coeff_matrix and qs is the array of loads (stresses) Sparse solver for one-dimensional flexure of an elastic plate """ if self.Debug: print('qs', self.qs.shape) print('Te', self.Te.shape) self.calc_max_flexural_wavelength() print('maxFlexuralWavelength_ncells', self.maxFlexuralWavelength_ncells) if self.Solver == "iterative" or self.Solver == "Iterative": if self.Debug: print("Using generalized minimal residual method for iterative solution") if self.Verbose: print("Converging to a tolerance of", self.iterative_ConvergenceTolerance, "m between iterations") # qs negative so bends down with positive load, bends up with neative load # (i.e. material removed) w = isolve.lgmres(self.coeff_matrix, -self.qs, tol=self.iterative_ConvergenceTolerance) self.w = w[0] # Reach into tuple to get my array back else: if self.Solver == "direct" or self.Solver == "Direct": if self.Debug: print("Using direct solution with UMFpack") else: print("Solution type not understood:") print("Defaulting to direct solution with UMFpack") # UMFpack is now the default, but setting true just to be sure in case # anything changes # qs negative so bends down with positive load, bends up with neative load # (i.e. material removed) self.w = spsolve(self.coeff_matrix, -self.qs, use_umfpack=True) if self.Debug: print("w.shape:") print(self.w.shape) print("w:") print(self.w)
def do_solve(**kw): count[0] = 0 x0, flag = lgmres(A, b, x0=zeros(A.shape[0]), inner_m=6, tol=1e-14, **kw) count_0 = count[0] assert_(allclose(A*x0, b, rtol=1e-12, atol=1e-12), norm(A*x0-b)) return x0, count_0