[Scipy-svn] r3658 - in trunk/scipy/sandbox/multigrid: . multigridtools tests
scipy-svn at scipy.org
scipy-svn at scipy.org
Fri Dec 14 18:31:10 EST 2007
Author: wnbell
Date: 2007-12-14 17:31:02 -0600 (Fri, 14 Dec 2007)
New Revision: 3658
Modified:
trunk/scipy/sandbox/multigrid/adaptive.py
trunk/scipy/sandbox/multigrid/dec_test.py
trunk/scipy/sandbox/multigrid/multigridtools/README.txt
trunk/scipy/sandbox/multigrid/multilevel.py
trunk/scipy/sandbox/multigrid/rs.py
trunk/scipy/sandbox/multigrid/sa.py
trunk/scipy/sandbox/multigrid/tests/test_adaptive.py
trunk/scipy/sandbox/multigrid/tests/test_sa.py
trunk/scipy/sandbox/multigrid/tests/test_utils.py
trunk/scipy/sandbox/multigrid/utils.py
Log:
updated multigrid to use shape instead of dims
Modified: trunk/scipy/sandbox/multigrid/adaptive.py
===================================================================
--- trunk/scipy/sandbox/multigrid/adaptive.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/adaptive.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -44,17 +44,17 @@
c = new_candidate.reshape(-1)[diff(AggOp.indptr) == 1] #eliminate DOFs that aggregation misses
threshold = 1e-10 * abs(c).max() # cutoff for small basis functions
- X = csr_matrix((c,AggOp.indices,AggOp.indptr),dims=AggOp.shape)
+ X = csr_matrix((c,AggOp.indices,AggOp.indptr),shape=AggOp.shape)
#orthogonalize X against previous
for i in range(K):
old_c = ascontiguousarray(Q_data[:,:,i].reshape(-1))
- D_AtX = csr_matrix((old_c*X.data,X.indices,X.indptr),dims=X.shape).sum(axis=0).A.flatten() #same as diagonal of A.T * X
+ D_AtX = csr_matrix((old_c*X.data,X.indices,X.indptr),shape=X.shape).sum(axis=0).A.flatten() #same as diagonal of A.T * X
R[:,i,K] = D_AtX
X.data -= D_AtX[X.indices] * old_c
#normalize X
- D_XtX = csr_matrix((X.data**2,X.indices,X.indptr),dims=X.shape).sum(axis=0).A.flatten() #same as diagonal of X.T * X
+ D_XtX = csr_matrix((X.data**2,X.indices,X.indptr),shape=X.shape).sum(axis=0).A.flatten() #same as diagonal of X.T * X
col_norms = sqrt(D_XtX)
mask = col_norms < threshold # find small basis functions
col_norms[mask] = 0 # and set them to zero
@@ -69,7 +69,7 @@
Q_data = Q_data.reshape(-1) #TODO BSR change
R = R.reshape(-1,K+1)
- Q = csr_matrix((Q_data,Q_indices,Q_indptr),dims=(AggOp.shape[0],(K+1)*AggOp.shape[1]))
+ Q = csr_matrix((Q_data,Q_indices,Q_indptr),shape=(AggOp.shape[0],(K+1)*AggOp.shape[1]))
return Q,R
@@ -249,7 +249,7 @@
indptr = hstack((indptr,indptr[:,-1].reshape(-1,1)))
indptr = indptr.reshape(-1)
indptr = hstack((indptr,indptr[-1:])) #duplicate last element
- return csr_matrix((P.data,P.indices,indptr),dims=(K*P.shape[0]/(K-1),P.shape[1]))
+ return csr_matrix((P.data,P.indices,indptr),shape=(K*P.shape[0]/(K-1),P.shape[1]))
for i in range(len(As) - 2):
T,R = augment_candidates(AggOps[i], Ts[i], Bs[i+1], x)
Modified: trunk/scipy/sandbox/multigrid/dec_test.py
===================================================================
--- trunk/scipy/sandbox/multigrid/dec_test.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/dec_test.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -41,7 +41,7 @@
# replace with CSR + eliminate duplicates
#indptr = (2*num_basis) * arange(num_edges+1)
## same same
- #csr_matrix((data,indices,indptr),dims=(num_edges,num_aggs))
+ #csr_matrix((data,indices,indptr),shape=(num_edges,num_aggs))
row = arange(num_edges).repeat(2*num_basis)
col = (num_basis*aggs[D_nodal.indices]).repeat(num_basis)
@@ -49,7 +49,7 @@
col = col.reshape(-1)
data = tile(0.5 * (D_nodal*vertices),(1,2)).reshape(-1)
- return coo_matrix((data,(row,col)),dims=(num_edges,num_basis*num_aggs)).tocsr()
+ return coo_matrix((data,(row,col)),shape=(num_edges,num_basis*num_aggs)).tocsr()
Modified: trunk/scipy/sandbox/multigrid/multigridtools/README.txt
===================================================================
--- trunk/scipy/sandbox/multigrid/multigridtools/README.txt 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/multigridtools/README.txt 2007-12-14 23:31:02 UTC (rev 3658)
@@ -1,5 +1,5 @@
Before regenerating multigridtools_wrap.cxx with SWIG, ensure that you
-are using SWIG Version 1.3.32 or newer (check with: 'swig -version')
+are using SWIG Version 1.3.33 or newer (check with: 'swig -version')
The wrappers are generated with:
swig -c++ -python multigridtools.i
Modified: trunk/scipy/sandbox/multigrid/multilevel.py
===================================================================
--- trunk/scipy/sandbox/multigrid/multilevel.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/multilevel.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -4,9 +4,10 @@
import scipy
import numpy
-from numpy import ones,zeros,zeros_like,array,asarray
+from numpy import ones,zeros,zeros_like,array,asarray,empty
from numpy.linalg import norm
from scipy.linsolve import spsolve
+from scipy.sparse import dia_matrix
from sa import sa_interpolation
from rs import rs_interpolation
@@ -24,19 +25,33 @@
O = -ones(N)
return scipy.sparse.spdiags([D,O,O],[0,-1,1],N,N).tocoo().tocsr() #eliminate explicit zeros
-def poisson_problem2D(N,epsilon=1.0):
+def poisson_problem2D(N, epsilon=1.0, dtype='d', format=None):
"""
- Return a sparse CSR matrix for the 2d poisson problem
+ Return a sparse matrix for the 2d poisson problem
with standard 5-point finite difference stencil on a
square N-by-N grid.
"""
- D = (2 + 2*epsilon)*ones(N*N)
- T = -epsilon * ones(N*N)
- O = -ones(N*N)
- T[N-1::N] = 0
- return scipy.sparse.spdiags([D,O,T,T,O],[0,-N,-1,1,N],N*N,N*N).tocoo().tocsr() #eliminate explicit zeros
+ if N == 1:
+ diags = asarray( [[4]],dtype=dtype)
+ return dia_matrix((diags,[0]), shape=(1,1)).asformat(format)
+ offsets = array([0,-N,N,-1,1])
+ diags = empty((5,N**2),dtype=dtype)
+
+ diags[0] = (2 + 2*epsilon) #main diagonal
+ diags[1,:] = -1
+ diags[2,:] = -1
+
+ diags[3,:] = -epsilon #first lower diagonal
+ diags[4,:] = -epsilon #first upper diagonal
+ diags[3,N-1::N] = 0
+ diags[4,N::N] = 0
+
+ return dia_matrix((diags,offsets),shape=(N**2,N**2)).tocoo().tocsr() #eliminate explicit zeros
+ #return dia_matrix((diags,offsets),shape=(N**2,N**2)).asformat(format)
+
+
def ruge_stuben_solver(A,max_levels=10,max_coarse=500):
"""
Create a multilevel solver using Ruge-Stuben coarsening (Classical AMG)
Modified: trunk/scipy/sandbox/multigrid/rs.py
===================================================================
--- trunk/scipy/sandbox/multigrid/rs.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/rs.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -14,7 +14,7 @@
if not isspmatrix_csr(A): raise TypeError('expected csr_matrix')
Sp,Sj,Sx = multigridtools.rs_strong_connections(A.shape[0],theta,A.indptr,A.indices,A.data)
- return csr_matrix((Sx,Sj,Sp),dims=A.shape)
+ return csr_matrix((Sx,Sj,Sp),shape=A.shape)
def rs_interpolation(A,theta=0.25):
Modified: trunk/scipy/sandbox/multigrid/sa.py
===================================================================
--- trunk/scipy/sandbox/multigrid/sa.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/sa.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -41,11 +41,11 @@
## # for non-scalar problems, use pre-defined blocks in aggregation
## # the strength of connection matrix is based on the 1-norms of the blocks
##
-## B = csr_matrix((ones(num_dofs),blocks,arange(num_dofs + 1)),dims=(num_dofs,num_blocks))
+## B = csr_matrix((ones(num_dofs),blocks,arange(num_dofs + 1)),shape=(num_dofs,num_blocks))
## Bt = B.T.tocsr()
##
## #1-norms of blocks entries of A
-## Block_A = Bt * csr_matrix((abs(A.data),A.indices,A.indptr),dims=A.shape) * B
+## Block_A = Bt * csr_matrix((abs(A.data),A.indices,A.indptr),shape=A.shape) * B
##
## S = sa_strong_connections(Block_A,epsilon)
## S.data[:] = 1
@@ -80,10 +80,10 @@
# for non-scalar problems, use pre-defined blocks in aggregation
# the strength of connection matrix is based on the Frobenius norms of the blocks
- B = csr_matrix((ones(num_dofs),blocks,arange(num_dofs + 1)),dims=(num_dofs,num_blocks))
+ B = csr_matrix((ones(num_dofs),blocks,arange(num_dofs + 1)),shape=(num_dofs,num_blocks))
#1-norms of blocks entries of A
#TODO figure out what to do for blocks here
- Block_A = B.T.tocsr() * csr_matrix((abs(A.data),A.indices,A.indptr),dims=A.shape) * B
+ Block_A = B.T.tocsr() * csr_matrix((abs(A.data),A.indices,A.indptr),shape=A.shape) * B
S = sa_strong_connections(Block_A,epsilon)
@@ -125,16 +125,16 @@
threshold = tol * abs(c).max() # cutoff for small basis functions
- X = csr_matrix((c,AggOp.indices,AggOp.indptr),dims=AggOp.shape)
+ X = csr_matrix((c,AggOp.indices,AggOp.indptr),shape=AggOp.shape)
#orthogonalize X against previous
for j,A in enumerate(candidate_matrices):
- D_AtX = csr_matrix((A.data*X.data,X.indices,X.indptr),dims=X.shape).sum(axis=0).A.flatten() #same as diagonal of A.T * X
+ D_AtX = csr_matrix((A.data*X.data,X.indices,X.indptr),shape=X.shape).sum(axis=0).A.flatten() #same as diagonal of A.T * X
R[:,j,i] = D_AtX
X.data -= D_AtX[X.indices] * A.data
#normalize X
- D_XtX = csr_matrix((X.data**2,X.indices,X.indptr),dims=X.shape).sum(axis=0).A.flatten() #same as diagonal of X.T * X
+ D_XtX = csr_matrix((X.data**2,X.indices,X.indptr),shape=X.shape).sum(axis=0).A.flatten() #same as diagonal of X.T * X
col_norms = sqrt(D_XtX)
mask = col_norms < threshold # set small basis functions to 0
col_norms[mask] = 0
@@ -153,7 +153,7 @@
Q_data = empty(AggOp.indptr[-1] * K) #if AggOp includes all nodes, then this is (N_fine * K)
for i,X in enumerate(candidate_matrices):
Q_data[i::K] = X.data
- Q = csr_matrix((Q_data,Q_indices,Q_indptr),dims=(N_fine,K*N_coarse))
+ Q = csr_matrix((Q_data,Q_indices,Q_indptr),shape=(N_fine,K*N_coarse))
R = R.reshape(-1,K)
Modified: trunk/scipy/sandbox/multigrid/tests/test_adaptive.py
===================================================================
--- trunk/scipy/sandbox/multigrid/tests/test_adaptive.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/tests/test_adaptive.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -21,7 +21,7 @@
#two candidates
##block candidates
- ##self.cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),dims=(9,3)), vstack((array([1]*9 + [0]*9),arange(2*9))).T ))
+ ##self.cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),shape=(9,3)), vstack((array([1]*9 + [0]*9),arange(2*9))).T ))
@@ -29,17 +29,17 @@
cases = []
## tests where AggOp includes all DOFs
- cases.append((csr_matrix((ones(4),array([0,0,1,1]),arange(5)),dims=(4,2)), vstack((ones(4),arange(4))).T ))
- cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),dims=(9,3)), vstack((ones(9),arange(9))).T ))
- cases.append((csr_matrix((ones(9),array([0,0,1,1,2,2,3,3,3]),arange(10)),dims=(9,4)), vstack((ones(9),arange(9))).T ))
+ cases.append((csr_matrix((ones(4),array([0,0,1,1]),arange(5)),shape=(4,2)), vstack((ones(4),arange(4))).T ))
+ cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),shape=(9,3)), vstack((ones(9),arange(9))).T ))
+ cases.append((csr_matrix((ones(9),array([0,0,1,1,2,2,3,3,3]),arange(10)),shape=(9,4)), vstack((ones(9),arange(9))).T ))
## tests where AggOp excludes some DOFs
- cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),dims=(5,2)), vstack((ones(5),arange(5))).T ))
+ cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),shape=(5,2)), vstack((ones(5),arange(5))).T ))
# overdetermined blocks
- cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),dims=(5,2)), vstack((ones(5),arange(5),arange(5)**2)).T ))
- cases.append((csr_matrix((ones(6),array([1,3,0,2,1,0]),array([0,0,1,2,2,3,4,5,5,6])),dims=(9,4)), vstack((ones(9),arange(9),arange(9)**2)).T ))
- cases.append((csr_matrix((ones(6),array([1,3,0,2,1,0]),array([0,0,1,2,2,3,4,5,5,6])),dims=(9,4)), vstack((ones(9),arange(9))).T ))
+ cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),shape=(5,2)), vstack((ones(5),arange(5),arange(5)**2)).T ))
+ cases.append((csr_matrix((ones(6),array([1,3,0,2,1,0]),array([0,0,1,2,2,3,4,5,5,6])),shape=(9,4)), vstack((ones(9),arange(9),arange(9)**2)).T ))
+ cases.append((csr_matrix((ones(6),array([1,3,0,2,1,0]),array([0,0,1,2,2,3,4,5,5,6])),shape=(9,4)), vstack((ones(9),arange(9))).T ))
def mask_candidate(AggOp,candidates):
#mask out all DOFs that are not included in the aggregation
Modified: trunk/scipy/sandbox/multigrid/tests/test_sa.py
===================================================================
--- trunk/scipy/sandbox/multigrid/tests/test_sa.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/tests/test_sa.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -71,11 +71,11 @@
# two aggregates in 1D
A = poisson_problem1D(6)
- AggOp = csr_matrix((ones(6),array([0,0,0,1,1,1]),arange(7)),dims=(6,2))
+ AggOp = csr_matrix((ones(6),array([0,0,0,1,1,1]),arange(7)),shape=(6,2))
candidates = ones((6,1))
T_result,coarse_candidates_result = sa_fit_candidates(AggOp,candidates)
- T_expected = csr_matrix((sqrt(1.0/3.0)*ones(6),array([0,0,0,1,1,1]),arange(7)),dims=(6,2))
+ T_expected = csr_matrix((sqrt(1.0/3.0)*ones(6),array([0,0,0,1,1,1]),arange(7)),shape=(6,2))
assert_almost_equal(T_result.todense(),T_expected.todense())
#check simple block examples
@@ -103,13 +103,13 @@
#simple 1d example w/ two aggregates
A = poisson_problem1D(6)
- AggOp = csr_matrix((ones(6),array([0,0,0,1,1,1]),arange(7)),dims=(6,2))
+ AggOp = csr_matrix((ones(6),array([0,0,0,1,1,1]),arange(7)),shape=(6,2))
candidates = ones((6,1))
user_cases.append((A,AggOp,candidates))
#simple 1d example w/ two aggregates (not all nodes are aggregated)
A = poisson_problem1D(6)
- AggOp = csr_matrix((ones(4),array([0,0,1,1]),array([0,1,1,2,3,3,4])),dims=(6,2))
+ AggOp = csr_matrix((ones(4),array([0,0,1,1]),array([0,1,1,2,3,3,4])),shape=(6,2))
candidates = ones((6,1))
user_cases.append((A,AggOp,candidates))
@@ -129,25 +129,25 @@
## tests where AggOp includes all DOFs
#one candidate
- #self.cases.append((csr_matrix((ones(5),array([0,0,0,1,1]),arange(6)),dims=(5,2)), ones((5,1)) ))
- #self.cases.append((csr_matrix((ones(5),array([1,1,0,0,0]),arange(6)),dims=(5,2)), ones((5,1)) ))
- #self.cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),dims=(9,3)), ones((9,1)) ))
- self.cases.append((csr_matrix((ones(9),array([2,1,0,0,1,2,1,0,2]),arange(10)),dims=(9,3)), arange(9).reshape(9,1) ))
+ #self.cases.append((csr_matrix((ones(5),array([0,0,0,1,1]),arange(6)),shape=(5,2)), ones((5,1)) ))
+ #self.cases.append((csr_matrix((ones(5),array([1,1,0,0,0]),arange(6)),shape=(5,2)), ones((5,1)) ))
+ #self.cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),shape=(9,3)), ones((9,1)) ))
+ self.cases.append((csr_matrix((ones(9),array([2,1,0,0,1,2,1,0,2]),arange(10)),shape=(9,3)), arange(9).reshape(9,1) ))
#two candidates
- #self.cases.append((csr_matrix((ones(4),array([0,0,1,1]),arange(5)),dims=(4,2)), vstack((ones(4),arange(4))).T ))
- #self.cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),dims=(9,3)), vstack((ones(9),arange(9))).T ))
- #self.cases.append((csr_matrix((ones(9),array([0,0,1,1,2,2,3,3,3]),arange(10)),dims=(9,4)), vstack((ones(9),arange(9))).T ))
+ #self.cases.append((csr_matrix((ones(4),array([0,0,1,1]),arange(5)),shape=(4,2)), vstack((ones(4),arange(4))).T ))
+ #self.cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),shape=(9,3)), vstack((ones(9),arange(9))).T ))
+ #self.cases.append((csr_matrix((ones(9),array([0,0,1,1,2,2,3,3,3]),arange(10)),shape=(9,4)), vstack((ones(9),arange(9))).T ))
##block candidates
- #self.cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),dims=(9,3)), vstack((array([1]*9 + [0]*9),arange(2*9))).T ))
+ #self.cases.append((csr_matrix((ones(9),array([0,0,0,1,1,1,2,2,2]),arange(10)),shape=(9,3)), vstack((array([1]*9 + [0]*9),arange(2*9))).T ))
#
### tests where AggOp excludes some DOFs
- #self.cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),dims=(5,2)), ones((5,1)) ))
- #self.cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),dims=(5,2)), vstack((ones(5),arange(5))).T ))
+ #self.cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),shape=(5,2)), ones((5,1)) ))
+ #self.cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),shape=(5,2)), vstack((ones(5),arange(5))).T ))
## overdetermined blocks
- #self.cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),dims=(5,2)), vstack((ones(5),arange(5),arange(5)**2)).T ))
- #self.cases.append((csr_matrix((ones(6),array([1,3,0,2,1,0]),array([0,0,1,2,2,3,4,5,5,6])),dims=(9,4)), vstack((ones(9),arange(9),arange(9)**2)).T ))
- #self.cases.append((csr_matrix((ones(6),array([1,3,0,2,1,0]),array([0,0,1,2,2,3,4,5,5,6])),dims=(9,4)), vstack((ones(9),arange(9))).T ))
+ #self.cases.append((csr_matrix((ones(4),array([0,0,1,1]),array([0,1,2,2,3,4])),shape=(5,2)), vstack((ones(5),arange(5),arange(5)**2)).T ))
+ #self.cases.append((csr_matrix((ones(6),array([1,3,0,2,1,0]),array([0,0,1,2,2,3,4,5,5,6])),shape=(9,4)), vstack((ones(9),arange(9),arange(9)**2)).T ))
+ #self.cases.append((csr_matrix((ones(6),array([1,3,0,2,1,0]),array([0,0,1,2,2,3,4,5,5,6])),shape=(9,4)), vstack((ones(9),arange(9))).T ))
def check_all_cases(self):
"""Test case where aggregation includes all fine nodes"""
@@ -168,7 +168,7 @@
## #aggregate one more level (to a single aggregate)
## K = coarse_candidates.shape[1]
## N = K*AggOp.shape[1]
-## AggOp = csr_matrix((ones(N),zeros(N),arange(N + 1)),dims=(N,1)) #aggregate to a single point
+## AggOp = csr_matrix((ones(N),zeros(N),arange(N + 1)),shape=(N,1)) #aggregate to a single point
## fine_candidates = coarse_candidates
##
## #mask_candidate(AggOp,fine_candidates) #not needed
Modified: trunk/scipy/sandbox/multigrid/tests/test_utils.py
===================================================================
--- trunk/scipy/sandbox/multigrid/tests/test_utils.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/tests/test_utils.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -116,8 +116,8 @@
cases.append( ( matrix([[0,1,0],[0,2,3]]), (3,2) ) )
cases.append( ( matrix([[1,0,0],[2,0,3]]), (2,5) ) )
- for A,dims in cases:
- m,n = dims
+ for A,shape in cases:
+ m,n = shape
result = expand_into_blocks(csr_matrix(A),m,n).todense()
expected = zeros((m*A.shape[0],n*A.shape[1]))
Modified: trunk/scipy/sandbox/multigrid/utils.py
===================================================================
--- trunk/scipy/sandbox/multigrid/utils.py 2007-12-14 22:44:43 UTC (rev 3657)
+++ trunk/scipy/sandbox/multigrid/utils.py 2007-12-14 23:31:02 UTC (rev 3658)
@@ -112,7 +112,7 @@
if isspmatrix_csr(A) or isspmatrix_csc(A):
#avoid copying index and ptr arrays
- abs_A = A.__class__((abs(A.data),A.indices,A.indptr),dims=A.shape)
+ abs_A = A.__class__((abs(A.data),A.indices,A.indptr),shape=A.shape)
return (abs_A * numpy.ones(A.shape[1],dtype=A.dtype)).max()
else:
return (abs(A) * numpy.ones(A.shape[1],dtype=A.dtype)).max()
@@ -152,7 +152,7 @@
data = A.data[:A.nnz] * D_sqrt_inv[Acoo.row]
data *= D_sqrt_inv[Acoo.col]
- DAD = A.__class__((data,A.indices[:A.nnz],A.indptr),dims=A.shape)
+ DAD = A.__class__((data,A.indices[:A.nnz],A.indptr),shape=A.shape)
return D_sqrt,D_sqrt_inv,DAD
@@ -169,7 +169,7 @@
I = concatenate((A.row,B.row))
J = concatenate((A.col,B.col+A.shape[1]))
V = concatenate((A.data,B.data))
- return coo_matrix((V,(I,J)),dims=(A.shape[0],A.shape[1]+B.shape[1])).tocsr()
+ return coo_matrix((V,(I,J)),shape=(A.shape[0],A.shape[1]+B.shape[1])).tocsr()
def vstack_csr(A,B):
#TODO OPTIMIZE THIS
@@ -184,7 +184,7 @@
I = concatenate((A.row,B.row+A.shape[0]))
J = concatenate((A.col,B.col))
V = concatenate((A.data,B.data))
- return coo_matrix((V,(I,J)),dims=(A.shape[0]+B.shape[0],A.shape[1])).tocsr()
+ return coo_matrix((V,(I,J)),shape=(A.shape[0]+B.shape[0],A.shape[1])).tocsr()
def expand_into_blocks(A,m,n):
@@ -224,4 +224,4 @@
data = A.data.repeat(m*n)
- return coo_matrix((data,(row,col)),dims=(m*A.shape[0],n*A.shape[1]))
+ return coo_matrix((data,(row,col)),shape=(m*A.shape[0],n*A.shape[1]))
More information about the Scipy-svn
mailing list