_-PhhdZddlmZddlZddlmZmZmZm Z m Z m Z m Z m Z mZddlmZddlmZmZmZmZddlmZddlmZd d lmZd d lmZd Zd1dZdZd2dZ d2dZ!d2dZ"d1dZ#dZ$dZ%d3dZ&d2dZ'dZ(dZ) d4d Z*d2d!Z+d"Z,d1d#Z-d$Z.d%Z/d&Z0d5d(Z1d)Z2d*Z3d+Z4d,Z5d-Z6d3d.Z7d/Z8d0Z9dS)6z$General utility functions for pyamg.)warnN) isspmatrixisspmatrix_csrisspmatrix_cscisspmatrix_bsr csr_matrix csc_matrix bsr_matrix coo_matrixeye)eigvals)csr_scale_rowsbsr_scale_rowscsr_scale_columnsbsr_scale_columns) make_system)upcast)amg_core)linalgc>t|r |jdSdS)z"Return the block size of a matrix.rr)r blocksizeAs P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/pyamg/util/utils.py get_blocksizers#a{1~ 1c V|jdjtjjddzg||jfdi|n>fd}||dd}|f||d |tj S) aProfile a particular multilevel object. Parameters ---------- ml : multilevel Fully constructed multilevel object accel : function pointer Pointer to a valid Krylov solver (e.g. gmres, cg) Returns ------- residuals : array Array of residuals for each iteration See Also -------- multilevel.psolve, multilevel.solve Examples -------- >>> import numpy as np >>> from scipy.sparse import spdiags, csr_matrix >>> from scipy.sparse.linalg import cg >>> from pyamg.classical import ruge_stuben_solver >>> from pyamg.util.utils import profile_solver >>> n=100 >>> e = np.ones((n,1)).ravel() >>> data = [ -1*e, 2*e, -1*e ] >>> A = csr_matrix(spdiags(data,[-1,0,1],n,n)) >>> b = A*np.ones(A.shape[0]) >>> ml = ruge_stuben_solver(A, max_coarse=10) >>> res = profile_solver(ml,accel=cg) rrN residualsc tjtjtj|zz dSN)appendrnormnpravel)xrbr s rcallbackz profile_solver..callbackGs@   V[!rx!}})DEE F F F F FrcycleV)r*)Mr)) levelsrr%randomrandshapesolveaspreconditionergetasarray)mlaccelkwargsr)r,rr(r s @@@rprofile_solverr8sF ! A BINN171:q ) ))AI }22i262222 G G G G G G G   fjj#&>&>  ? ? a5a(55f555 :i  rc t|r|Stj|dkrt dt tj|tjt|tjt|dzft|t|fS)aReturn a diagonal. If A is a sparse matrix (e.g. csr_matrix or csc_matrix) - return the diagonal of A as an array Otherwise - return a csr_matrix with A on the diagonal Parameters ---------- A : sparse matrix or 1d array General sparse matrix or array of diagonal entries Returns ------- B : array or sparse matrix Diagonal sparse is returned as csr if A is dense otherwise return an array of the diagonal Examples -------- >>> import numpy as np >>> from pyamg.util.utils import diag_sparse >>> d = 2.0*np.ones((3,)).ravel() >>> print(diag_sparse(d).toarray()) [[2. 0. 0.] [0. 2. 0.] [0. 0. 2.]] rz&input diagonal array expected to be 1d) rdiagonalr%ndim ValueErrorrr4arangelenrs r diag_sparser?Os>!}}zz|| wqzzQABBB rz!}}biA&7&7yQ**,.1!ffc!ff-= ? ??rTc tj|}|j\}}t|st d|t |krt d|rM|}tj|jt|j |j |_ntj||j }t|r$t|||j |j|j|nt|rb|j\}}t#t%||z t%||z |||j |jtj|j|not'|r)t)j|||j |j|j|n7|j}t/t1|||}|S)ahScale the sparse rows of a matrix. Parameters ---------- A : sparse matrix Sparse matrix with M rows v : array_like Array of M scales copy : {True,False} - If copy=True, then the matrix is copied to a new and different return matrix (e.g. B=scale_rows(A,v)) - If copy=False, then the matrix is overwritten deeply (e.g. scale_rows(A,v,copy=False) overwrites A) Returns ------- A : sparse matrix Scaled sparse matrix in original format See Also -------- scipy.sparse._sparsetools.csr_scale_rows, scale_columns Notes ----- - if A is a csc_matrix, the transpose A.T is passed to scale_columns - if A is not csr, csc, or bsr, it is converted to csr and sent to scale_rows Examples -------- >>> import numpy as np >>> from scipy.sparse import spdiags >>> from pyamg.util.utils import scale_rows >>> n=5 >>> e = np.ones((n,1)).ravel() >>> data = [ -1*e, 2*e, -1*e ] >>> A = spdiags(data,[-1,0,1],n,n-1).tocsr() >>> B = scale_rows(A,5*np.ones((A.shape[0],1))) z scale rows needs a sparse matrix#scale vector has incompatible shapedtype)r%r&r0rr<r>copyr4datarrCrrindptrindicesrrrintrrcsc_scale_rowsformat scale_rowsrasformatrvrDr,NRCfmts rrKrKxsT  A 7DAq a===;<<<CFF{{>??? ) FFHHAF&!'*B*BCCC Jq ( ( (a 7q!QXqy!&!<<<<   7{1s1Q3xxQqS1a19x'' , , , ,   71ah 161EEEEh z!}}a ( ( 1 1# 6 6 Hrc tj|}|j\}}t|st d|t |krt d|rM|}tj|jt|j |j |_ntj||j }t|r$t|||j |j|j|nt|rb|j\}}t#t%||z t%||z |||j |jtj|j|not'|r)t)j|||j |j|j|n7|j}t/t1|||}|S)aScale the sparse columns of a matrix. Parameters ---------- A : sparse matrix Sparse matrix with N rows v : array_like Array of N scales copy : {True,False} - If copy=True, then the matrix is copied to a new and different return matrix (e.g. B=scale_columns(A,v)) - If copy=False, then the matrix is overwritten deeply (e.g. scale_columns(A,v,copy=False) overwrites A) Returns ------- A : sparse matrix Scaled sparse matrix in original format See Also -------- scipy.sparse._sparsetools.csr_scale_columns, scale_rows Notes ----- - if A is a csc_matrix, the transpose A.T is passed to scale_rows - if A is not csr, csc, or bsr, it is converted to csr and sent to scale_rows Examples -------- >>> import numpy as np >>> from scipy.sparse import spdiags >>> from pyamg.util.utils import scale_columns >>> n=5 >>> e = np.ones((n,1)).ravel() >>> data = [ -1*e, 2*e, -1*e ] >>> A = spdiags(data,[-1,0,1],n,n-1).tocsr() >>> print(scale_columns(A,5*np.ones((A.shape[1],1))).toarray()) [[10. -5. 0. 0.] [-5. 10. -5. 0.] [ 0. -5. 10. -5.] [ 0. 0. -5. 10.] [ 0. 0. 0. -5.]] z#scale columns needs a sparse matrixrArB)r%r&r0rr<r>rDr4rErrCrrrFrGrrrrHrrcsc_scale_columnsrJ scale_columnsrrLrMs rrUrUs^  A 7DAq a==@>???CFF{{>??? ) FFHHAF&!'*B*BCCC Jq ( ( (a :!Q!)QVQ????   :{1#ac((C!HHaAHai(16**A / / / /   :"1a19afaHHHHh *Q-- + + 4 4S 9 9 Hrc6t|st|st|r|jd|jdkrt dt |}|dk}|jtkr"tj t|}ntj |}tj |}d||z ||<t|||}t||d}|||fStt|S)adScale the matrix symmetrically. A = D^{-1/2} A D^{-1/2} where D=diag(A). The left multiplication is accomplished through scale_rows and the right multiplication is done through scale columns. Parameters ---------- A : sparse matrix Sparse matrix with N rows copy : {True,False} - If copy=True, then the matrix is copied to a new and different return matrix (e.g. B=symmetric_rescaling(A)) - If copy=False, then the matrix is overwritten deeply (e.g. symmetric_rescaling(A,copy=False) overwrites A) Returns ------- D_sqrt : array Array of sqrt(diag(A)) D_sqrt_inv : array Array of 1/sqrt(diag(A)) DAD : csr_matrix Symmetrically scaled A Notes ----- - if A is not csr, it is converted to csr and sent to scale_rows Examples -------- >>> import numpy as np >>> from scipy.sparse import spdiags >>> from pyamg.util.utils import symmetric_rescaling >>> n=5 >>> e = np.ones((n,1)).ravel() >>> data = [ -1*e, 2*e, -1*e ] >>> A = spdiags(data,[-1,0,1],n,n).tocsr() >>> Ds, Dsi, DAD = symmetric_rescaling(A) >>> print(DAD.toarray()) [[ 1. -0.5 0. 0. 0. ] [-0.5 1. -0.5 0. 0. ] [ 0. -0.5 1. -0.5 0. ] [ 0. 0. -0.5 1. -0.5] [ 0. 0. 0. -0.5 1. ]] rrzexpected square matrix?rDF)rrrr0r<r?rCcomplexr%sqrtabs zeros_likerKrUsymmetric_rescalingr)rrDDmaskD_sqrt D_sqrt_invDADs rr]r]s fa'N1--'1B1B' 71: # #566 6 NNAv 7g  WSVV__FFWQZZF]6** vd|+ 4JT222C%888z3&& z!}} - --rct|d\}}}t|jdD]<}tj|dd|ftj|z|dd|f<=t |drs|jdkrh|tdt|jdD]<}tj|dd|ftj|z|dd|f<=|||gS)aScale the matrix symmetrically. A = D^{-1/2} A D^{-1/2} where D=diag(A). The left multiplication is accomplished through scale_rows and the right multiplication is done through scale columns. The candidates B and BH are scaled accordingly:: B = D^{1/2} B BH = D^{1/2} BH Parameters ---------- A : {sparse matrix} Sparse matrix with N rows B : {array} N x m array BH : {None, array} If A.symmetry == 'nonsymmetric, then BH must be an N x m array. Otherwise, BH is ignored. Returns ------- Appropriately scaled A, B and BH, i.e., A = D^{-1/2} A D^{-1/2}, B = D^{1/2} B, and BH = D^{1/2} BH Notes ----- - if A is not csr, it is converted to csr and sent to scale_rows Examples -------- >>> import numpy as np >>> from scipy.sparse import spdiags >>> from pyamg.util.utils import symmetric_rescaling_sa >>> n=5 >>> e = np.ones((n,1)).ravel() >>> data = [ -1*e, 2*e, -1*e ] >>> A = spdiags(data,[-1,0,1],n,n).tocsr() >>> B = e.copy().reshape(-1,1) >>> [DAD, DB, DBH] = symmetric_rescaling_sa(A,B,BH=None) >>> print(DAD.toarray()) [[ 1. -0.5 0. 0. 0. ] [-0.5 1. -0.5 0. 0. ] [ 0. -0.5 1. -0.5 0. ] [ 0. 0. -0.5 1. -0.5] [ 0. 0. 0. -0.5 1. ]] >>> print(DB) [[1.41421356] [1.41421356] [1.41421356] [1.41421356] [1.41421356]] FrXrNsymmetry nonsymmetriczBH should be an n x m array)r]ranger0r%r&hasattrrdr<)rBBHr`_is rsymmetric_rescaling_sarlZst'qu555LFAq171:  55(1QQQT7##BHV$4$44!!!Q$q*? : ' 'z !>???28A;'' ? ?8Bqqq!tH--bhv.>.>>111a4 q":rct||}t|}t|D]:}tj||rtj||g||<;|S)a0Upcast variables to a type. Loop over all elements of varlist and convert them to upcasttype The only difference with pyamg.util.utils.to_type(...), is that scalars are wrapped into (1,0) arrays. This is desirable when passing the numpy complex data type to C routines and complex scalars aren't handled correctly Parameters ---------- upcast_type : data type e.g. complex, float64 or complex128 varlist : list list may contain arrays, mat's, sparse matrices, or scalars the elements may be float, int or complex Returns ------- Returns upcast-ed varlist to upcast_type Notes ----- Useful when harmonizing the types of variables, such as if A and b are complex, but x,y and z are not. Examples -------- >>> import numpy as np >>> from pyamg.util.utils import type_prep >>> from scipy.sparse.sputils import upcast >>> x = np.ones((5,1)) >>> y = 2.0j*np.ones((5,1)) >>> z = 2.3 >>> varlist = type_prep(upcast(x.dtype, y.dtype), [x, y, z]) )to_typer>rfr%isscalararray upcast_typevarlistnvrks r type_preprusiJk7++G WB 2YY00 ;wqz " " 071:,//GAJ Nrcft|}t|D]}tj||r&tj||g|d||<B ||j|kr|||||<s#t$rtdYwxYw|S)a Loop over all elements of varlist and convert them to upcasttype. Parameters ---------- upcast_type : data type e.g. complex, float64 or complex128 varlist : list list may contain arrays, mat's, sparse matrices, or scalars the elements may be float, int or complex Returns ------- Returns upcast-ed varlist to upcast_type Notes ----- Useful when harmonizing the types of variables, such as if A and b are complex, but x,y and z are not. Examples -------- >>> import numpy as np >>> from pyamg.util.utils import to_type >>> from scipy.sparse.sputils import upcast >>> x = np.ones((5,1)) >>> y = 2.0j*np.ones((5,1)) >>> varlist = to_type(upcast(x.dtype, y.dtype), [x, y]) rzFailed to cast in to_type) r>rfr%rorprCastypeAttributeErrorrrqs rrnrns@ WB 2YY 2 2 ;wqz " " 271:, < D = diag(A) 1 ==> D = diag(A.H A) 2 ==> D = diag(A A.H) inv : {True, False} If True, D = 1.0/D Returns ------- diagonal, D, of appropriate system Notes ----- This function is especially useful for its fast methods of obtaining diag(A A.H) and diag(A.H A). Dinv is zero wherever D is zero Examples -------- >>> from pyamg.util.utils import get_diagonal >>> from pyamg.gallery import poisson >>> A = poisson( (5,), format='csr' ) >>> D = get_diagonal(A) >>> print(D) [2. 2. 2. 2. 2.] >>> D = get_diagonal(A, norm_eq=1, inv=True) >>> print(D) [0.2 0.16666667 0.16666667 0.16666667 0.2 ] z$Implicit conversion to sparse matrixrrrrW)rrrrr sort_indicesTmultiply conjugater%onesr0r:r\)rnorm_eqinvAtr^Dinvr_s r get_diagonalrs&L 1  !2!2nQ6G6G 3444 qMMNN!||S [[ ( ("'28A;.*A*A A A ZZ & & (>(> > JJLL }QCx1T7]T  Hrct|std|jd|jdkrtdt j|jd|dkrtdt |drg|re|jjd|krN|jjd|kr8|jjdt|jd|z kr|jSnvt |drf|sd|j jd|krN|j jd|kr8|j jdt|jd|z kr|j St|st|||f }|j ||fkr| ||f }|}t jt|jd|z ||f|j }t jd|jjddz|j|jf}t|jd|z t|jd|z f}t)|| }|dz}|d k}||}|jd kr|j|ddddf||ddddf<|rm|jddkr@t/j||jd|jddnt5j|||_n||_ |S)aReturn the block diagonal of A, in array form. Parameters ---------- A : csr_matrix assumed to be square blocksize : int square block size for the diagonal inv_flag : bool if True, return the inverse of the block diagonal Returns ------- block_diag : array block diagonal of A in array form, array size is (A.shape[0]/blocksize, blocksize, blocksize) Examples -------- >>> from numpy import arange >>> from scipy.sparse import csr_matrix >>> from pyamg.util.utils import get_block_diag >>> A = csr_matrix(arange(36).reshape(6,6)) >>> block_diag_inv = get_block_diag(A, blocksize=2, inv_flag=False) >>> print(block_diag_inv) [[[ 0. 1.] [ 6. 7.]] [[14. 15.] [20. 21.]] [[28. 29.] [34. 35.]]] >>> block_diag_inv = get_block_diag(A, blocksize=2, inv_flag=True) Expected sparse matrixrrExpected square matrix(blocksize and A.shape must be compatible block_D_invrblock_DrrBr0rNr|)r TypeErrorr0r<r%modrgrrHrrr rtobsrasfptypezerosrCr=rGrFrr:rEr pinv_arrayr&r)rrinv_flag block_diagAAIJr0 diag_entries nonzero_masks rget_block_diagrCsKJ a==20111wqzQWQZ1222 vagaj)$$))CDDDq-  X  M  "i / / M  "i / / M  "c!'!*Y*>&?&? ? ?= I   IOA ) + + IOA ) + + IOA #agaj&:";"; ; ;9  !  < qY $: ; ; ;{y),,, GGy)4G 5 5 A3qwqz)344iK !)))J Ia+A- . . 18 DD I% & &AGAJy,@(A(A BEd%00099;;LAL2%L -LT!!)* aaa0B)C <AAA%&   A  " "   0 0 2 2J4DQ4G * 0 3S : : : :  j ) ) )"  rc|dkr|Stj|jd|dkrtd|||f}|tj|jj|j|jf}t|jd|j dz t|jd|j dz f}t||S)aAmalgamate matrix A. Parameters ---------- A : csr_matrix Matrix to amalgamate blocksize : int blocksize to use while amalgamating Returns ------- A_amal : csr_matrix Amalgamated matrix A, first, convert A to BSR with square blocksize and then return a CSR matrix of ones using the resulting BSR indptr and indices Notes ----- inverse operation of unamal for square matrices Examples -------- >>> from numpy import array >>> from scipy.sparse import csr_matrix >>> from pyamg.util.utils import amalgamate >>> row = array([0,0,1]) >>> col = array([0,2,1]) >>> data = array([1,2,3]) >>> A = csr_matrix( (data,(row,col)), shape=(4,4) ) >>> A.toarray() array([[1, 0, 2, 0], [0, 3, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) >>> amalgamate(A,2).toarray() array([[1., 1.], [0., 0.]]) rrzIncompatible blocksizerr) r%rr0r<rr{rrGrFrHrr)rrsubIr0s r amalgamatersPA~~ vagaj)$$))1222 9i011ANN GAIO $ $ai :D AKN* + + AKN* + + -E d% ( ( ((rctj|jjd||f}||j|jf}||jdz||jdzf}t ||S)a`Unamalgamate a CSR A with blocks of 1's. This operation is equivalent to replacing each entry of A with ones(rows_per_block, cols_per_block), i.e., this is equivalent to setting all of A's nonzeros to 1 and then doing a Kronecker product between A and ones(rows_per_block, cols_per_block). Parameters ---------- A : csr_matrix Amalgamted matrix rows_per_block : int Give A blocks of size (rows_per_block, cols_per_block) cols_per_block : int Give A blocks of size (rows_per_block, cols_per_block) Returns ------- A : bsr_matrix Returns A.data[:] = 1, followed by a Kronecker product of A and ones(rows_per_block, cols_per_block) Examples -------- >>> from numpy import array >>> from scipy.sparse import csr_matrix >>> from pyamg.util.utils import unamal >>> row = array([0,0,1,2,2,2]) >>> col = array([0,2,2,0,1,2]) >>> data = array([1,2,3,4,5,6]) >>> A = csr_matrix( (data,(row,col)), shape=(3,3) ) >>> A.toarray() array([[1, 0, 2], [0, 0, 3], [4, 5, 6]]) >>> unamal(A,2,2).toarray() array([[1., 1., 0., 0., 1., 1.], [1., 1., 0., 0., 1., 1.], [0., 0., 0., 0., 1., 1.], [0., 0., 0., 0., 1., 1.], [1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1.]]) rrr)r%rrGr0rFr )rrows_per_blockcols_per_blockrEblockIr0s runamalrsgZ 7AIOA&G H HDAIqx (F AGAJ &qwqz(A BE fE * * **r|center-c  d}t|tr|d}|d}g}|D]} tt| t|z D]} |dt | D]0\} } t| || krt| || <1t |D]\} } || xx|z cc<t |t|t|dz zz}t|dkr@|d}|D]#}|t ||dzz }$|dz }| }|dkr tj }|dkr tj }|dkr tj }|rt|d|D]$\}}||t|||zz }%|dgkr-|dt| dz}t|dkrd }||tt!jt%|t%t|z zdzz }|dd}|D]p} t| |D]$\}}||t|||zz }%| gkr.|dt| dz}k|dz }q|S) aPrint a table from a list of lists representing the rows of a table. Parameters ---------- table : list list of lists, e.g. a table with 3 columns and 2 rows could be [ ['0,0', '0,1', '0,2'], ['1,0', '1,1', '1,2'] ] title : string Printed centered above the table delim : string character to delimit columns centering : {'left', 'right', 'center'} chooses justification for columns col_padding : int number of blank spaces to add to each column header : {True, False} Does the first entry of table contain column headers? headerchar : {string} character to separate column headers from rest of table Returns ------- string representing table that's ready to be printed Notes ----- The string for the table will have correctly justified columns with extra padding added into each column entry to ensure columns align. The characters to delimit the columns can be user defined. This should be useful for printing convergence data from tests. Examples -------- >>> from pyamg.util.utils import print_table >>> table = [ ['cos(0)', 'cos(pi/2)', 'cos(pi)'], ['0.0', '1.0', '0.0'] ] >>> table1 = print_table(table) # string to print >>> table2 = print_table(table, delim='||') >>> table3 = print_table(table, headerchar='*') >>> table4 = print_table(table, col_padding=6, centering='left')  rrrrrightleftN ) isinstancetuplerfr>r# enumeratesumsplitstrrlowerrjustljustziprstriprHr%ceilfloat)tabletitledelim centering col_paddingheader headerchar table_str colwidthsrowrjjrrkttwidthtelmt elmtwidths r print_tablersPXI%aaI&&s3xx#i..011 ! !A   R cNN & &DAq1vv ! $$"1vv !  & )$$$$1! # )nns5zz3y>>!+;<>!,CJJ;,/66884?I z??a  JZ guS__'='==>> ? ?@BFG G abb "3 22 A AOD) 3t99i885@ @II "99!,CJJ;,/66884?II  II rc gdg}gdg}g}t|jD]%\}}|j}|dur||jdd|jddz }|dkd} |}|jdd|jddz } | dkd} tj | | } | }|| ddfdd| f}n| }t|} tj |}ttj| }t!tj| }t!| tj| dkj}t!| tj| dkj}|t'||d |d t'|t'||d gttj| }t!tj| }t!| tj| dkj}t!| tj| dkj}|t'||d |d t'|t'||d g|| 't+t-|t+t-||S) aExamine a multilevel hierarchy's spectrum. Parameters ---------- mg { pyamg multilevel hierarchy } e.g. generated with smoothed_aggregation_solver(...) or ruge_stuben_solver(...) Returns ------- leveleigs : list List of eigenvalues per level Notes ----- This can be useful for troubleshooting and when examining how your problem's nature changes from level to level A table is printed to standard out detailing the spectrum of each level in mg Examples -------- >>> from pyamg import smoothed_aggregation_solver >>> from pyamg.gallery import poisson >>> from pyamg.util.utils import hierarchy_spectrum >>> A = poisson( (1,), format='csr' ) >>> ml = smoothed_aggregation_solver(A) >>> leveleigs = hierarchy_spectrum(ml) Level | min(re(eig)) | max(re(eig)) | num re(eig) < 0 | num re(eig) > 0 | cond_2(A) ------------------------------------------------------------------------------------- 0 | 2.000 | 2.000 | 0 | 1 | 1.00e+00 Level | min(im(eig)) | max(im(eig)) | num im(eig) < 0 | num im(eig) > 0 | cond_2(A) ------------------------------------------------------------------------------------- 0 | 0.000 | 0.000 | 0 | 0 | 1.00e+00 )Levelz min(re(eig))z max(re(eig))znum re(eig) < 0znum re(eig) > 0 cond_2(A))rz min(im(eig))z max(im(eig))znum im(eig) < 0znum im(eig) > 0rTrrrNrzz1.3fz1.2e)rr-rtocsreliminate_zerosrFnonzerotocscr%union1dtoarrayr rcondminrealmaxr0r#rimagprintr)mgfilter_entries real_table imag_table leveleigsrklevelr nnz_per_row nonzero_rows nnz_per_col nonzero_colsnonzero_rowcolsec lambda_min lambda_maxnum_negnum_poss rhierarchy_spectrumrys%R3334J3334JIbi((!!5 GMMOO T ! !     (1R4.18ABB<7K'1,5577:L A(1R4.18ABB<7K'1,5577:L j|DDO A/111$%aaa&89AA A AJJ KNN__ __ a S()/00a S()/003q66j#7#7J9M9Mw<<W!{{D E E E__ __ a S()/00a S()/003q66j#7#7J9M9Mw<<W!{{D E E E  +j ! !""" +j ! !""" rcr|dkrd}n|dvrd}ntd|dt|j|ks0t|j|kst|j|krtd|tjtj||z|f}t |D]}}||z}|dkrd||<|dkrAt ddD]0} t d dD]} | | kr d||| z| f<d ||| z| f<1|dvrt d dD]0} t d dD]} | | kr d||| z| f<d ||| z| f<1t d dD]} t ddD]n} | | dz kr d ||| z| f<| | zd kr||||| z| f<0| | zd kr||||| z| f<J| | zdkr||||| z| f<dd ||| z| f<od } d } ||| z| fxxd zcc<d} d} ||| z| fxxd zcc<d} d } ||| z| fxxd zcc<|S)aOConvert 2D or 3D coordinates into Rigid body modes. For use as near nullspace modes in elasticity AMG solvers. Parameters ---------- nnodes : int Number of nodes ndof : Number of dofs per node x,y,z : array_like Coordinate vectors Returns ------- rbm : array An array of size (nnodes*ndof) x (1 | 6) containing the 6 rigid body modes Examples -------- >>> import numpy as np >>> from pyamg.util.utils import coord_to_rbm >>> a = np.array([0,1,2]) >>> coord_to_rbm(3,6,a,a,a) array([[ 1., 0., 0., 0., 0., -0.], [ 0., 1., 0., -0., 0., 0.], [ 0., 0., 1., 0., -0., 0.], [ 0., 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 1., 0.], [ 0., 0., 0., 0., 0., 1.], [ 1., 0., 0., 0., 1., -1.], [ 0., 1., 0., -1., 0., 1.], [ 0., 0., 1., 1., -1., 0.], [ 0., 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 1., 0.], [ 0., 0., 0., 0., 0., 1.], [ 1., 0., 0., 0., 2., -2.], [ 0., 1., 0., -2., 0., 2.], [ 0., 0., 1., 2., -2., 0.], [ 0., 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 1., 0.], [ 0., 0., 0., 0., 0., 1.]]) r)rzncoord_to_rbm(...) only supports 1, 3 or 6 PDEs per spatial location,i.e. ndof = [1 | 3 | 6]. You have entered .zXcoord_to_rbm(...) requires coordinate vectors of equal length. Length must be nnodes = rWrrrzgr)r<rr0r%rprrf) nnodesndofr'yznumcolsrbmnodedofiijjs r coord_to_rbmrs2^ qyy 5-155566 6 AG CLLF$:$:AG PV@V@VF=CFFGG G (28VD['233 4 4Cf .$.$Tk 199CI 199Aqkk . .1++..BRxx*-CFBJ*-CFBJ . 6>>Aqkk . .1++..BRxx*-CFBJ*-CFBJ . Aqkk 2 21++ 2 2Bbd||*-CFBJrEa<<./gCB OO e\\./gCB OO e\\./gCB OO.1CB OO 2BB B OOOt #OOOBB B OOOt #OOOBB B OOOt #OOO Jrc |jd}|jd|jdkrtd|jd|jdkrtdt|r~d}|jd}|jd}t ||z } t|std||jdks||jdkrtdnUt |r7d}d}d}t ||z } t |stdntdt |jdkr|dd}|jd|jdkrtd t |jdkr|dd}|jd|jdkrtd |jd|jdkrtd |jd} |jtkr%tj |j t |_ |jtkr%tj |j t |_ |jtkr%tj |j t |_ |j|jks|j|jkrtd |t||}|}d|j dd<||}|}|}tjtj|j j|j |j f|_ tj|j|jf|_tj|j|jf|_|r|||f}n|}||z|z } t1j||| | tjtj|tj| tj||j|jtj|j  ||S)a Filter the matrix A according to the matrix graph of C. Ensure that the new, filtered A satisfies: A_new*B = Bf. A : {csr_matrix, bsr_matrix} n x m matrix to filter C : {csr_matrix, bsr_matrix} n x m matrix representing the couplings in A to keep B : {array} m x k array of near nullspace vectors Bf : {array} n x k array of near nullspace vectors to place in span(A) BtBinv : {None, array} 3 dimensional array such that, BtBinv[i] = pinv(B_i.H Bi), and B_i is B restricted to the neighborhood (with respect to the matrix graph of C) of dof of i. If None is passed in, this array is computed internally. Returns ------- A : sparse matrix updated such that sparsity structure of A now matches that of C, and that the relationship A*B = Bf holds. Notes ----- This procedure allows for certain important modes (i.e., Bf) to be placed in span(A) by way of row-wise l2-projections that enforce the relationship A*B = Bf. This is useful for maintaining certain modes (e.g., the constant) in the span of prolongation. This routine is primarily used in pyamg.aggregation.smooth.energy_prolongation_smoother, where it is used to generate a suitable initial guess for the energy-minimization process, when root-node style SA is used. Essentially, the tentative prolongator, T, is processed by this routine to produce fine-grid nullspace vectors when multiplying coarse-grid nullspace vectors, i.e., T*B = Bf. This is possible for any arbitrary vectors B and Bf, so long as the sparsity structure of T is rich enough. When generating initial guesses for root-node style prolongation operators, this function is usually called before pyamg.uti.utils.scale_T Examples -------- >>> from numpy import ones, array >>> from scipy.sparse import csr_matrix >>> from pyamg.util.utils import filter_operator >>> A = array([ [1.,1,1],[1,1,1],[0,1,0],[0,1,0],[0,0,1],[0,0,1]]) >>> C = array([ [1.,1,0],[1,1,0],[0,1,0],[0,1,0],[0,0,1],[0,0,1]]) >>> B = ones((3,1)) >>> Bf = ones((6,1)) >>> filter_operator(csr_matrix(A), csr_matrix(C), B, Bf).toarray() array([[0.5, 0.5, 0. ], [0.5, 0.5, 0. ], [0. , 1. , 0. ], [0. , 1. , 0. ], [0. , 0. , 1. ], [0. , 0. , 1. ]]) rzA and C must be the same sizerTz&A and C must either both be CSR or BSRz%A and C must have same BSR blocksizesFrz+A and Bf must have the same first dimensionzZA and B must have matching dimensions such that A*B is computablezEB and Bf must have the same second dimensionrBz"A, B and Bf must of the same dtypeN)r0r<rrrHrr>reshaperCr%rprErrcompute_BtBinvrDr}tocoohstackrrcolrrrsatisfy_constraints_helperr~r&rFrGr) rrQrhBfBtBinvNfineisBSRrrNnodesNullDimdiffs rfilter_operatorr GsF~ GAJEwqzQWQZ8999wqzQWQZ8999aCQQU>)**a   GEFF F ak!n , ,.AKPQN2R2RDEE E3S   CU>)**a   GEFF F GABBB 28}} ZZA   x{agaj  FGGG 17||q IIb!  wqzQWQZ233 3 wqzRXa[  %&& &gajGw#~~!&...w#~~!&... x3(27%000 1728 3 3<=== ~1%% AAF111I 1 A  A  A YQW===qvF G GAF Iquaen % %AE Iquaen % %AE  GG^^4 5 5 GGII Q38D '(.(* RXa[[(A(A(*(*(8(8!(() 28AF3C3C EEE Hrct|std|jd|jdkrtdt|std|jd|jdkrtdt|std|jd|jdkrtd|jd|jdks|jd|jdkrtd |jdkr;|j|z}|jdkrt j|j||z}||z|z}|S) a Scale T with a block diagonal matrix. Helper function that scales T with a right multiplication by a block diagonal inverse, so that T is the identity at C-node rows. Parameters ---------- T : {bsr_matrix} Tentative prolongator, with square blocks in the BSR data structure, and a non-overlapping block-diagonal structure P_I : {bsr_matrix} Interpolation operator that carries out only simple injection from the coarse grid to fine grid Cpts nodes I_F : {bsr_matrix} Identity operator on Fpts, i.e., the action of this matrix zeros out entries in a vector at all Cpts, leaving Fpts untouched Returns ------- T : {bsr_matrix} Tentative prolongator scaled to be identity at C-pt nodes Examples -------- >>> from scipy.sparse import csr_matrix, bsr_matrix >>> import numpy as np >>> from pyamg.util.utils import scale_T >>> T = np.array([[ 1.0, 0., 0. ], ... [ 0.5, 0., 0. ], ... [ 0. , 1., 0. ], ... [ 0. , 0.5, 0. ], ... [ 0. , 0., 1. ], ... [ 0. , 0., 0.25 ]]) >>> P_I = np.array([[ 0., 0., 0. ], ... [ 1., 0., 0. ], ... [ 0., 1., 0. ], ... [ 0., 0., 0. ], ... [ 0., 0., 0. ], ... [ 0., 0., 1. ]]) >>> I_F = np.array([[ 1., 0., 0., 0., 0., 0.], ... [ 0., 0., 0., 0., 0., 0.], ... [ 0., 0., 0., 0., 0., 0.], ... [ 0., 0., 0., 1., 0., 0.], ... [ 0., 0., 0., 0., 1., 0.], ... [ 0., 0., 0., 0., 0., 0.]]) >>> scale_T(bsr_matrix(T), bsr_matrix(P_I), bsr_matrix(I_F)).toarray() array([[2. , 0. , 0. ], [1. , 0. , 0. ], [0. , 1. , 0. ], [0. , 0.5, 0. ], [0. , 0. , 4. ], [0. , 0. , 1. ]]) Notes ----- This routine is primarily used in pyamg.aggregation.smooth.energy_prolongation_smoother, where it is used to generate a suitable initial guess for the energy-minimization process, when root-node style SA is used. This function, scale_T, takes an existing tentative prolongator and ensures that it injects from the coarse-grid to fine-grid root-nodes. When generating initial guesses for root-node style prolongation operators, this function is usually called after pyamg.uti.utils.filter_operator This function assumes that the eventual coarse-grid nullspace vectors equal coarse-grid injection applied to the fine-grid nullspace vectors. Expected BSR matrix Trrz(Expected BSR matrix T with square blockszExpected BSR matrix P_Iz*Expected BSR matrix P_I with square blockszExpected BSR matrix I_Fz*Expected BSR matrix I_F with square blocksz.Expected identical blocksize in I_F, P_I and T)rrrnnzr|rrrE)r|P_II_Fr^s rscale_TrsmL !  1/000{1~Q''BCCC #  31222 }Q3=+++DEEE #  31222 }Q3=+++DEEE aCM!,,, aAKN**HIII w{{ E!G 5199  af % % % aC ECK Hrc t|st|stdt|stdt|std|jd|jdkrtd|jd|jdkrtd|jd|jdkrtd|jd|jdkr |jddkrtd t|r|jddkrp|jd}t j||z|}td|D]9}|tt||jd|xx|z cc<:nd}|}t j |t }|jd|jdkr |jd|krtd ||jdkrtd |jdt|jd|z krtd |jd}t|jd|jdd}| } d| j|<| || z }|| j } |jdkr7| } t j| jddz} nDt jd|jj } t j|dzf|jj } t-|j | | f|jd|f} | |j} t|r5||j}| |j} n,|d}| d} | | ||| dS)aa Return C and F pts. Helper function that returns a dictionary of sparse matrices and arrays which allow us to easily operate on Cpts and Fpts separately. Parameters ---------- A : {csr_matrix, bsr_matrix} Operator Cnodes : {array} Array of all root node indices. This is an array of nodal indices, not degree-of-freedom indices. If the blocksize of T is 1, then nodal indices and degree-of-freedom indices coincide. AggOp : {csr_matrix} Aggregation operator corresponding to A T : {bsr_matrix} Tentative prolongator based on AggOp Returns ------- Dictionary containing these parameters: P_I : {bsr_matrix} Interpolation operator that carries out only simple injection from the coarse grid to fine grid Cpts nodes I_F : {bsr_matrix} Identity operator on Fpts, i.e., the action of this matrix zeros out entries in a vector at all Cpts, leaving Fpts untouched I_C : {bsr_matrix} Identity operator on Cpts nodes, i.e., the action of this matrix zeros out entries in a vector at all Fpts, leaving Cpts untouched Cpts : {array} An array of all root node dofs, corresponding to the F/C splitting Fpts : {array} An array of all non root node dofs, corresponding to the F/C splitting Examples -------- >>> from numpy import array >>> from pyamg.util.utils import get_Cpt_params >>> from pyamg.gallery import poisson >>> from scipy.sparse import csr_matrix, bsr_matrix >>> A = poisson((10,), format='csr') >>> Cpts = array([3, 7]) >>> AggOp = ([[ 1., 0.], [ 1., 0.], ... [ 1., 0.], [ 1., 0.], ... [ 1., 0.], [ 0., 1.], ... [ 0., 1.], [ 0., 1.], ... [ 0., 1.], [ 0., 1.]]) >>> AggOp = csr_matrix(AggOp) >>> T = AggOp.copy().tobsr() >>> params = get_Cpt_params(A, Cpts, AggOp, T) >>> params['P_I'].toarray() array([[0., 0.], [0., 0.], [0., 0.], [1., 0.], [0., 0.], [0., 0.], [0., 0.], [0., 1.], [0., 0.], [0., 0.]]) Notes ----- The principal calling routine is aggregation.smooth.energy_prolongation_smoother, which uses the Cpt_param dictionary for root-node style prolongation smoothing zExpected BSR or CSR matrix AzExpected CSR matrix AggOpr rrz*Expected square blocksize for BSR matrix TzExpected square matrix Az[Expected compatible dimensions for T and A, T.shape[0] = A.shape[0]zRNumber of columns in AggOp must equal number of CnodesrBz+Expected number of Cpts to match T.shape[1]z'Expected identical blocksize in A and TzUNumber of rows in AggOp must equal number of fine-grid nodescsrrJrzrr)rrr)rrI_CCptsFpts)rrrrr0r%repeatrflistrprHr<r rDrErrGrr=rrCrFr r)rCnodesAggOpr|rrkncoarserrrrGrFrs rget_Cpt_paramsrPs+R !  8^A%6%686777 % 53444 !  1/000{1~Q''DEEEwqzQWQZ2333wqzQWQZ233 3 |A%+a.(( ;q>A  ()) )aQ[^a//KN y6)955q)$$ @ @A eAtz!}i8899 : : :a ? : : : : @  8D $ $ $D z!} "" 71: ! !JKK KAKN""BCCC {1~QWQZ 12222+,, ,gajG agaj!'!*U 3 3 3C ((**CCHTN )C ;    D  w{{))++7=+A-..(4qy777719,ahn=== chmmoow7IaL'2 4 4 4C ))AK Ca*ii $$ii $$ii&i))ii&i))s3d K KKrc t|st|std|jd|jdkrtdt|r|jd}|jd}nd}d}|jd}|jd}|jd}t ||z }t j|||f|j}tt|dz} t j|| f|j} d} t|D]} t| |D]} t j t j t j |dd| ft j t j |dd| fz| dd| f<| dz} tj|||t j t j | | t j t j ||j|j|d}t)j||S)aCreate block inverses. Helper function that creates inv(B_i.T B_i) for each block row i in C, where B_i is B restricted to the sparsity pattern of block row i. Parameters ---------- B : {array} (M,k) array, typically near-nullspace modes for coarse grid, i.e., B_c. C : {csr_matrix, bsr_matrix} Sparse NxM matrix, whose sparsity structure (i.e., matrix graph) is used to determine BtBinv. Returns ------- BtBinv : {array} BtBinv[i] = inv(B_i.T B_i), where B_i is B restricted to the nonzero pattern of block row i in C. Examples -------- >>> from numpy import array >>> from scipy.sparse import bsr_matrix >>> from pyamg.util.utils import compute_BtBinv >>> T = array([[ 1., 0.], ... [ 1., 0.], ... [ 0., .5], ... [ 0., .25]]) >>> T = bsr_matrix(T) >>> B = array([[1.],[2.]]) >>> compute_BtBinv(B, T) array([[[1. ]], [[1. ]], [[0.25]], [[0.25]]]) Notes ----- The principal calling routines are aggregation.smooth.energy_prolongation_smoother, and util.utils.filter_operator. BtBinv is used in the prolongation smoothing process that incorporates B into the span of prolongation with row-wise projection operators. It is these projection operators that BtBinv is part of. z'Expected bsr_matrix or csr_matrix for Crrz*Expected matching dimensions such that C*BrBN)rrr)rrrr0rrHr%rrCrrfr~r&r4rcalc_BtBrFrG transposerDrr)rhrQrrNcoarserr rrBsqColsBsqcounterrkrs rrrsFf !  C^A%6%6CABBBwqzQWQZDEEEaQQgajG GAJEgajG ~% & &FXvw0 @ @ @F% ""##G (GW%QW 5 5 5CG 7^^""q'"" " "A l28BJqAw4G4G+H+HIIAaaadG,,--.C7 OkGG "  gv~hrz#//rx 6(:(:;;h +++  i ( ( - - / /F f MrRQ?c|}tj|j|_t |dd}|||tj|jdf|z|z zk}t|}|dkrMtj|t}| d|}tj |d}||k}t|jd|jdd }d |j|<||z|z}d |j|<d |jtj |dkd<||z}~|S) aEliminate diagonally dominance. Helper function that eliminates diagonally dominant rows and cols from A in the separate matrix C. This is useful because it eliminates nodes in C which we don't want coarsened. These eliminated nodes in C just become the rows and columns of the identity. Parameters ---------- A : {csr_matrix, bsr_matrix} Sparse NxN matrix C : {csr_matrix} Sparse MxM matrix, where M is the number of nodes in A. M=N if A is CSR or is BSR with blocksize 1. Otherwise M = N/blocksize. theta : {float} determines diagonal dominance threshold Returns ------- C : {csr_matrix} C updated such that the rows and columns corresponding to diagonally dominant rows in A have been eliminated and replaced with rows and columns of the identity. Notes ----- Diagonal dominance is defined as :math:`\| (e_i, A) - a_{ii} \|_1 < \\theta a_{ii}` that is, the 1-norm of the off diagonal elements in row i must be less than theta times the diagonal element. Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.util.utils import eliminate_diag_dom_nodes >>> A = poisson( (4,), format='csr' ) >>> C = eliminate_diag_dom_nodes(A, A.copy(), 1.1) >>> C.toarray() array([[ 1., 0., 0., 0.], [ 0., 2., -1., 0.], [ 0., -1., 2., 0.], [ 0., 0., 0., 1.]]) rF)rrrBrr)axisrrrzrW)rDr%r[rErrr0rrprHrrr where)rrQthetaA_absD_abs diag_dom_rowsbsizeIds reliminate_diag_dom_nodesr0CsX\ FFHHE ##EJ u 5 5 5EeU27EKN3D9>,@,@,@&@BG&HIJM % E qyyc::: %--b%88 }1555 %.  QWQZE 2 2 2B BGM Q A BGM/2BGBH]a' ( ( +, BA Hrcvt|std|jd|jdkrtd|jt |}|j|jk}|j||_|j||_|j||_|S)aRemove the diagonal of the matrix S. Parameters ---------- S : csr_matrix Square matrix Returns ------- S : csr_matrix Strength matrix with the diagonal removed Notes ----- This is needed by all the splitting routines which operate on matrix graphs with an assumed zero diagonal Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.util.utils import remove_diagonal >>> A = poisson( (4,), format='csr' ) >>> C = remove_diagonal(A) >>> C.toarray() array([[ 0., -1., 0., 0.], [-1., 0., -1., 0.], [ 0., -1., 0., -1.], [ 0., 0., -1., 0.]]) expected csr_matrixrrzexpected square matrix, shape=) rrr0r<r rrrEr)Sr_s rremove_diagonalr4s@ !  /-...wqzQWQZC!'CCDDD1 A 5AE>D E$KAE E$KAE VD\AF 7799rcDt|stdtj|jdf|j}t j|jd||j|j |j d||dkz ||dk<t||d}|S)a{Scale each row in S by it's largest in magnitude entry. Parameters ---------- S : csr_matrix Returns ------- S : csr_matrix Each row has been scaled by it's largest in magnitude entry Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.util.utils import scale_rows_by_largest_entry >>> A = poisson( (4,), format='csr' ) >>> A.data[1] = 5.0 >>> A = scale_rows_by_largest_entry(A) >>> A.toarray() array([[ 0.4, 1. , 0. , 0. ], [-0.5, 1. , -0.5, 0. ], [ 0. , -0.5, 1. , -0.5], [ 0. , 0. , -0.5, 1. ]]) r2rrBrWTrX) rrr%rr0rCrmaximum_row_valuerFrGrErK)r3largest_row_entrys rscale_rows_by_largest_entryr8s4 !  /-...!'!*ag>>> qwqz+< xAF<<<  1Q 677'1,-1'd333A Hrcttr5ddkr gd}d}nJfdt|dz Dn*ttr4dkrt dfdt|dz Dntt rtdtr'dddkrt dz}d}nt |dz krE|dz t z }fd t|D}|n.d t|dz Dnt d ||fS) a]Turn parameter into a list per level. Helper function to preprocess the strength and aggregation parameters passed to smoothed_aggregation_solver and rootnode_solver. Parameters ---------- to_levelize : {string, tuple, list} Parameter to preprocess, i.e., levelize and convert to a level-by-level list such that entry i specifies the parameter at level i max_levels : int Defines the maximum number of levels considered max_coarse : int Defines the maximum coarse grid size allowed Returns ------- (max_levels, max_coarse, to_levelize) : tuple New max_levels and max_coarse values and then the parameter list to_levelize, such that entry i specifies the parameter choice at level i. max_levels and max_coarse are returned, because they may be updated if strength or aggregation set a predefined coarsening and possibly change these values. Notes ----- This routine is needed because the user will pass in a parameter option such as smooth='jacobi', or smooth=['jacobi', None], and this option must be "levelized", or converted to a list of length max_levels such that entry [i] in that list is the parameter choice for level i. The parameter choice in to_levelize can be a string, tuple or list. If it is a string or tuple, then that option is assumed to be the parameter setting at every level. If to_levelize is inititally a list, if the length of the list is less than max_levels, the last entry in the list defines that parameter for all subsequent levels. Examples -------- >>> from pyamg.util.utils import levelize_strength_or_aggregation >>> strength = ['evolution', 'classical'] >>> levelize_strength_or_aggregation(strength, 4, 10) (4, 10, ['evolution', 'classical', 'classical']) r predefinedrcg|]}Sr<.0rk to_levelizes r z4levelize_strength_or_aggregation..sDDD1;DDDrrzpredefined to_levelize requires a user-provided CSR matrix representing strength or aggregation i.e., ("predefined", {"C" : CSR_MAT}).cg|]}Sr<r<r=s rr@z4levelize_strength_or_aggregation..s@@@q{@@@rrc g|] }d Srr<r=s rr@z4levelize_strength_or_aggregation..+s===QR===rNcg|]}difSr"r<r>rks rr@z4levelize_strength_or_aggregation../s???abz???rzinvalid to_levelize)rrrfrr<rr>extend)r? max_levels max_coarsemlztoexts` r levelize_strength_or_aggregationrKs^+u%%0 q>\ ) )&-KJJJDDDDjl0C0CDDDKK K % %0 , & &FGG GA@@@E*Q,,?,?@@@ K & &0 k"ou - - * OA , . .[))A-JJJ;*Q,.. 1ns;'7'77====%**===""5)))  ??5A+>+>??? ./// z; ..rcttr*tdtrttttfrfdt |DnttrVt |krB|t z }fdt |D}|ndt |DS)aTurn parameter in to a list per level. Helper function to preprocess the smooth and improve_candidates parameters passed to smoothed_aggregation_solver and rootnode_solver. Parameters ---------- to_levelize : {string, tuple, list} Parameter to preprocess, i.e., levelize and convert to a level-by-level list such that entry i specifies the parameter at level i max_levels : int Defines the maximum number of levels considered Returns ------- to_levelize : list The parameter list such that entry i specifies the parameter choice at level i. Notes ----- This routine is needed because the user will pass in a parameter option such as smooth='jacobi', or smooth=['jacobi', None], and this option must be "levelized", or converted to a list of length max_levels such that entry [i] in that list is the parameter choice for level i. The parameter choice in to_levelize can be a string, tuple or list. If it is a string or tuple, then that option is assumed to be the parameter setting at every level. If to_levelize is inititally a list, if the length of the list is less than max_levels, the last entry in the list defines that parameter for all subsequent levels. Examples -------- >>> from pyamg.util.utils import levelize_smooth_or_improve_candidates >>> improve_candidates = ['gauss_seidel', None] >>> levelize_smooth_or_improve_candidates(improve_candidates, 4) ['gauss_seidel', None, None, None] rcg|]}Sr<r<r=s rr@z9levelize_smooth_or_improve_candidates..is>>>q{>>>rc g|] }d SrCr<r=s rr@z9levelize_smooth_or_improve_candidates..ms999[_999rNcg|]}difSr"r<rEs rr@z9levelize_smooth_or_improve_candidates..ps===abz===r)rrrrrfr>rF)r?rGrIrJs` r%levelize_smooth_or_improve_candidatesrP6s\+u%%, k!ne , , ,{++K+U|,,>>>>>E*,=,=>>> K & &> {  j ( (s;///C9999eCjj999E   u % % %  ==5+<+<=== rc xt|stdd}t|r|j}|j}|dks|dkrtd|}|}|xj|jdz c_|xj|jdz c_tj |jd||j |j|j |j |j|j |jd|j dxx|jdzcc<t|j d|j d|jd|j d|j f|j}~|d kr||}n||}|S) aFilter each column of A with tol. i.e., drop all entries in column k where abs(A[i,k]) < tol max( abs(A[:,k]) ) Parameters ---------- A : sparse_matrix theta : float In range [0,1) and defines drop-tolerance used to filter the columns of A Returns ------- A_filter : sparse_matrix Each column has been filtered by dropping all entries where abs(A[i,k]) < tol max( abs(A[:,k]) ) Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.util.utils import filter_matrix_columns >>> from numpy import array >>> from scipy.sparse import csr_matrix >>> A = csr_matrix( array([[ 0.24, 1. , 0. ], ... [-0.5 , 1. , -0.5 ], ... [ 0. , 0.49, 1. ], ... [ 0. , 0. , -0.5 ]]) ) >>> filter_matrix_columns(A, 0.5).toarray() array([[ 0. , 1. , 0. ], [-0.5, 1. , -0.5], [ 0. , 0. , 1. ], [ 0. , 0. , -0.5]]) Sparse matrix input neededrrrWtheta must be in [0,1)Nrrbsr)rr<rrrJrDrrGr0r$classical_strength_of_connection_absrFrEr rrL)rr*rAformatA_filters rfilter_matrix_columnsrXusJ a==75666Ia K hG  u||1222 AvvxxHIIII  " 1!'!*2723(23)23&2:/2:2B2:-AAA )hob))***hnQ.??***8=)=(/"*=)=>#+,@X_R-@,@A#?,3;>CCCH %>>),,$$W-- Orc Vt|stdd}t|r|j}|j}|}|dks|dkrtd|ret j|jd||j |j |j || |dkr| |}dS|}|xj |jdz c_ |xj |jdz c_ t j|jd||j |j |j |j |j |j |j d|j d xx|jdzcc<t!|j d|j d |j d|j d |j f|j }|dkr| |}n||}|xj |jdzc_ |S) aFilter each row of A with tol. i.e., drop all entries in row k where abs(A[i,k]) < tol max( abs(A[:,k]) ) Parameters ---------- A : sparse_matrix theta : float In range [0,1) and defines drop-tolerance used to filter the row of A diagonal : bool If True, filter by diagonal entry. Otherwise, filter by maximum absolute value in row. This is in place. lump : bool If True, instead of removing entries, lump them to diagonal. Preserves row sum of matrix. Returns ------- A_filter : sparse_matrix Each row has been filtered by dropping all entries where abs(A[i,k]) < tol max( abs(A[:,k]) ) If `diagonal == True`, then no return (None). Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.util.utils import filter_matrix_rows >>> from numpy import array >>> from scipy.sparse import csr_matrix >>> A = csr_matrix( array([[ 0.24, -0.5 , 0. , 0. ], ... [ 1. , 1. , 0.49, 0. ], ... [ 0. , -0.5 , 1. , -0.5 ]]) ) >>> filter_matrix_rows(A, 0.5).toarray() array([[ 0. , -0.5, 0. , 0. ], [ 1. , 1. , 0. , 0. ], [ 0. , -0.5, 1. , -0.5]]) rRrrrWrSrTrNrr)rr<rrrJrrfilter_matrix_rowsr0rFrGrErrrDrUrrL)rr*r:lumprrVrWs rrZrZs9R a==75666Ia K hG  A  u||1222#AGAJqx$%Iqvt = = =  e  ),,At vvxxHIIII  " 1!'!*2723(23)23&2:/2:2B2:-AAA )hob))***hnQ.??***8=)=(/"*=)=>#+,@X_R-@,@A#?,3;>CCCH%>>),,$$W--IIII Orct|stdd}t|r|j}t |r|}|j}|}t|}tj |j d||j |j |j||dkr||}n||}|S)aoTruncate the rows of A by keeping only the largest in magnitude entries in each row. Parameters ---------- A : sparse_matrix nz_per_row : int Determines how many entries in each row to keep Returns ------- A : sparse_matrix Each row has been truncated to at most nz_per_row entries Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.util.utils import truncate_rows >>> from numpy import array >>> from scipy.sparse import csr_matrix >>> A = csr_matrix( array([[-0.24, -0.5 , 0. , 0. ], ... [ 1. , -1.1 , 0.49, 0.1 ], ... [ 0. , 0.4 , 1. , 0.5 ]]) ) >>> truncate_rows(A, 2).toarray() array([[-0.24, -0.5 , 0. , 0. ], [ 1. , -1.1 , 0. , 0. ], [ 0. , 0. , 1. , 0.5 ]]) rRrrrT)rr<rrrrDrJrrHrtruncate_rows_csrr0rFrGrErrrL)r nz_per_rowrrVs r truncate_rowsr_ s< a==75666Ia K a FFHHhG  AZJ qwqz:qx y!&222% GGI   JJw   Hrc dt|std|jd|jdkrtdt j|jd|dkrtdt |st|||f}|j||fkr| ||f}|jd|z }t||d}t|t j d|t j d|dzf||g|j }||z|fS) a1Get inverse of block diagonal of A and scale A, A = D^{-1}A. Parameters ---------- A : csr or bsr_matrix Matrix to scale by block inverse. blocksize : int Blocksize of matrix. Returns ------- tuple, (D^{-1}*A, D^{-1}) Notes ----- This is not a symmetric scaling. Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.util.utils import scale_block_inverse >>> A = poisson((4,), format='csr') >>> A, Dinv = scale_block_inverse(A, 2) >>> A.toarray() array([[ 1. , 0. , -0.33333333, 0. ], [ 0. , 1. , -0.66666667, 0. ], [ 0. , -0.66666667, 1. , 0. ], [ 0. , -0.33333333, 0. , 1. ]]) rrrrrrT)rrr)rr0) rrr0r<r%rrr rrrr=)rrN_blockrscales rscale_block_inversercVsC< a==20111wqzQWQZ1222 vagaj)$$))CDDD !  < qY $: ; ; ;{y),,, GGy)4G 5 5gaj9$G AT B B BD bi733RYq'!)5L5LM"+Y!7qw H H HE 19e rr")T)FF)rrrrTr)r&):__doc__warningsrnumpyr% scipy.sparserrrrrr r r r scipy.linalgr scipy.sparse._sparsetoolsrrrr!scipy.sparse.linalg._isolve.utilsrscipy.sparse._sputilsrrrrrr8r?rKrUr]rlrurnrrrrrrrr rrrr0r4r8rKrPrXrZr_rcr<rrrls**HHHHHHHHHHHHHHHHHHHHHH MMMMMMMMMMMM:99999((((((   /!/!/!/!d&?&?&?RF F F F RK K K K \H.H.H.H.VHHHHV+++\...b< < < < ~YYYYx3)3)3)l0+0+0+fMN(+nnnnbUUUUpssslY Y Y Y xj j j ZRLRLRLj[[[|E E E E P,,,^& & & RP/P/P/f<<<~LLL^YYYYx3 3 3 l00000r