EisLSrSSKrSSKrSSKrSSKJr SSKJrJ r J r J r SS/r "SS5r "SS \ 5r"S S \ 5r"S S \ 5rSSjr"SS\ 5r"SS\ 5r"SS\ 5r"SS\ 5r"SS\ 5r"SS\5r"SS\ 5rSrg)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_spmatrixLinearOperatoraslinearoperatorc^\rSrSrSrSrSr\"\R5r U4Sjr Sr Sr SrS rS rS rS rS rSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!Sr"Sr#\$"\#5r%Sr&\$"\&5r'Sr(S r)S!r*U=r+$)"r8a Common 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.>U[La[TU] [5$[TU] U5n[ U5R [R :XaA[ U5R [R :Xa[R"S[SS9 U$)NzMLinearOperator subclass should implement at least one of _matvec and _matmat.r )category stacklevel) rsuper__new___CustomLinearOperatortype_matvec_matmatwarningswarnRuntimeWarning)clsargskwargsobj __class__s [/home/mande/repo/quber/.venv/lib/python3.13/site-packages/scipy/sparse/linalg/_interface.pyrLinearOperator.__new__sx . 7?#89 9'/#&CS !!^%;%;;S ))^-C-CC F'5!EJcUb[R"U5n[U5n[U5(d[ SU<S35eXlX lg)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__LinearOperator.__init__sG  HHUOEe u~~~eYnEF F  r cLURch[R"URS[RS9n[R "UR U55nURUlgg![a" [R"[5Ulgf=f)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_dtypeLinearOperator._init_dtypesw :: Brww7A ,::dkk!n5 &^^  ! +XXc]  +s%A77)B#"B#c [R"URVs/sH#o RUR SS55PM% sn5$s snf)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 rrLinearOperator._matmats;yyACCHCS++ckk"Q&78CHIIHs*AcDURURSS55$)aIDefault 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+r7)matmatr:r'xs rrLinearOperator._matvecs{{199R+,,r c[R"U5nURup#URU4:waURUS4:wa [S5eUR U5n[ U[R 5(a [U5nO[R"U5nURS:XaURU5nU$URS:XaURUS5nU$[S5e)aMatrix-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. r7dimension mismatchr z/invalid shape returned by user-defined matvec()) r" asanyarrayr&r%r isinstancematrixrr.ndimr:r'rBMNys rr/LinearOperator.matvecs0 MM! jj 77qd?qww1Q%/12 2 LLO a # # A 1 A 66Q; ! A  VVq[ !AANO Or c[R"U5nURup#URU4:waURUS4:wa [S5eUR U5n[ U[R 5(a [U5nO[R"U5nURS:XaURU5nU$URS:XaURUS5nU$[S5e)a Adjoint 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. r7rEr z0invalid shape returned by user-defined rmatvec()) r"rFr&r%_rmatvecrGrHrr.rIr:rJs rrmatvecLinearOperator.rmatvecs0 MM! jj 77qd?qww1Q%/12 2 MM!  a # # A 1 A 66Q; ! A  VVq[ !AAOP Pr cb[U5R[R:Xan[US5(aW[U5R[R:wa0UR UR SS55R S5$[ eURRU5$)z6Default implementation of _rmatvec; defers to adjoint._rmatmatr+r7) r_adjointrhasattrrTr:NotImplementedErrorHr/rAs rrPLinearOperator._rmatvecEs} :  ."9"9 9j))T ++~/F/FF}}QYYr1%56>>rBB% %66==# #r cD[U5(d&[U5(d[R"U5nURS:wa[ SURS35eUR SUR S:wa%[ SUR SUR 35eURU5n[U[R5(a [U5nU$![a2n[U5(d[U5(a [S5UeeS nAff=f) aMatrix-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 -drr7dimension mismatch: , zdUnable to multiply a LinearOperator with a sparse matrix. Wrap the matrix in aslinearoperator first.N) rrr"rFrIr%r&r Exception TypeErrorrGrHrr'r<Yes rr@LinearOperator.matmatQs. 1!44 a A 66Q;CAFF82NO O 771:A &3DJJ#NO O66==# #Os*Bc X-$NrAs r__call__LinearOperator.__call__s v r c$URU5$rl)dotrAs r__mul__LinearOperator.__mul__sxx{r cl[R"U5(d [S5e[USU- 5$)Nz.Can only divide a linear operator by a scalar.g?)r"isscalarr%_ScaledLinearOperatorr'others r __truediv__LinearOperator.__truediv__s.{{5!!MN N$T3u955r c[U[5(a [X5$[R"U5(a [ X5$[ U5(d&[U5(d[R"U5nURS:Xd#URS:Xa$URSS:XaURU5$URS:XaURU5$[SU<35e)a"Matrix-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. r7r )expected 1-d or 2-d array or matrix, got )rGr_ProductLinearOperatorr"rurvrrr.rIr&r/r@r%rAs rrqLinearOperator.dots a ( ()$2 2 [[^^(1 1A;;'9!'<'<JJqMvv{affkaggajAo{{1~%1{{1~% #LQE!RSSr cp[R"U5(a [S5eURU5$Nz0Scalar operands are not allowed, use '*' instead)r"rur%rrrws r __matmul__LinearOperator.__matmul__s2 ;;u  /0 0||E""r cp[R"U5(a [S5eURU5$r)r"rur%__rmul__rws r __rmatmul__LinearOperator.__rmatmul__s2 ;;u  /0 0}}U##r cp[R"U5(a [X5$URU5$rl)r"rurv_rdotrAs rrLinearOperator.__rmul__s( ;;q>>(1 1::a= r cZ[U[5(a [X5$[R"U5(a [ X5$[ U5(d&[U5(d[R"U5nURS:Xd#URS:XaBURSS:Xa/URRUR5R$URS:Xa/URRUR5R$[SU<35e)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. r7r rr|)rGrr}r"rurvrrr.rIr&r9r/r@r%rAs rrLinearOperator._rdots$ a ( ()!2 2 [[^^(1 1A;;'9!'<'<JJqMvv{affkaggajAovv}}QSS)+++1vv}}QSS)+++ #LQE!RSSr cZ[R"U5(a [X5$[$rl)r"ru_PowerLinearOperatorNotImplemented)r'ps r__pow__LinearOperator.__pow__s ;;q>>'0 0! !r cN[U[5(a [X5$[$rl)rGr_SumLinearOperatorrrAs r__add__LinearOperator.__add__s a ( (%d. .! !r c[US5$)Nr+)rvr's r__neg__LinearOperator.__neg__!s$T2..r c&URU*5$rl)rrAs r__sub__LinearOperator.__sub__$s||QBr c URupURcSnOS[UR5-nSUSUSURRSUS3 $)Nzunspecified dtypezdtype=)r&r#strr__name__)r'rKrLdts r__repr__LinearOperator.__repr__'sZjj :: $BC O+B1#Qqc4>>2236"Q??r c"UR5$)a;Hermitian 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. )rUrs radjointLinearOperator.adjoint0s}}r c"UR5$)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 transposeLinearOperator.transposeBs   r c[U5$)z6Default implementation of _adjoint; defers to rmatvec.)_AdjointLinearOperatorrs rrULinearOperator._adjointLs %d++r c[U5$)z>Default implementation of _transpose; defers to rmatvec + conj)_TransposedLinearOperatorrs rrLinearOperator._transposePs (..r r#r&),r __module__ __qualname____firstlineno____doc__rI__array_ufunc__ classmethodtypes GenericAlias__class_getitem__rr(r4rrr/rQrPr@rgrTrnrrryrqrrrrrrrrrrpropertyrXrr9rUr__static_attributes__ __classcell__rs@rrr8s\| DO$E$6$67  ,*J --^-^ $-^+Z$6 T># $ ! "TH" " / @ A! A,//r c^^\rSrSrSrS U4SjjrU4SjrSrSrU4Sjr Sr S r U=r $) riUz>Linear operator defined in terms of user-specified operations.c>[TU]XQ5 SUlX lX0lX`lX@lUR5 g)Nrm)rr(r"_CustomLinearOperator__matvec_impl#_CustomLinearOperator__rmatvec_impl#_CustomLinearOperator__rmatmat_impl"_CustomLinearOperator__matmat_implr4)r'r&r/rQr@r#rgrs rr(_CustomLinearOperator.__init__Xs; & #%%# r c^>URbURU5$[TU] U5$rl)rrrr'r<rs rr_CustomLinearOperator._matmates/    )%%a( (7?1% %r c$URU5$rl)rrAs rr_CustomLinearOperator._matvecks!!!$$r cXURnUc [S5eURU5$)Nzrmatvec is not defined)rrW)r'rBfuncs rrP_CustomLinearOperator._rmatvecns/"" <%&>? ?""1%%r c^>URbURU5$[TU] U5$rl)rrrTrs rrT_CustomLinearOperator._rmatmatts0    *&&q) )7#A& &r c [URSURS4URURURUR UR S9$)Nr7r)r&r/rQr@rgr#)rr&rrrrr#rs rrU_CustomLinearOperator._adjointzsQ$DJJqM4::a=+I,0,?,?-1-?-?,0,?,?-1-?-?+/:: 7 7r ) __matmat_impl __matvec_impl__rmatmat_impl__rmatvec_implr)NNNN) rrrrrr(rrrPrTrUrrrs@rrrUs/H;?%) & %& ' 77r rcD^\rSrSrSrU4SjrSrSrSrSr Sr U=r $) riz$Adjoint of arbitrary Linear Operatorc>URSURS4n[TU] URUS9 XlU4UlgNr7rrr&rr(r#Arr'rr&rs rr(_AdjointLinearOperator.__init__AQWWQZ( qwwe4D r c8URRU5$rl)rrPrAs rr_AdjointLinearOperator._matvecvvq!!r c8URRU5$rl)rrrAs rrP_AdjointLinearOperator._rmatvecvv~~a  r c8URRU5$rl)rrTrAs rr_AdjointLinearOperator._matmatrr c8URRU5$rl)rrrAs rrT_AdjointLinearOperator._rmatmatrr rr rrrrrr(rrPrrTrrrs@rrrs$. "!"!!r rcD^\rSrSrSrU4SjrSrSrSrSr Sr U=r $) riz*Transposition of arbitrary Linear Operatorc>URSURS4n[TU] URUS9 XlU4Ulgrrrs rr("_TransposedLinearOperator.__init__rr c[R"URR[R"U555$rl)r"conjrrPrAs rr!_TransposedLinearOperator._matvec&wwtvvrwwqz233r c[R"URR[R"U555$rl)r"rrrrAs rrP"_TransposedLinearOperator._rmatvec&wwtvv~~bggaj122r c[R"URR[R"U555$rl)r"rrrTrAs rr!_TransposedLinearOperator._matmatrr c[R"URR[R"U555$rl)r"rrrrAs rrT"_TransposedLinearOperator._rmatmatrr rrrs@rrrs$4 43433r rcUc/nUH6nUcM[US5(dMURUR5 M8 [R"U6$)Nr#)rVappendr#r" result_type) operatorsdtypesrs r _get_dtypersH ~ ?wsG44 MM#)) $ >>6 ""r cF^\rSrSrU4SjrSrSrSrSrSr Sr U=r $) ric >[U[5(a[U[5(d [S5eURUR:wa[SUSUS35eX4Ul[ TU][X/5UR5 g)N)both operands have to be a LinearOperatorz cannot add  and : shape mismatch)rGrr%r&rrr(rr'rBrs rr(_SumLinearOperator.__init__sw!^,,q.11HI I 77agg {1#U1#5EFG GF  QF+QWW5r c|URSRU5URSRU5-$Nrr7rr/rAs rr_SumLinearOperator._matvec3yy|""1% ! (;(;A(>>>r c|URSRU5URSRU5-$r rrQrAs rrP_SumLinearOperator._rmatvec3yy|##A&1)=)=a)@@@r c|URSRU5URSRU5-$r rrgrAs rrT_SumLinearOperator._rmatmatrr c|URSRU5URSRU5-$r rr@rAs rr_SumLinearOperator._matmatr r cPURupURUR-$rlrrXr'rrs rrU_SumLinearOperator._adjointyyssQSSyr r rrrrr(rrPrTrrUrrrs@rrrs(6?AA?r rcF^\rSrSrU4SjrSrSrSrSrSr Sr U=r $) r}icP>[U[5(a[U[5(d [S5eURSURS:wa[SUSUS35e[TU][ X/5URSURS45 X4Ulg)Nrr7rzcannot multiply rr)rGrr%r&rr(rrrs rr(_ProductLinearOperator.__init__s!^,,q.11HI I 771: #/s%s:JKL L QF+67ggaj!''!*5M OF r cvURSRURSRU55$r r rAs rr_ProductLinearOperator._matvec.yy|""499Q<#6#6q#9::r cvURSRURSRU55$Nr7rrrAs rrP_ProductLinearOperator._rmatvec.yy|##DIIaL$8$8$;<[U[5(d [S5e[R"U5(d [S5e[U[ 5(aUR upX#-n[U/[U5/5n[TU])XAR5 X4Ulg)NLinearOperator expected as Azscalar expected as alpha) rGrr%r"rurvrrrrr(r&)r'ralphaalpha_originalr#rs rr(_ScaledLinearOperator.__init__s!^,,;< <{{5!!78 8 a. / / ! A*EA3e . (J r c^URSURSRU5-$r%r rAs rr_ScaledLinearOperator._matvec(yy|diil11!444r c[R"URS5URSRU5-$r%)r"rrrQrAs rrP_ScaledLinearOperator._rmatvec1wwtyy|$tyy|';';A'>>>r c[R"URS5URSRU5-$r%)r"rrrgrAs rrT_ScaledLinearOperator._rmatmatr9r c^URSURSRU5-$r%rrAs rr_ScaledLinearOperator._matmat r6r cdURupUR[R"U5-$rl)rrXr"r)r'rr1s rrU_ScaledLinearOperator._adjoint s$99ssRWWU^##r rrrs@rrvrvs&  5??5$$r rvcL^\rSrSrU4SjrSrSrSrSrSr Sr S r U=r $) ric>>[U[5(d [S5eURSURS:wa[SU<35e[ U5(aUS:a [S5e[ TU][U/5UR5 X4Ulg)Nr0rr7z$square LinearOperator expected, got z"non-negative integer expected as p) rGrr%r&rrr(rr)r'rrrs rr(_PowerLinearOperator.__init__s!^,,;< < 771: #CA5IJ J||q1uAB B QC!''2F r c~[R"USS9n[URS5H nU"U5nM U$)NT)copyr7)r"arrayranger)r'funrBresis r_power_PowerLinearOperator._powers7hhqt$tyy|$Ac(C% r cTURURSRU5$Nr)rJrr/rAs rr_PowerLinearOperator._matvec#!{{499Q<..22r cTURURSRU5$rM)rJrrQrAs rrP_PowerLinearOperator._rmatvec&!{{499Q<//33r cTURURSRU5$rM)rJrrgrAs rrT_PowerLinearOperator._rmatmat)rRr cTURURSRU5$rM)rJrr@rAs rr_PowerLinearOperator._matmat,rOr c<URupURU-$rlr)r'rrs rrU_PowerLinearOperator._adjoint/syyssaxr r) rrrrr(rJrrPrTrrUrrrs@rrrs+  3443r rc4^\rSrSrU4SjrSrSrSrU=r$)MatrixLinearOperatori4cx>[TU]URUR5 XlSUlU4Ulgrl)rr(r#r&r_MatrixLinearOperator__adjr)r'rrs rr(MatrixLinearOperator.__init__5s/ !''* D r c8URRU5$rl)rrq)r'r<s rrMatrixLinearOperator._matmat;svvzz!}r chURc[UR5UlUR$rl)r\_AdjointMatrixOperatorrrs rrUMatrixLinearOperator._adjoint>s& :: /7DJzzr )r__adjr) rrrrr(rrUrrrs@rrZrZ4s r rZc0\rSrSrSr\S5rSrSrg)raiDcURR5UlU4UlURSURS4Ulgr%)r9rrrr&)r' adjoint_arrays rr(_AdjointMatrixOperator.__init__EsB%%'"$ "((+]-@-@-CC r c4URSR$rM)rr#rs rr#_AdjointMatrixOperator.dtypeJsyy|!!!r c2[URS5$rM)rZrrs rrU_AdjointMatrixOperator._adjointNs#DIIaL11r )rrr&N) rrrrr(rr#rUrrmr rraraDs!D ""2r racJ^\rSrSrS U4SjjrSrSrSrSrSr Sr U=r $) IdentityOperatoriRc$>[TU]X!5 grl)rr()r'r&r#rs rr(IdentityOperator.__init__Ss &r cU$rlrmrAs rrIdentityOperator._matvecVr cU$rlrmrAs rrPIdentityOperator._rmatvecYrrr cU$rlrmrAs rrTIdentityOperator._rmatmat\rrr cU$rlrmrAs rrIdentityOperator._matmat_rrr cU$rlrmrs rrUIdentityOperator._adjointbs r rmrlrrs@rrmrmRs&'r rmc[U[5(aU$[U[R5(d[U[R5(aPUR S:a [ S5e[R"[R"U55n[U5$[U5(d[U5(a [U5$[US5(a[US5(a}SnSnSn[US5(a URn[US5(a URn[US5(a URn[UR UR"UX#S 9$[%S 5e) 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/NrQrgr#)rQrgr#ztype not understood)rGrr"ndarrayrHrIr% atleast_2dr.rZrrrVrQrgr#r&r/r`)rrQrgr#s rr r fs(4!^$$ Arzz " "jBII&>&> 66A:89 9 MM"**Q- (#A&& !*1--#A&& 1g  71h#7#7GGEq)$$))q)$$))q'""!!''188W*1@ @12 2r rl)rrrnumpyr" scipy.sparserscipy.sparse._sputilsrrrr__all__rrrrrrr}rvrrZrarmr rmr rrs*X !RR / 0Z/Z/z+7N+7\!^!*33.#6^8$N$D > F >  21 2~(63r