_MhrdZddlZddlZddlmZddlmZmZm Z m Z ddgZ GddZ Gdd e Z Gd d e ZGd d e ZddZGdde ZGdde ZGdde ZGdde ZGdde ZGddeZGdde ZdZdS)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_spmatrixLinearOperatoraslinearoperatorceZdZdZdZdZfdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZeeZ dZ!ee!Z"dZ#dZ$xZ%S) ralCommon 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.]) Nch|tur&ttSt|}t |jtjkr>t |jtjkrtjdtd|S)NzMLinearOperator subclass should implement at least one of _matvec and _matmat.r )category stacklevel) rsuper__new___CustomLinearOperatortype_matvec_matmatwarningswarnRuntimeWarning)clsargskwargsobj __class__s ^/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/sparse/linalg/_interface.pyrzLinearOperator.__new__s . 77??#899 9''//#&&CS !^%;;;S )^-CCC F'5!EEEEJc|tj|}t|}t|st d|d||_||_dS)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__s]  HUOOEe u~~ GEeEEEFF F  rc4|jtj|jdtj} tj||}|j|_dS#t$r"tjt|_YdSwxYwdS)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_dtypes : Brw777A ,:dkk!nn55 &^ ! + + +Xc]]  +  s'A))(BBcNtjfd|jDS)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). cbg|]+}|dd,Sr()r,reshape.0colr%s r z*LinearOperator._matmat..s3HHHS$++ckk"Q&7&788HHHr)r hstackTr%Xs` rrzLinearOperator._matmats,yHHHHACHHHIIIrcT||ddS)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(r5)matmatr6r%xs rrzLinearOperator._matvecs${{199R++,,,rctj|}|j\}}|j|fkr|j|dfkrtd||}t |tjrt|}ntj|}|j dkr| |}n1|j dkr| |d}ntd|S)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. r5dimension mismatchr z/invalid shape returned by user-defined matvec()) r asanyarrayr$r#r isinstancematrixrr+ndimr6r%rBMNys rr,zLinearOperator.matvecs0 M!  j! 7qd??qw1Q%//122 2 LLOO a # #  AA 1 A 6Q;; ! AA Vq[[ !AAANOO Orctj|}|j\}}|j|fkr|j|dfkrtd||}t |tjrt|}ntj|}|j dkr| |}n1|j dkr| |d}ntd|S)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. r5rDr z0invalid shape returned by user-defined rmatvec()) r rEr$r#_rmatvecrFrGrr+rHr6rIs rrmatveczLinearOperator.rmatvecs0 M!  j! 7qd??qw1Q%//122 2 MM!   a # #  AA 1 A 6Q;; ! AA Vq[[ !AAAOPP Prcdt|jtjkrut|dr^t|jtjkr<||dddSt |j|S)z6Default implementation of _rmatvec; defers to adjoint._rmatmatr(r5) r_adjointrhasattrrQr6NotImplementedErrorHr,rAs rrNzLinearOperator._rmatvecAs :: ."9 9 9j)) CT +~/FFF}}QYYr1%5%566>>rBBB% %6==## #rc(t|s#t|stj|}|jdkrt d|jd|jd|jdkrt d|jd|j ||}nA#t$r4}t|st|rtd|d }~wwxYwt|tj rt|}|S) 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 z$expected 2-d ndarray or matrix, not z-drr5dimension mismatch: , zdUnable to multiply a LinearOperator with a sparse matrix. Wrap the matrix in aslinearoperator first.N) rrr rErHr#r$r Exception TypeErrorrFrGrr%r>Yes rr@zLinearOperator.matmatMs-.  !1!44 ! a  A 6Q;;NAFNNNOO O 71:A & &KDJKK!'KKLL L  QAA   {{ 033 B    a # #  AsB(( C&2/C!!C&c&t|s#t|stj|}|jdkrt d|jz|jd|jdkrt d|jd|j ||}nA#t$r4}t|st|rtd|d}~wwxYwt|tj rt|}|S)a;Adjoint matrix-matrix 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, or 2-d array. The default implementation defers to the adjoint. Parameters ---------- X : {matrix, ndarray} A matrix or 2D array. Returns ------- Y : {matrix, ndarray} A matrix or 2D array depending on the type of the input. Notes ----- This rmatmat wraps the user-specified rmatmat routine. r z(expected 2-d ndarray or matrix, not %d-drrWrXzfUnable to multiply a LinearOperator with a sparse matrix. Wrap the matrix in aslinearoperator() first.N) rrr rErHr#r$rQrYrZrFrGrr[s rrmatmatzLinearOperator.rmatmat|s4,  !1!44 ! a  A 6Q;;G v&'' ' 71:A & &KDJKK!'KKLL L  a  AA   {{ 033 D    a # #  AsB'' C%1/C  C%ctjtjkr%tjfd|jDSj|S)z@Default implementation of _rmatmat defers to rmatvec or adjoint.cbg|]+}|dd,Sr4)rOr6r7s rr:z+LinearOperator._rmatmat..s3NNN3dll3;;r1+=+=>>NNNr)rrRrr r;r<rUr@r=s` rrQzLinearOperator._rmatmatsU :: ."9 9 99NNNN!#NNNOO O6==## #rc ||zSNrAs r__call__zLinearOperator.__call__s Av rc,||Src)dotrAs r__mul__zLinearOperator.__mul__sxx{{rcntj|stdt|d|z S)Nz.Can only divide a linear operator by a scalar.g?)r isscalarr#_ScaledLinearOperatorr%others r __truediv__zLinearOperator.__truediv__s8{5!! OMNN N$T3u9555rct|trt||Stj|rt ||St |s#t|stj|}|j dks|j dkr&|j ddkr| |S|j dkr| |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. r5r )expected 1-d or 2-d array or matrix, got )rFr_ProductLinearOperatorr rjrkrrr+rHr$r,r@r#rAs rrgzLinearOperator.dots a ( ( T)$22 2 [^^ T(q11 1A;; "'9!'<'< "JqMMv{{afkkagajAoo{{1~~%1{{1~~% !RQ!R!RSSSrcrtj|rtd||SNz0Scalar operands are not allowed, use '*' instead)r rjr#rhrls r __matmul__zLinearOperator.__matmul__s= ;u   0/00 0||E"""rcrtj|rtd||Srs)r rjr#__rmul__rls r __rmatmul__zLinearOperator.__rmatmul__s= ;u   0/00 0}}U###rcttj|rt||S||Src)r rjrk_rdotrAs rrvzLinearOperator.__rmul__s2 ;q>> !(q11 1::a== rct|trt||Stj|rt ||St |s#t|stj|}|j dks|j dkr5|j ddkr$|j |j j S|j dkr$|j |j j Std|)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. r5r rrp)rFrrqr rjrkrrr+rHr$r<r,r@r#rAs rryzLinearOperator._rdots$ a ( ( T)!T22 2 [^^ T(q11 1A;; "'9!'<'< "JqMMv{{afkkagajAoov}}QS))++1v}}QS))++ !RQ!R!RSSSrcXtj|rt||StSrc)r rj_PowerLinearOperatorNotImplemented)r%ps r__pow__zLinearOperator.__pow__s( ;q>> "'a00 0! !rcZt|trt||StSrc)rFr_SumLinearOperatorr}rAs r__add__zLinearOperator.__add__s* a ( ( "%dA.. .! !rc"t|dS)Nr()rkr%s r__neg__zLinearOperator.__neg__s$T2...rc.|| Src)rrAs r__sub__zLinearOperator.__sub__!s||QBrc~|j\}}|jd}ndt|jz}d|||jj|fzS)Nzunspecified dtypezdtype=z<%dx%d %s with %s>)r$r!strr__name__)r%rJrKdts r__repr__zLinearOperator.__repr__$sGj! : $BBC OO+B#q!T^-Db&IIIrc*|S)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. )rRrs radjointzLinearOperator.adjoint-s}}rc*|S)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.transpose?s    rc t|S)z6Default implementation of _adjoint; defers to rmatvec.)_AdjointLinearOperatorrs rrRzLinearOperator._adjointIs%d+++rc t|S)z? Default implementation of _transpose; defers to rmatvec + conj)_TransposedLinearOperatorrs rrzLinearOperator._transposeMs(...r)&r __module__ __qualname____doc__rH__array_ufunc__rr&r1rrr,rOrNr@r_rQrerhrnrgrtrwrvryrrrrrrpropertyrUrr<rRr __classcell__rs@rrr7s\\| DO      ,,,*JJJ - - ----^---^ $ $ $---^,,,\$$$666 TTT>### $$$ !!! "T"T"TH""" """ ///   JJJ A!!! A,,,///////rcNeZdZdZ d fd ZfdZdZdZfdZdZ xZ S) rz>Linear operator defined in terms of user-specified operations.Nct||d|_||_||_||_||_|dS)Nrd)rr&r"_CustomLinearOperator__matvec_impl#_CustomLinearOperator__rmatvec_impl#_CustomLinearOperator__rmatmat_impl"_CustomLinearOperator__matmat_implr1)r%r$r,rOr@r!r_rs rr&z_CustomLinearOperator.__init__Us\ &&& #%%# rc~|j||St|Src)rrrr%r>rs rrz_CustomLinearOperator._matmatbs6   )%%a(( (77??1%% %rc,||Src)rrAs rrz_CustomLinearOperator._matvechs!!!$$$rc\|j}|td||S)Nzrmatvec is not defined)rrT)r%rBfuncs rrNz_CustomLinearOperator._rmatvecks2" <%&>?? ?""1%%%rc~|j||St|Src)rrrQrs rrQz_CustomLinearOperator._rmatmatqs8   *&&q)) )77##A&& &rct|jd|jdf|j|j|j|j|jS)Nr5r)r$r,rOr@r_r!)rr$rrrrr!rs rrRz_CustomLinearOperator._adjointwsI$DJqM4:a=+I,0,?-1-?,0,?-1-?+/: 777 7r)NNNN) rrrrr&rrrNrQrRrrs@rrrRsHH;?%)      &&&&& %%%&&& ''''' 7777777rrc:eZdZdZfdZdZdZdZdZxZ S)rz$Adjoint of arbitrary Linear Operatorc|jd|jdf}t|j|||_|f|_dSNr5r)r!r$r$rr&r!Arr%rr$rs rr&z_AdjointLinearOperator.__init__LQWQZ( qwe444D rc6|j|Src)rrNrAs rrz_AdjointLinearOperator._matvecvq!!!rc6|j|Src)rrrAs rrNz_AdjointLinearOperator._rmatvecv~~a   rc6|j|Src)rrQrAs rrz_AdjointLinearOperator._matmatrrc6|j|Src)rrrAs rrQz_AdjointLinearOperator._rmatmatrr rrrrr&rrNrrQrrs@rrrsz.. """!!!"""!!!!!!!rrc:eZdZdZfdZdZdZdZdZxZ S)rz*Transposition of arbitrary Linear Operatorc|jd|jdf}t|j|||_|f|_dSrrrs rr&z"_TransposedLinearOperator.__init__rrc~tj|jtj|Src)r conjrrNrAs rrz!_TransposedLinearOperator._matvec(wtvrwqzz22333rc~tj|jtj|Src)r rrrrAs rrNz"_TransposedLinearOperator._rmatvec(wtv~~bgajj11222rc~tj|jtj|Src)r rrrQrAs rrz!_TransposedLinearOperator._matmatrrc~tj|jtj|Src)r rrrrAs rrQz"_TransposedLinearOperator._rmatmatrrrrs@rrrsz44 4443334443333333rrc|g}|D].}|*t|dr||j/tj|S)Nr!)rSappendr!r result_type) operatorsdtypesrs r _get_dtypersP ~%% ?wsG44? MM#) $ $ $ >6 ""rc<eZdZfdZdZdZdZdZdZxZ S)rcDt|trt|tstd|j|jkrtd|d|d||f|_t t||g|jdS)N)both operands have to be a LinearOperatorz cannot add  and : shape mismatch)rFrr#r$rrr&rr%rBrs rr&z_SumLinearOperator.__init__s!^,, Jq.11 JHII I 7ag  F1FF1FFFGG GF  QF++QW55555rc|jd||jd|zSNrr5rr,rAs rrz_SumLinearOperator._matvec5y|""1%% ! (;(;A(>(>>>rc|jd||jd|zSrrrOrAs rrNz_SumLinearOperator._rmatvec5y|##A&&1)=)=a)@)@@@rc|jd||jd|zSrrr_rAs rrQz_SumLinearOperator._rmatmatrrc|jd||jd|zSrrr@rAs rrz_SumLinearOperator._matmatrrc4|j\}}|j|jzSrcrrUr%rrs rrRz_SumLinearOperator._adjointy1sQSyr rrrr&rrNrQrrRrrs@rrrs66666???AAAAAA???rrc<eZdZfdZdZdZdZdZdZxZ S)rqct|trt|tstd|jd|jdkrtd|d|dt t ||g|jd|jdf||f|_dS)Nrr5rzcannot multiply rr)rFrr#r$rr&rrrs rr&z_ProductLinearOperator.__init__s!^,, Jq.11 JHII I 71: # #KKKKKKLL L QF++67gaj!'!*5M O O OF rc~|jd|jd|SrrrAs rrz_ProductLinearOperator._matvec0y|""49Q<#6#6q#9#9:::rc~|jd|jd|SNr5rrrAs rrNz_ProductLinearOperator._rmatvec0y|##DIaL$8$8$;$;<<'>>>rctj|jd|jd|zSr)r rrr_rAs rrQz_ScaledLinearOperator._rmatmatrrc^|jd|jd|zSrrrAs rrz_ScaledLinearOperator._matmatrrcN|j\}}|jtj|zSrc)rrUr r)r%rrs rrRz_ScaledLinearOperator._adjoint s"95sRWU^^##rrrs@rrkrks      555??????555$$$$$$$rrkcBeZdZfdZdZdZdZdZdZdZ xZ S)r|cpt|tstd|jd|jdkrtd|t |r|dkrtdt t|g|j||f|_dS)Nrrr5z$square LinearOperator expected, got z"non-negative integer expected as p) rFrr#r$rrr&rr)r%rr~rs rr&z_PowerLinearOperator.__init__s!^,, =;<< < 71: # #IAIIJJ J|| Cq1uuABB B QC!'222F rctj|d}t|jdD] }||}|S)NT)copyr5)r arrayranger)r%funrBresis r_powerz_PowerLinearOperator._powersGhqt$$$ty|$$  A#c((CC rcN||jdj|SNr)rrr,rAs rrz_PowerLinearOperator._matvec {{49Q<.222rcN||jdj|Sr)rrrOrAs rrNz_PowerLinearOperator._rmatvec#{{49Q</333rcN||jdj|Sr)rrr_rAs rrQz_PowerLinearOperator._rmatmat&rrcN||jdj|Sr)rrr@rAs rrz_PowerLinearOperator._matmat)rrc*|j\}}|j|zSrcr)r%rr~s rrRz_PowerLinearOperator._adjoint,sy1saxr) rrrr&rrrNrQrrRrrs@rr|r|s      333444444333rr|c*eZdZfdZdZdZxZS)MatrixLinearOperatorct|j|j||_d|_|f|_dSrc)rr&r!r$r_MatrixLinearOperator__adjr)r%rrs rr&zMatrixLinearOperator.__init__2s< !'*** D rc6|j|Src)rrgr=s rrzMatrixLinearOperator._matmat8svzz!}}rcP|jt|j|_|jSrc)r _AdjointMatrixOperatorrrs rrRzMatrixLinearOperator._adjoint;s# : /77DJzr)rrrr&rrRrrs@rrr1sV rrc0eZdZdZedZdZdS)r c|j|_|f|_|jd|jdf|_dSr)r<rrrr$)r% adjoint_arrays rr&z_AdjointMatrixOperator.__init__BsA%%''"$ "(+]-@-CC rc&|jdjSr)rr!rs rr!z_AdjointMatrixOperator.dtypeGsy|!!rc6t|jdSr)rrrs rrRz_AdjointMatrixOperator._adjointKs#DIaL111rN)rrrr&rr!rRrdrrr r AsPDDD ""X"22222rr c>eZdZdfd ZdZdZdZdZdZxZ S) IdentityOperatorNcLt||dSrc)rr&)r%r$r!rs rr&zIdentityOperator.__init__Ps# &&&&&rc|SrcrdrAs rrzIdentityOperator._matvecSrc|SrcrdrAs rrNzIdentityOperator._rmatvecVrrc|SrcrdrAs rrQzIdentityOperator._rmatmatYrrc|SrcrdrAs rrzIdentityOperator._matmat\rrc|Srcrdrs rrRzIdentityOperator._adjoint_s rrcrrs@rrrOs''''''rrct|tr|St|tjst|tjrO|jdkrt dtjtj|}t|St|st|rt|St|dryt|drid}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,NrOr_r!)rOr_r!ztype not understood)rFrr ndarrayrGrHr# atleast_2dr+rrrrSrOr_r!r$r,rZ)rrOr_r!s rr r csg4!^$$3 Arz " "3jBI&>&>3 6A::899 9 M"*Q-- ( (#A&&& !3*1--3#A&&& 1g   371h#7#7 3GGEq)$$ $)q)$$ $)q'"" !!'18W*1@@@ @122 2rrc)rrnumpyr scipy.sparserscipy.sparse._sputilsrrrr__all__rrrrrrrqrkr|rr rr rdrrr"sn**X!!!!!!RRRRRRRRRRRR / 0X/X/X/X/X/X/X/X/v+7+7+7+7+7N+7+7+7\!!!!!^!!!*33333333.####6^8$$$$$N$$$D     >   F     >    2 2 2 2 21 2 2 2~(6363636363r