!YHhrBdZddlZddlZddlmZddlmZmZm Z m Z ddgZ GddZ Gdd e Z Gd 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_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.]) 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 W/var/www/html/planif/env/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._matmats9yyACCHS$++ckk"Q&78HIIHs(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._rmatvecAsz :  ."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 z$expected 2-d ndarray or matrix, not z-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.matmatMs. 1!4 a A 66Q;CAFF82NO O 771:A &3DJJNO 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 rdrerrr+rCr$r,r;r#r<s rrazLinearOperator.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 rdr#rbrfs r __matmul__zLinearOperator.__matmul__s/ ;;u /0 0||E""rcdtj|r td|j|Srm)r rdr#__rmul__rfs r __rmatmul__zLinearOperator.__rmatmul__s/ ;;u /0 0}}U##rcftj|r t||S|j|Sr])r rdre_rdotr<s rrpzLinearOperator.__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 rrj)rArrkr rdrerrr+rCr$r5r,r;r#r<s rrszLinearOperator._rdots$ a ()!T2 2 [[^(q1 1A;'9!'<JJqMvv{affkaggajAovv}}QSS)+++1vv}}QSS)+++ #LQE!RSSrcPtj|r t||StSr])r rd_PowerLinearOperatorNotImplemented)r%ps r__pow__zLinearOperator.__pow__s ;;q>'a0 0! !rcFt|tr t||StSr])rAr_SumLinearOperatorrwr<s r__add__zLinearOperator.__add__s a (%dA. .! !rct|dS)Nr()rer%s r__neg__zLinearOperator.__neg__s$T2..rc&|j| Sr])r|r<s 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%rErFdts r__repr__zLinearOperator.__repr__$sNjj! :: $BC O+B#q!T^^-D-Db&IIIrc"|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. )rMr~s radjointzLinearOperator.adjoint-s}}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(). ) _transposer~s r transposezLinearOperator.transpose?s   rct|S)z6Default implementation of _adjoint; defers to rmatvec.)_AdjointLinearOperatorr~s rrMzLinearOperator._adjointIs %d++rct|S)z? Default implementation of _transpose; defers to rmatvec + conj)_TransposedLinearOperatorr~s rrzLinearOperator._transposeMs (..r)&r __module__ __qualname____doc__rC__array_ufunc__rr&r1rrr,rJrIr;rZrLr_rbrhrarnrqrprsryr|rrrrpropertyrPrr5rMr __classcell__rs@rrr7s\| DO  ,*J --^-^ $-^,\$6 T># $ ! "TH" " / J A! A,/rcNeZdZdZ dfd ZfdZdZdZfdZdZ xZ S) rz>Linear operator defined in terms of user-specified operations.ct|||d|_||_||_||_||_|jy)Nr^)rr&r"_CustomLinearOperator__matvec_impl#_CustomLinearOperator__rmatvec_impl#_CustomLinearOperator__rmatmat_impl"_CustomLinearOperator__matmat_implr1)r%r$r,rJr;r!rZrs rr&z_CustomLinearOperator.__init__UsE & #%%# rc\|j|j|St| |Sr])rrrr%r8rs rrz_CustomLinearOperator._matmatbs/    )%%a( (7?1% %rc$|j|Sr])rr<s rrz_CustomLinearOperator._matvechs!!!$$rcV|j}| td|j|S)Nzrmatvec is not defined)rrO)r%r=funcs rrIz_CustomLinearOperator._rmatvecks/"" <%&>? ?""1%%rc\|j|j|St| |Sr])rrrLrs rrLz_CustomLinearOperator._rmatmatqs0    *&&q) )7#A& &rct|jd|jdf|j|j|j|j |j S)Nr3r)r$r,rJr;rZr!)rr$rrrrr!r~s rrMz_CustomLinearOperator._adjointwsQ$DJJqM4::a=+I,0,?,?-1-?-?,0,?,?-1-?-?+/:: 7 7r)NNNN) rrrrr&rrrIrLrMrrs@rrrRs*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_dtypersJ ~% ?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|zSrrrZr<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)rkc>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 rrrZr<s rrLz_ScaledLinearOperator._rmatmatrrc^|jd|jdj|zSrrr<s rrz_ScaledLinearOperator._matmatrrcd|j\}}|jtj|zSr])rrPr r)r%rrs rrMz_ScaledLinearOperator._adjoint s&995ssRWWU^##rrrs@rreres!  5??5$rrecBeZdZfdZdZdZdZdZdZdZ xZ S)rvc&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%rrxrs 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._powers<hhqt$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)rrrZr<s rrLz_PowerLinearOperator._rmatmat&rrcT|j|jdj|Sr)rrr;r<s rrz_PowerLinearOperator._matmat)rrc>|j\}}|j|zSr]r)r%rrxs rrMz_PowerLinearOperator._adjoint,syy1ssaxr) rrrr&rrrIrLrrMrrs@rrvrvs&  3443rrvc*eZdZfdZdZdZxZS)MatrixLinearOperatorczt||j|j||_d|_|f|_yr])rr&r!r$r_MatrixLinearOperator__adjr)r%rrs rr&zMatrixLinearOperator.__init__2s1 !''* D rc8|jj|Sr])rra)r%r8s rrzMatrixLinearOperator._matmat8svvzz!}rcf|jt|j|_|jSr])r_AdjointMatrixOperatorrr~s rrMzMatrixLinearOperator._adjoint;s& :: /7DJzzr)rrrr&rrMrrs@rrr1s rrc(eZdZdZedZdZy)rc|jj|_|f|_|jd|jdf|_yr)r5rrrr$)r% adjoint_arrays rr&z_AdjointMatrixOperator.__init__BsB%%'"$ "((+]-@-@-CC rc4|jdjSr)rr!r~s rr!z_AdjointMatrixOperator.dtypeGsyy|!!!rc2t|jdSr)rrr~s rrMz_AdjointMatrixOperator._adjointKs#DIIaL11rN)rrrr&rr!rMr^rrrrAs!D ""2rrc>eZdZdfd ZdZdZdZdZdZxZ S)IdentityOperatorc&t|||yr])rr&)r%r$r!rs rr&zIdentityOperator.__init__Ps &rc|Sr]r^r<s rrzIdentityOperator._matvecSrc|Sr]r^r<s rrIzIdentityOperator._rmatvecVrrc|Sr]r^r<s rrLzIdentityOperator._rmatmatYrrc|Sr]r^r<s rrzIdentityOperator._matmat\rrc|Sr]r^r~s rrMzIdentityOperator._adjoint_s rr]rrs@rr r Os!'rr ct|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,NrJrZr!)rJrZr!ztype not understood)rArr ndarrayrBrCr# atleast_2dr+rrrrNrJrZr!r$r,rU)rrJrZr!s rr r cs 4!^$ Arzz "jBII&> 66A:89 9 MM"**Q- (#A&& !*1-#A&& 1g 71h#7GGEq)$))q)$))q'"!!''188W*1@ @12 2rr])rrnumpyr scipy.sparserscipy.sparse._sputilsrrrr__all__rrrrrr{rkrervrrr r r^rrrs*X!RR / 0X/X/v+7N+7\!^!*33.#6^8$N$D > F >  21 2~(63r