isJdZddlZddlZddlZddlmZddlmZm Z m Z m Z ddgZ GddZ Gdd e ZGd d e ZGd d e ZddZGdde ZGdde ZGdde ZGdde ZGdde ZGddeZGdde ZdZy)aUAbstract linear algebra library. This module defines a class hierarchy that implements a kind of "lazy" matrix representation, called the ``LinearOperator``. It can be used to do linear algebra with extremely large sparse or structured matrices, without representing those explicitly in memory. Such matrices can be added, multiplied, transposed, etc. As a motivating example, suppose you want have a matrix where almost all of the elements have the value one. The standard sparse matrix representation skips the storage of zeros, but not ones. By contrast, a LinearOperator is able to represent such matrices efficiently. First, we need a compact way to represent an all-ones matrix:: >>> import numpy as np >>> from scipy.sparse.linalg._interface import LinearOperator >>> class Ones(LinearOperator): ... def __init__(self, shape): ... super().__init__(dtype=None, shape=shape) ... def _matvec(self, x): ... return np.repeat(x.sum(), self.shape[0]) Instances of this class emulate ``np.ones(shape)``, but using a constant amount of storage, independent of ``shape``. The ``_matvec`` method specifies how this linear operator multiplies with (operates on) a vector. We can now add this operator to a sparse matrix that stores only offsets from one:: >>> from scipy.sparse.linalg._interface import aslinearoperator >>> from scipy.sparse import csr_array >>> offsets = csr_array([[1, 0, 2], [0, -1, 0], [0, 0, 3]]) >>> A = aslinearoperator(offsets) + Ones(offsets.shape) >>> A.dot([1, 2, 3]) array([13, 4, 15]) The result is the same as that given by its dense, explicitly-stored counterpart:: >>> (np.ones(A.shape, A.dtype) + offsets.toarray()).dot([1, 2, 3]) array([13, 4, 15]) Several algorithms in the ``scipy.sparse`` library are able to operate on ``LinearOperator`` instances. N)issparse)isshape isintlikeasmatrixis_pydata_spmatrixLinearOperatoraslinearoperatorceZdZdZdZdZeejZ fdZ dZ dZ dZ dZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"e#e"Z$dZ%e#e%Z&dZ'dZ(xZ)S) raCommon interface for performing matrix vector products Many iterative methods (e.g. `cg`, `gmres`) do not need to know the individual entries of a matrix to solve a linear system ``A@x = b``. Such solvers only require the computation of matrix vector products, ``A@v`` where ``v`` is a dense vector. This class serves as an abstract interface between iterative solvers and matrix-like objects. To construct a concrete `LinearOperator`, either pass appropriate callables to the constructor of this class, or subclass it. A subclass must implement either one of the methods ``_matvec`` and ``_matmat``, and the attributes/properties ``shape`` (pair of integers) and ``dtype`` (may be None). It may call the ``__init__`` on this class to have these attributes validated. Implementing ``_matvec`` automatically implements ``_matmat`` (using a naive algorithm) and vice-versa. Optionally, a subclass may implement ``_rmatvec`` or ``_adjoint`` to implement the Hermitian adjoint (conjugate transpose). As with ``_matvec`` and ``_matmat``, implementing either ``_rmatvec`` or ``_adjoint`` implements the other automatically. Implementing ``_adjoint`` is preferable; ``_rmatvec`` is mostly there for backwards compatibility. Parameters ---------- shape : tuple Matrix dimensions ``(M, N)``. matvec : callable f(v) Returns returns ``A @ v``. rmatvec : callable f(v) Returns ``A^H @ v``, where ``A^H`` is the conjugate transpose of ``A``. matmat : callable f(V) Returns ``A @ V``, where ``V`` is a dense matrix with dimensions ``(N, K)``. dtype : dtype Data type of the matrix. rmatmat : callable f(V) Returns ``A^H @ V``, where ``V`` is a dense matrix with dimensions ``(M, K)``. Attributes ---------- args : tuple For linear operators describing products etc. of other linear operators, the operands of the binary operation. ndim : int Number of dimensions (this is always 2) See Also -------- aslinearoperator : Construct LinearOperators Notes ----- The user-defined `matvec` function must properly handle the case where ``v`` has shape ``(N,)`` as well as the ``(N,1)`` case. The shape of the return type is handled internally by `LinearOperator`. It is highly recommended to explicitly specify the `dtype`, otherwise it is determined automatically at the cost of a single matvec application on ``int8`` zero vector using the promoted `dtype` of the output. Python ``int`` could be difficult to automatically cast to numpy integers in the definition of the `matvec` so the determination may be inaccurate. It is assumed that `matmat`, `rmatvec`, and `rmatmat` would result in the same dtype of the output given an ``int8`` input as `matvec`. LinearOperator instances can also be multiplied, added with each other and exponentiated, all lazily: the result of these operations is always a new, composite LinearOperator, that defers linear operations to the original operators and combines the results. More details regarding how to subclass a LinearOperator and several examples of concrete LinearOperator instances can be found in the external project `PyLops `_. Examples -------- >>> import numpy as np >>> from scipy.sparse.linalg import LinearOperator >>> def mv(v): ... return np.array([2*v[0], 3*v[1]]) ... >>> A = LinearOperator((2,2), matvec=mv) >>> A <2x2 _CustomLinearOperator with dtype=int8> >>> A.matvec(np.ones(2)) array([ 2., 3.]) >>> A @ np.ones(2) array([ 2., 3.]) Nc,|turt| tSt| |}t |j tj k(rBt |j tj k(rtjdtd|S)NzMLinearOperator subclass should implement at least one of _matvec and _matmat.r )category stacklevel) rsuper__new___CustomLinearOperatortype_matvec_matmatwarningswarnRuntimeWarning)clsargskwargsobj __class__s s/Volumes/fast/ai/experiments/voice-extract-mac/.venv/lib/python3.12/site-packages/scipy/sparse/linalg/_interface.pyrzLinearOperator.__new__sx . 7?#89 9'/#&CS !!^%;%;;S ))^-C-CC F'5!EJc|tj|}t|}t|st d|d||_||_y)zInitialize this LinearOperator. To be called by subclasses. ``dtype`` may be None; ``shape`` should be convertible to a length-2 tuple. Nzinvalid shape z (must be 2-d))npdtypetupler ValueErrorshape)selfr!r$s r__init__zLinearOperator.__init__sI  HHUOEe u~~eYnEF F  rcH|jitj|jdtj} tj |j |}|j|_yy#t$r!tjt|_YywxYw)aDetermine the dtype by executing `matvec` on an `int8` test vector. In `np.promote_types` hierarchy, the type `int8` is the smallest, so we call `matvec` on `int8` and use the promoted dtype of the output to set the default `dtype` of the `LinearOperator`. We assume that `matmat`, `rmatvec`, and `rmatmat` would result in the same dtype of the output given an `int8` input as `matvec`. Called from subclasses at the end of the __init__ routine. N)r!) r!r zerosr$int8asarraymatvec OverflowErrorint)r%vmatvec_vs r _init_dtypezLinearOperator._init_dtypesw :: Brww7A ,::dkk!n5 &^^  ! +XXc]  +s$A77'B! B!c tj|jDcgc]#}|j|j dd%c}Scc}w)zDefault matrix-matrix multiplication handler. Falls back on the user-defined _matvec method, so defining that will define matrix multiplication (though in a very suboptimal way). r()r hstackTr,reshaper%Xcols rrzLinearOperator._matmats=yyACCHCS$++ckk"Q&78CHIIHs(A cD|j|jddS)ayDefault matrix-vector multiplication handler. If self is a linear operator of shape (M, N), then this method will be called on a shape (N,) or (N, 1) ndarray, and should return a shape (M,) or (M, 1) ndarray. This default implementation falls back on _matmat, so defining that will define matrix-vector multiplication as well. r(r3)matmatr6r%xs rrzLinearOperator._matvecs{{199R+,,rctj|}|j\}}|j|fk7r|j|dfk7r td|j |}t |tj r t|}ntj|}|jdk(r|j|}|S|jdk(r|j|d}|Std)axMatrix-vector multiplication. Performs the operation y=A@x where A is an MxN linear operator and x is a column vector or 1-d array. Parameters ---------- x : {matrix, ndarray} An array with shape (N,) or (N,1). Returns ------- y : {matrix, ndarray} A matrix or ndarray with shape (M,) or (M,1) depending on the type and shape of the x argument. Notes ----- This matvec wraps the user-specified matvec routine or overridden _matvec method to ensure that y has the correct shape and type. r3dimension mismatchr z/invalid shape returned by user-defined matvec()) r asanyarrayr$r#r isinstancematrixrr+ndimr6r%r=MNys rr,zLinearOperator.matvecs0 MM! jj! 77qd?qww1Q%/12 2 LLO a # A 1 A 66Q; ! A  VVq[ !AANO Orctj|}|j\}}|j|fk7r|j|dfk7r td|j |}t |tj r t|}ntj|}|jdk(r|j|}|S|jdk(r|j|d}|Std)aAdjoint matrix-vector multiplication. Performs the operation y = A^H @ x where A is an MxN linear operator and x is a column vector or 1-d array. Parameters ---------- x : {matrix, ndarray} An array with shape (M,) or (M,1). Returns ------- y : {matrix, ndarray} A matrix or ndarray with shape (N,) or (N,1) depending on the type and shape of the x argument. Notes ----- This rmatvec wraps the user-specified rmatvec routine or overridden _rmatvec method to ensure that y has the correct shape and type. r3r?r z0invalid shape returned by user-defined rmatvec()) r r@r$r#_rmatvecrArBrr+rCr6rDs rrmatveczLinearOperator.rmatvecs0 MM! jj! 77qd?qww1Q%/12 2 MM!  a # A 1 A 66Q; ! A  VVq[ !AAOP PrcTt|jtjk(rht|drVt|jtjk7r0|j |j ddj dSt |jj|S)z6Default implementation of _rmatvec; defers to adjoint._rmatmatr(r3) r_adjointrhasattrrLr6NotImplementedErrorHr,r<s rrIzLinearOperator._rmatvecEsz :  ."9"9 9j)T ++~/F/FF}}QYYr1%56>>rBB% %66==# #rc t|s t|stj|}|jdk7rt d|jd|j d|j dk7r%t d|j d|j  |j|}t|tjr t|}|S#t$r(}t|s t|r td|d }~wwxYw) aPMatrix-matrix multiplication. Performs the operation y=A@X where A is an MxN linear operator and X dense N*K matrix or ndarray. Parameters ---------- X : {matrix, ndarray} An array with shape (N,K). Returns ------- Y : {matrix, ndarray} A matrix or ndarray with shape (M,K) depending on the type of the X argument. Notes ----- This matmat wraps any user-specified matmat routine or overridden _matmat method to ensure that y has the correct type. r $expected 2-d ndarray or matrix, not -drr3dimension mismatch: , zdUnable to multiply a LinearOperator with a sparse matrix. Wrap the matrix in aslinearoperator first.N) rrr r@rCr#r$r Exception TypeErrorrArBrr%r8Yes rr;zLinearOperator.matmatQs. 1!4 a A 66Q;CAFF82NO O 771:A &3DJJ#NO O66==# #Os(Bc ||zSNr<s r__call__zLinearOperator.__call__s Av rc$|j|Sr`)dotr<s r__mul__zLinearOperator.__mul__sxx{rc`tj|s tdt|d|z S)Nz.Can only divide a linear operator by a scalar.g?)r isscalarr#_ScaledLinearOperatorr%others r __truediv__zLinearOperator.__truediv__s+{{5!MN N$T3u955rct|tr t||Stj|r t ||St |s t|stj|}|jdk(s!|jdk(r#|jddk(r|j|S|jdk(r|j|Std|)arMatrix-matrix or matrix-vector multiplication. Parameters ---------- x : array_like 1-d or 2-d array, representing a vector or matrix. Returns ------- Ax : array 1-d or 2-d array (depending on the shape of x) that represents the result of applying this linear operator on x. r3r )expected 1-d or 2-d array or matrix, got )rAr_ProductLinearOperatorr rgrhrrr+rCr$r,r;r#r<s rrdzLinearOperator.dots a ()$2 2 [[^(q1 1A;'9!'<JJqMvv{affkaggajAo{{1~%1{{1~% #LQE!RSSrcdtj|r td|j|SNz0Scalar operands are not allowed, use '*' instead)r rgr#reris r __matmul__zLinearOperator.__matmul__s/ ;;u /0 0||E""rcdtj|r td|j|Srp)r rgr#__rmul__ris r __rmatmul__zLinearOperator.__rmatmul__s/ ;;u /0 0}}U##rcftj|r t||S|j|Sr`)r rgrh_rdotr<s rrszLinearOperator.__rmul__s( ;;q>(q1 1::a= rc(t|tr t||Stj|r t ||St |s t|stj|}|jdk(s!|jdk(rA|jddk(r/|jj|jjS|jdk(r/|jj|jjStd|)aMatrix-matrix or matrix-vector multiplication from the right. Parameters ---------- x : array_like 1-d or 2-d array, representing a vector or matrix. Returns ------- xA : array 1-d or 2-d array (depending on the shape of x) that represents the result of applying this linear operator on x from the right. Notes ----- This is copied from dot to implement right multiplication. r3r rrm)rArrnr rgrhrrr+rCr$r5r,r;r#r<s rrvzLinearOperator._rdots$ a ()!T2 2 [[^(q1 1A;'9!'<JJqMvv{affkaggajAovv}}QSS)+++1vv}}QSS)+++ #LQE!RSSrcPtj|r t||StSr`)r rg_PowerLinearOperatorNotImplemented)r%ps r__pow__zLinearOperator.__pow__s ;;q>'a0 0! !rcFt|tr t||StSr`)rAr_SumLinearOperatorrzr<s r__add__zLinearOperator.__add__s a (%dA. .! !rct|dS)Nr()rhr%s r__neg__zLinearOperator.__neg__!s$T2..rc&|j| Sr`)rr<s r__sub__zLinearOperator.__sub__$s||QBrc |j\}}|jd}ndt|jz}d|d|d|jjd|d S)Nzunspecified dtypezdtype=)r$r!strr__name__)r%rErFdts r__repr__zLinearOperator.__repr__'s\jj! :: $BC O+B1#Qqc4>>2236"Q??rc"|jS)aHermitian adjoint. Returns the Hermitian adjoint of self, aka the Hermitian conjugate or Hermitian transpose. For a complex matrix, the Hermitian adjoint is equal to the conjugate transpose. Can be abbreviated self.H instead of self.adjoint(). Returns ------- A_H : LinearOperator Hermitian adjoint of self. )rMrs radjointzLinearOperator.adjoint0s}}rc"|jS)zTranspose this linear operator. Returns a LinearOperator that represents the transpose of this one. Can be abbreviated self.T instead of self.transpose(). ) _transposers r transposezLinearOperator.transposeBs   rct|S)z6Default implementation of _adjoint; defers to rmatvec.)_AdjointLinearOperatorrs rrMzLinearOperator._adjointLs %d++rct|S)z? Default implementation of _transpose; defers to rmatvec + conj)_TransposedLinearOperatorrs rrzLinearOperator._transposePs (..r)*r __module__ __qualname____doc__rC__array_ufunc__ classmethodtypes GenericAlias__class_getitem__rr&r1rrr,rJrIr;r]rLrbrerkrdrqrtrsrvr|rrrrrpropertyrPrr5rMr __classcell__rs@rrr8s\| DO$E$6$67  ,*J --^-^ $-^+Z$6 T># $ ! "TH" " / @ A! A,/rcNeZdZdZ dfd ZfdZdZdZfdZdZ xZ S) rz>Linear operator defined in terms of user-specified operations.ct|||d|_||_||_||_||_|jy)Nra)rr&r"_CustomLinearOperator__matvec_impl#_CustomLinearOperator__rmatvec_impl#_CustomLinearOperator__rmatmat_impl"_CustomLinearOperator__matmat_implr1)r%r$r,rJr;r!r]rs rr&z_CustomLinearOperator.__init__XsE & #%%# rc\|j|j|St| |Sr`)rrrr%r8rs rrz_CustomLinearOperator._matmates/    )%%a( (7?1% %rc$|j|Sr`)rr<s rrz_CustomLinearOperator._matvecks!!!$$rcV|j}| td|j|S)Nzrmatvec is not defined)rrO)r%r=funcs rrIz_CustomLinearOperator._rmatvecns/"" <%&>? ?""1%%rc\|j|j|St| |Sr`)rrrLrs rrLz_CustomLinearOperator._rmatmatts0    *&&q) )7#A& &rct|jd|jdf|j|j|j|j |j S)Nr3r)r$r,rJr;r]r!)rr$rrrrr!rs rrMz_CustomLinearOperator._adjointzsQ$DJJqM4::a=+I,0,?,?-1-?-?,0,?,?-1-?-?+/:: 7 7r)NNNN) rrrrr&rrrIrLrMrrs@rrrUs*H;?%) & %& ' 7rrc:eZdZdZfdZdZdZdZdZxZ S)rz$Adjoint of arbitrary Linear Operatorc|jd|jdf}t| |j|||_|f|_yNr3r)r!r$r$rr&r!Arr%rr$rs rr&z_AdjointLinearOperator.__init__CQWWQZ( qwwe4D rc8|jj|Sr`)rrIr<s rrz_AdjointLinearOperator._matvecvvq!!rc8|jj|Sr`)rrr<s rrIz_AdjointLinearOperator._rmatvecvv~~a  rc8|jj|Sr`)rrLr<s rrz_AdjointLinearOperator._matmatrrc8|jj|Sr`)rrr<s rrLz_AdjointLinearOperator._rmatmatrr rrrrr&rrIrrLrrs@rrrs. "!"!rrc:eZdZdZfdZdZdZdZdZxZ S)rz*Transposition of arbitrary Linear Operatorc|jd|jdf}t| |j|||_|f|_yrrrs rr&z"_TransposedLinearOperator.__init__rrctj|jjtj|Sr`)r conjrrIr<s rrz!_TransposedLinearOperator._matvec&wwtvvrwwqz233rctj|jjtj|Sr`)r rrrr<s rrIz"_TransposedLinearOperator._rmatvec&wwtvv~~bggaj122rctj|jjtj|Sr`)r rrrLr<s rrz!_TransposedLinearOperator._matmatrrctj|jjtj|Sr`)r rrrr<s rrLz"_TransposedLinearOperator._rmatmatrrrrs@rrrs4 4343rrc|g}|D]-}|t|ds|j|j/tj|S)Nr!)rNappendr!r result_type) operatorsdtypesrs r _get_dtypersE ~ ?wsG4 MM#)) $ >>6 ""rc<eZdZfdZdZdZdZdZdZxZ S)r~ct|trt|ts td|j|jk7rtd|d|d||f|_t |t||g|jy)N)both operands have to be a LinearOperatorz cannot add  and : shape mismatch)rArr#r$rrr&rr%rBrs rr&z_SumLinearOperator.__init__su!^,q.1HI I 77agg {1#U1#5EFG GF  QF+QWW5rc||jdj||jdj|zSNrr3rr,r<s rrz_SumLinearOperator._matvec3yy|""1% ! (;(;A(>>>rc||jdj||jdj|zSrrrJr<s rrIz_SumLinearOperator._rmatvec3yy|##A&1)=)=a)@@@rc||jdj||jdj|zSrrr]r<s rrLz_SumLinearOperator._rmatmatrrc||jdj||jdj|zSrrr;r<s rrz_SumLinearOperator._matmatrrcR|j\}}|j|jzSr`rrPr%rrs rrMz_SumLinearOperator._adjoint!yy1ssQSSyr rrrr&rrIrLrrMrrs@rr~r~s#6?AA?rr~c<eZdZfdZdZdZdZdZdZxZ S)rnc>t|trt|ts td|jd|jdk7rtd|d|dt|t ||g|jd|jdf||f|_y)Nrr3rzcannot multiply rr)rArr#r$rr&rrrs rr&z_ProductLinearOperator.__init__s!^,q.1HI I 771: #/s%s:JKL L QF+67ggaj!''!*5M OF rcv|jdj|jdj|Srrr<s rrz_ProductLinearOperator._matvec.yy|""499Q<#6#6q#9::rcv|jdj|jdj|SNr3rrr<s rrIz_ProductLinearOperator._rmatvec.yy|##DIIaL$8$8$;<>>rctj|jd|jdj|zSr)r rrr]r<s rrLz_ScaledLinearOperator._rmatmatrrc^|jd|jdj|zSrrr<s rrz_ScaledLinearOperator._matmat rrcd|j\}}|jtj|zSr`)rrPr r)r%rrs rrMz_ScaledLinearOperator._adjoint s&995ssRWWU^##rrrs@rrhrhs!  5??5$rrhcBeZdZfdZdZdZdZdZdZdZ xZ S)ryc&t|ts td|jd|jdk7rtd|t |r|dkr tdt |t|g|j||f|_y)Nrrr3z$square LinearOperator expected, got z"non-negative integer expected as p) rArr#r$rrr&rr)r%rr{rs rr&z_PowerLinearOperator.__init__s!^,;< < 771: #CA5IJ J|q1uAB B QC!''2F rc~tj|d}t|jdD] }||} |S)NT)copyr3)r arrayranger)r%funr=resis r_powerz_PowerLinearOperator._powers7hhqt$tyy|$Ac(C% rcT|j|jdj|SNr)rrr,r<s rrz_PowerLinearOperator._matvec#!{{499Q<..22rcT|j|jdj|Sr)rrrJr<s rrIz_PowerLinearOperator._rmatvec&!{{499Q<//33rcT|j|jdj|Sr)rrr]r<s rrLz_PowerLinearOperator._rmatmat)rrcT|j|jdj|Sr)rrr;r<s rrz_PowerLinearOperator._matmat,rrc>|j\}}|j|zSr`r)r%rr{s rrMz_PowerLinearOperator._adjoint/syy1ssaxr) rrrr&rrrIrLrrMrrs@rryrys&  3443rryc*eZdZfdZdZdZxZS)MatrixLinearOperatorczt||j|j||_d|_|f|_yr`)rr&r!r$r_MatrixLinearOperator__adjr)r%rrs rr&zMatrixLinearOperator.__init__5s1 !''* D rc8|jj|Sr`)rrd)r%r8s rrzMatrixLinearOperator._matmat;svvzz!}rcf|jt|j|_|jSr`)r _AdjointMatrixOperatorrrs rrMzMatrixLinearOperator._adjoint>s& :: /7DJzzr)rrrr&rrMrrs@rr r 4s rr c(eZdZdZedZdZy)rc|jj|_|f|_|jd|jdf|_yr)r5rrrr$)r% adjoint_arrays rr&z_AdjointMatrixOperator.__init__EsB%%'"$ "((+]-@-@-CC rc4|jdjSr)rr!rs rr!z_AdjointMatrixOperator.dtypeJsyy|!!!rc2t|jdSr)r rrs rrMz_AdjointMatrixOperator._adjointNs#DIIaL11rN)rrrr&rr!rMrarrrrDs!D ""2rrc>eZdZdfd ZdZdZdZdZdZxZ S)IdentityOperatorc&t|||yr`)rr&)r%r$r!rs rr&zIdentityOperator.__init__Ss &rc|Sr`rar<s rrzIdentityOperator._matvecVrc|Sr`rar<s rrIzIdentityOperator._rmatvecYrrc|Sr`rar<s rrLzIdentityOperator._rmatmat\rrc|Sr`rar<s rrzIdentityOperator._matmat_rrc|Sr`rars rrMzIdentityOperator._adjointbs rr`rrs@rrrRs!'rrct|tr|St|tjst|tjrM|j dkDr t dtjtj|}t|St|s t|r t|St|dr~t|drrd}d}d}t|dr |j}t|dr |j}t|dr |j}t|j |j"||| St%d ) aReturn A as a LinearOperator. 'A' may be any of the following types: - ndarray - matrix - sparse array (e.g. csr_array, lil_array, etc.) - LinearOperator - An object with .shape and .matvec attributes See the LinearOperator documentation for additional information. Notes ----- If 'A' has no .dtype attribute, the data type is determined by calling :func:`LinearOperator.matvec()` - set the .dtype attribute to prevent this call upon the linear operator creation. Examples -------- >>> import numpy as np >>> from scipy.sparse.linalg import aslinearoperator >>> M = np.array([[1,2,3],[4,5,6]], dtype=np.int32) >>> aslinearoperator(M) <2x3 MatrixLinearOperator with dtype=int32> r zarray must have ndim <= 2r$r,NrJr]r!)rJr]r!ztype not understood)rArr ndarrayrBrCr# atleast_2dr+r rrrNrJr]r!r$r,rW)rrJr]r!s rr r fs 4!^$ Arzz "jBII&> 66A:89 9 MM"**Q- (#A&& !*1-#A&& 1g 71h#7GGEq)$))q)$))q'"!!''188W*1@ @12 2rr`)rrrnumpyr scipy.sparserscipy.sparse._sputilsrrrr__all__rrrrrr~rnrhryr rrr rarrr&s*X !RR / 0Z/Z/z+7N+7\!^!*33.#6^8$N$D > F >  21 2~(63r