def _testme(): from scipy.sparse import csc_matrix from numpy import array from scipy.linsolve import spdiags, spsolve, use_solver print "Inverting a sparse linear system:" print "The sparse matrix (constructed from diagonals):" a = spdiags([[1, 2, 3, 4, 5], [6, 5, 8, 9, 10]], [0, 1], 5, 5) b = array([1, 2, 3, 4, 5]) print "Solve: single precision complex:" use_solver( useUmfpack = False ) a = a.astype('F') x = spsolve(a, b) print x print "Error: ", a*x-b print "Solve: double precision complex:" use_solver( useUmfpack = True ) a = a.astype('D') x = spsolve(a, b) print x print "Error: ", a*x-b print "Solve: double precision:" a = a.astype('d') x = spsolve(a, b) print x print "Error: ", a*x-b print "Solve: single precision:" use_solver( useUmfpack = False ) a = a.astype('f') x = spsolve(a, b.astype('f')) print x print "Error: ", a*x-b
def levenberg_iteration(z, z_p, z_l, x_p, x_l, f_p, f_l, C, lamb): """ """ x = build_zx(x_p, x_l) J = build_jacobian(z, x_p, x_l, f_p, f_l) #J = build_jacobian_numeric(z, x_p,x_l,f_p,f_l) Jsp = J.tocsr() Csp = C.tocsr() alpha = Jsp.T.dot(Csp.dot(Jsp)) fy_i = [] for i, f in zip(z_p, f_p): l1 = matrix([i[0], i[1], i[2]]).T l2 = f[0](x_p[f[1]], x_p[f[2]]) result = l1 - l2 fy_i += result.T.tolist()[0] for i, f in zip(z_l, f_l): l1 = matrix([[i[0]], [i[1]]]) l2 = f[0](x_p[f[1]], x_l[f[2]]) result = l1 - l2 fy_i += result.T.tolist()[0] fy_i = array(fy_i, dtype=float64).T beta = Jsp.T.dot(Csp.dot(fy_i)) # Augmented alpha alpha.setdiag(sparse.extract_diagonal(alpha) * (1 + lamb)) #### sparse solver return linsolve.spsolve(alpha, beta)
def check_solve_sparse_rhs(self): """Solve with UMFPACK: double precision, sparse rhs""" linsolve.use_solver( useUmfpack = True ) a = self.a.astype('d') b = csc_matrix( self.b ) x = linsolve.spsolve(a, b) #print x #print "Error: ", a*x-b assert_array_almost_equal(a*x, self.b)
def check_solve_umfpack(self): """Solve with UMFPACK: double precision""" linsolve.use_solver( useUmfpack = True ) a = self.a.astype('d') b = self.b x = linsolve.spsolve(a, b) #print x #print "Error: ", a*x-b assert_array_almost_equal(a*x, b)
def check_solve_without_umfpack(self): """Solve: single precision""" linsolve.use_solver( useUmfpack = False ) a = self.a.astype('f') b = self.b x = linsolve.spsolve(a, b.astype('f')) #print x #print "Error: ", a*x-b assert_array_almost_equal(a*x, b)
def GetEigSparse(D, e1, e2, w): w -= dot(w, e1) * e1 / dot(e1, e1) w -= dot(w, e2) * e2 / dot(e2, e2) for i in range(3): w = linsolve.spsolve(D, w) w -= dot(w, e1) * e1 / dot(e1, e1) w -= dot(w, e2) * e2 / dot(e2, e2) w /= dot(w, w)**.5 return w
def GetEigSparse(D, e1, e2, w): w -= dot(w,e1) * e1 / dot(e1,e1) w -= dot(w,e2) * e2 / dot(e2,e2) for i in range(3): w = linsolve.spsolve(D,w) w -= dot(w,e1) * e1 / dot(e1,e1) w -= dot(w,e2) * e2 / dot(e2,e2) w /= dot(w,w)**.5 return w
def solve(self, rhs): ij = vstack((self.x_l,self.y_l)) #print "ij", ij #print "data ", self.data_l mtx = sparse.coo_matrix((self.data_l,ij)) mtx.tocsr() ts_solve_s = time() u_vct = linsolve.spsolve( mtx, rhs ) ts_solve_e = time() dif_solve = ts_solve_e - ts_solve_s print "Sparse Solve: %8.2f sec" %dif_solve return u_vct
def eval( self, e = None ): if not self.sync_resp_tracing: self.rtrace_mngr.start_timer() adap = self.adap tstepper = self.ts self.setup() self.ls_counter = 0 # Measure computation time self.eval_timer.reset() # Register the list of variables requrired by the adaptive # strategy in the time stepper to include their evaluation in # the corrector-predictor evaluation ts.extend_output_list( # adap.get_indicator_list() ) # while self.t_n1 <= self.T.max and not self.user_wants_abort: self.iter_timer.reset() if LOGGING_ON: log.info( '===================================') log.info('time t_n1 = %f',self.t_n1) self.ls_counter += 1 self.report_load_step() self.k = 0 step_flag = 'predictor' while self.k < self.KMAX: self.report_iteration() # Extract the matrix representation of the time t_n1 # stepper for the given time and control variable u # self.crpr_timer.reset() self.K, self.F_int, self.F_ext = tstepper.eval( step_flag, self.U_k, self.t_n, self.t_n1 ) #self.K = sparse.csr_matrix(K_full) self.crpr_timer.record() self.rtrace_mngr_timer.reset() self.rtrace_mngr.record_iter( self.U_k ) self.rtrace_mngr_timer.record() if adap.ihandler_needed(): adap.ihandler_invoke() self.d_t *= adap.ihandler_get_scale() self.t_n1 = self.t_n + self.d_t step_flag = 'predictor' self.k = 0 if LOGGING_ON: log.info( "redo time step" ) continue self.R_k = self.F_ext - self.F_int if norm(self.R_k) < self.tolerance: # convergence satisfied self.n_reset = 0 if LOGGING_ON: log.info( "time step equilibrated in %d step(s)", self.k ) break # update_switch -> on self.solv_timer.reset() #self.d_U = solve(self.K,self.R_k) #s_solve = linsolve.factorized(self.K) #self.d_U = s_solve(self.R_k) self.d_U = linsolve.spsolve(self.K,self.R_k) # DG_k * d_U = r self.solv_timer.record() self.U_k += self.d_U self.k += 1 self.tot_k += 1 self.ttot_k += 1 step_flag = 'corrector' else: # handling nonconverged step if LOGGING_ON: log.info("no convergence reached - refinement in time") self.n_reset = self.n_reset + 1 # adaptive strategy halving d_t if self.n_reset > self.RESETMAX: # max number of resets achieved # Handle this situation with an exception with an # associated dialog box and concise report of the # iteration process # # @TODO raise the NoConvergence exception if not self.sync_resp_tracing: self.rtrace_mngr.stop_timer() self.rtrace_mngr.timer_tick() return self.d_t *= adap.fhandler_get_scale() self.t_n1 = self.t_n + self.d_t if LOGGING_ON: log.info("redo time step with dt = %s", ) continue self.iter_timer.record() #self.mem_counter.record() if self.sync_resp_tracing: self.rtrace_mngr.timer_tick() if adap.ehandler_needed(): # explicit adaptations if adap.ehandler_accept(): # accept equilibrium? self.accept_time_step() # register the state and response adap.ehandler_invoke() else: self.accept_time_step() self.d_t *= adap.ehandler_get_scale() self.t_n = self.t_n1 self.t_n1 = self.t_n + self.d_t self.T.val = self.t_n1 # Report computation time # self.eval_timer.record() self.eval_timer.report() if not self.sync_resp_tracing: self.rtrace_mngr.stop_timer() self.rtrace_mngr.timer_tick() return
b = array([12,15,20]) Afull[ix_(a),ix_(a)]=1. Asp[a,b] = 1. Bsp = Asp + Asp #print Asp[ix_(a),ix_(b)] Asp[2,:] = 3 Bsp = Asp + Asp #Asp[ix_(a),5]=1. print "after" b = arange(1,1001) Asp = Asp.astype('d') xsp = linsolve.spsolve(Asp,b) print xsp print "finished" Asp = sparse.dok_matrix((4,4)) Asp[2,:] = 5 Bsp = Asp + Asp Asp[3,2] = 8 print 'col 2', Asp.getcol(2) Bsp = Bsp + Asp print 'Asp' print Bsp[3,1]
def pde_interval(self, start, end): """ compute the density evolution for the given interval """ # length of the time interval U = end - start # final density matrix for this interval P_vt = zeros((self.W + 1, U)) # set initial value if self.debug: print "W", self.W print "U", U print P_vt P_vt[self.V_reset_index, 0] = 1 for t in xrange(U - 1): # V_rest as defined by lif V_rest = self.lif.V_rest(start + t) # A B and C diagonals of Lambda A = zeros(self.W - 2) B = zeros(self.W - 1) C = zeros(self.W - 2) # now we go and fill the matrix in a, b, c, u, w = self.a, self.b, self.c, self.u, self.w b_array = self.lif.g * (self.V_values[1:-1] / 2 - V_rest) #here we scrapped the for loop, yes! #but scrapped readability, no! A[:] = -(2 * a * u + b_array[:] * w * u) B[:] = ((4 * a * u) - (2 * c * w**2 * u) + (4 * w**2)) C[:] = -(2 * a * u - b_array[:] * w * u) self.beta[1:-1] = (2*a*u + b_array[1:]*w*u) * P_vt[3:-1,t] + \ (-4*a*u + 2*c*w**2*u + 4*w**2) * P_vt[2:-2,t] + \ (2*a*u - b_array[:-1]*w*u) * P_vt[1:-3,t] # now we set the diagonals of the tridiagonal matrix self.Lambda.setdiag(A, 1) self.Lambda.setdiag(B) self.Lambda.setdiag(C, -1) if self.debug: print "A :", A print "B :", B print "C :", C print "Lambda: ", self.Lambda.todense() print "Lambda22: ", Lambda2.todense() print "beta: ", self.beta chi = linsolve.spsolve(self.Lambda, self.beta) if self.debug: print "chi:", chi print "sumchi", chi.sum() P_vt[1:-1, t + 1] = chi[:] if self.debug: print "P_vt: ", P_vt return P_vt
def solve(self, rhs): return linsolve.spsolve( self.mtx, rhs )
QuickJacobian(x, Nb, Links, Tethers, D) Dsp = sparse.csc_matrix(array(D)) _f = _FiberForce (Nb, x, Xss, Yss, Links, Tethers) f = F - _f e3 = 0. * x z = x - e1 * x[Parts[7][0]] - e2 * x[Parts[7][0]+Nb] for p in range(2,7): for i in Parts[p]: e3[i] = z[i+Nb] e3[i+Nb] = -z[i] f -= e3 * dot(f,e3) / dot(e3,e3) y = linsolve.spsolve(Dsp,f) y -= e3 * dot(y,e3) / dot(e3,e3) damp = 1 x += damp * y subMax = max(list(abs(f))) print " submax:",subMax, " damp:",damp f = _FiberForce (Nb, x, Xss, Yss, Links, Tethers) r = b + dot(dt*A,f) - x # clf(); plot(r); #&&raw_input("") MaxRes = max(list(abs(r)))