:jdZddlZddlZddlZddlZddlmZddlm Z ddl m Z m Z mZmZmZmZmZmZmZmZddlmZddlmZmZmZmZdd gZeGd dZGd d eZGd deZ GddeZ!d!dZ"GddeZ#GddeZ$GddeZ%GddeZ&GddeZ'Gdde'Z(GddeZ)ed Z*y)"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)sparse)array_api_extra) SCIPY_ARRAY_API_asarrayarray_namespaceis_array_api_objis_pydata_sparse_array np_compatxp_capabilitiesxp_copy xp_isscalarxp_result_type)issparse)asmatrixis_pydata_spmatrix isintlikeisshapeLinearOperatoraslinearoperatorcReZdZUdZdZeejZee d<e e d<fdZ d)dZ dZ dZd Zd Zd Zd*d efd ZdZdZdZd*d efdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%d Z&d!Z'd"Z(d#Z)e*d$Z+d%Z,e*d&Z-d'Z.d(Z/xZ0S)+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, optionally with additional batch dimensions at the front) 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. The defined operator may have additional "batch" dimensions prepended to the core shape, to represent a batch of 2-D operators; see :ref:`linalg_batch` for details. Parameters ---------- shape : tuple Matrix dimensions ``(..., M, N)``, where ``...`` represents any additional batch dimensions. matvec : callable f(v) Applies ``A`` to ``v``, where ``v`` is a dense vector with shape ``(..., N)``. rmatvec : callable f(v) Applies ``A^H`` to ``v``, where ``A^H`` is the conjugate transpose of ``A``, and ``v`` is a dense vector of shape ``(..., M)``. matmat : callable f(V) Returns ``A @ V``, where ``V`` is a dense matrix with dimensions ``(..., N, K)``. rmatmat : callable f(V) Returns ``A^H @ V``, where ``A^H`` is the conjugate transpose of ``A``, and where ``V`` is a dense matrix with dimensions ``(..., M, K)``. dtype : dtype Data type of the matrix or matrices. xp : array_namespace, optional A namespace compatible with the array API standard for use in array operations. Default: ``numpy``. Attributes ---------- args : tuple For linear operators describing products etc. of other linear operators, the operands of the binary operation. ndim : int Number of dimensions (greater than 2 in the case of batch dimensions). T : LinearOperator Transpose. H : LinearOperator Hermitian adjoint. Methods ------- matvec matmat adjoint transpose rmatvec rmatmat dot rdot __mul__ __matmul__ __call__ __add__ __truediv__ __rmul__ __rmatmul__ See Also -------- aslinearoperator : Construct a `LinearOperator`. Notes ----- The user-defined `matvec` function must properly handle the case where ``v`` has shape ``(..., N)``. 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. 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 raised to integral powers, 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.]) N__class_getitem__ndimc,|turt| tSt| |}t |j tj k(rBt |j tj k(rtjdtd|S)NzMLinearOperator subclass should implement at least one of _matvec and _matmat.)category stacklevel) rsuper__new___CustomLinearOperatortype_matvec_matmatwarningswarnRuntimeWarning)clsargskwargsobj __class__s s/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/scipy/sparse/linalg/_interface.pyrzLinearOperator.__new__sy . 7?#89 9'/#&CS !!^%;%;;I%%)?)?? <+ Jc&|tn|}||jd|j}t|}t |dkrt d|dt |dst d|||_||_t ||_||_ y) zInitialize this LinearOperator. To be called by subclasses. ``dtype`` may be None; ``shape`` should be convertible to a length >=2 tuple. Nrdtyperzinvalid shape z (must be at least 2-d)F)check_nd) r emptyr/tuplelen ValueErrorrshaper_xp)selfr/r5xps r+__init__zLinearOperator.__init__s *Y"  HHQeH,22Ee  u:>~eY6MNO Ouu-~eY78 8  J r,ch|jj}|djd|d<|S)Nr6r)__dict__copyr1r7states r+ __getstate__zLinearOperator.__getstate__s1 ""$U|))!,e  r,cxt|jd|_|jj |y)Nr6)rpopr6r;updater=s r+ __setstate__zLinearOperator.__setstate__s)"599U#34 U#r,cZ|ji|j}|j|jd|j} |j |j |}|j|_yy#tttf$rtj|d|_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. Nr.integral)r8kind) r/r6zerosr5int8asarraymatvec OverflowError TypeError RuntimeErrorxpx default_dtype)r7r8vmatvec_vs r+ _init_dtypezLinearOperator._init_dtypes :: BBrww7A ,::dkk!n5&^^   "9l; G ..":F  Gs A770B*)B*c |j}|jt|jdDcgc]}|j |ddd|fc}dScc}w)aDefault matrix-matrix multiplication handler. If ``self`` is a linear operator of shape ``(..., M, N)``, then this method will be called on a shape ``(..., N, K)`` array, and should return a shape ``(..., M, K)`` array. Falls back to `_matvec`, so defining that will define matrix multiplication too (though in a very suboptimal way). rE.Naxis)r6stackranger5r!r7Xr8is r+r"zLinearOperator._matmatsXXX xx16qwwr{1C DAT\\!CAI, ' D2  Ds Ac`|j}|j|d|jfdS)alDefault matrix-vector multiplication handler. If ``self`` is a linear operator of shape ``(..., M, N)``, then this method will be called on a shape ``(..., N)`` array, and should return a shape ``(..., M)`` array. Falls back to `_matmat`, so defining that will define matrix-vector multiplication as well. ..r)r6r"newaxisr7xr8s r+r!zLinearOperator._matvec*s.XX||Ac2::o./77r,adjointc|j}t|d|}|j^}}}|r||fn||f\}}t|tj rR|r|j |n|j|} |j|dfk(r| j|d} t| Sd} d} |j|dfk(x} rj|rdnd} |rdnd }d | d |d |d }tj|ttjjt f|j||f}n2|j"dk\r#|jd|k(x} r|jdd} | s"| s d|d|d|j}t%||r|j |n|j|} t'j(|| }| r|j| g||} | S| r|j| g||d} | S)NTsubokr8Fz `rmatvec`z`matvec`z `rmatmat`z`matmat`zCalling z on 'column vectors' of shape `(za, 1)` was deprecated in SciPy 1.18.0 and will no longer be possible in SciPy 1.20.0. Please call z! instead for identical behaviour.)skip_file_prefixesrEz6Dimension mismatch: `x` must have a shape ending in `(z,)`, or shape `(z, 1)`. Given shape: )r6rr5 isinstancenpmatrix_rmatvecr!reshaperr#r$ FutureWarningospathdirname__file__rr4rObroadcast_shapes)r7r`rar8self_broadcast_dimsMN inner_dim outer_dimyx_broadcast_dims row_vector column_vector func_namematmat_func_namemsgbroadcasted_dimss r+_shared_matveczLinearOperator._shared_matvec8s XX Qdr *%)ZZ" a)01vq!f 9 a #$+ a aAww9a.(IIi+A; ,. GG 1~5 5= 5'. JI.5{: 9+&K /00QS  MM]8Q7S  1yl+A VVq[AGGBK9,DDjD wws| mK/ {; !y*  S/ ! 'DMM! T\\!_//0CEUV  1< 0<)<=A 1? 0?)?Q?@Ar,c$|j|S)aMatrix-vector multiplication. Applies ``A`` to `x`, where ``A`` is an ``M`` x ``N`` linear operator (or batch of linear operators) and `x` is a row vector (or batch of such vectors). Parameters ---------- x : {matrix, ndarray} An array with shape ``(..., N)`` representing a row vector (or batch of row vectors). .. versionadded:: 1.18.0 A ``FutureWarning`` is emitted for column vector input of shape ``(N, 1)``, for which an array with shape ``(M, 1)`` is returned. `matmat` can be called instead for identical behaviour on such input. Returns ------- y : {matrix, ndarray} An array with shape ``(..., M)``. Notes ----- This method wraps the user-specified ``matvec`` routine or overridden ``_matvec`` method to ensure that `y` has the correct shape and type. rr7r`s r+rKzLinearOperator.matvecks8""1%%r,c(|j|dS)a,Adjoint matrix-vector multiplication. Applies ``A^H`` to `x`, where ``A`` is an ``M`` x ``N`` linear operator (or batch of linear operators) and `x` is a row vector (or batch of such vectors). Parameters ---------- x : {matrix, ndarray} An array with shape ``(..., M)`` representing a row vector (or batch of row vectors), or an array with shape ``(M, 1)`` representing a column vector. .. versionadded:: 1.18.0 A ``FutureWarning`` is now emitted for column vector input of shape ``(M, 1)``, for which an array with shape ``(N, 1)`` is returned. `rmatmat` can be called instead for identical behaviour on such input. Returns ------- y : {matrix, ndarray} An array with shape ``(..., N)``. Notes ----- This method wraps the user-specified ``rmatvec`` routine or overridden ``_rmatvec`` method to ensure that `y` has the correct shape and type. Trarrs r+rmatveczLinearOperator.rmatvecs:""1d"33r,cRt|jtjk(rgt|drUt|jtjk7r/|j }|j |d|j fdSt|jj|S)zPDefault implementation of `_rmatvec`. Defers to `_rmatmat` or `adjoint`._rmatmat.r]) r _adjointrhasattrrr6r^NotImplementedErrorHr!r_s r+rkzLinearOperator._rmatvecs :  ."9"9 9j)J''>+B+BBXX}}QsBJJ%78@@% %66>>!$ $r,cXt|s#t|st|d|j}|jdkrt d|jd|j d|r|j dn|j dk7r%t d|j d |j  |r|j|n|j|}t|tjr t|}|S#t$r(}t|s t|r td |d}~wwxYw) NTrcrz-Expected at least 2-d ndarray or matrix, not z-drEzDimension mismatch: z, zMultipliying LinearOperator with a sparse matrix failed. Try wrapping the matrix with `aslinearoperator` first, or ensuring the operator's `matmat` function supports sparse input.)rrrr6rr4r5rr" ExceptionrMrhrirjr)r7rZraYes r+_shared_matmatzLinearOperator._shared_matmats 1!4$4884A 66A:LQVVHTVWX X 772;W4::b>$**R. I3DJJ>!$ $Js Bc ||zS)zIApply this linear operator. Equivalent to `__matmul__`. rfrs r+__call__zLinearOperator.__call__s axr,c$|j|S)zRMultiplication. Used by the ``*`` operator. Equivalent to `dot`. )dotrs r+__mul__zLinearOperator.__mul__s xx{r,cdt|s tdt|d|z |jS)zKScalar Division. Returns a lazily scaled linear operator. z.Can only divide a linear operator by a scalar.g?r8)r r4_ScaledLinearOperatorr6r7others r+ __truediv__zLinearOperator.__truediv__$s/ 5!MN N$T3;488DDr,ct|dd}|'t||jjdd}||jk7rd|jd|}t |y)Nr6rT) sparse_okz2Mismatched array namespaces.Namespace for self is z, namespace for x is )getattrrr6r1rM)r7r`xp_xr~s r+_check_matching_namespacez(LinearOperator._check_matching_namespace.smq%& <"1dhhnnQ&74HD 488 ))- 2GvO C. r,c6|j|t|trt|||jSt |rt |||jSt|s&t|s|jj|}|jd}|j|fk(}|jdk\xr|jd|k(}|s"|s d|d|d|j}t||r|j|S|r|j|Sy) aMulti-purpose multiplication method. Parameters ---------- x : array_like or `LinearOperator` or scalar Array-like input will be interpreted as a 1-D row vector or 2-D matrix (or batch of matrices) depending on its shape. See the Returns section for details. Returns ------- Ax : array or `LinearOperator` - For `LinearOperator` input, operator composition is performed. - For scalar input, a lazily scaled operator is returned. - Otherwise, the input is expected to take the form of a dense 1-D vector or 2-D matrix (or batch of matrices), interpreted as follows (where ``self`` is an ``M`` by ``N`` linear operator): - If `x` has shape ``(N,)`` it is interpreted as a row vector and `matvec` is called. - If `x` has shape ``(..., N, K)`` for some integer ``K``, it is interpreted as a matrix (or batch of matrices if there are batch dimensions) and `matmat` is called. See Also -------- __mul__ : Equivalent method used by the ``*`` operator. __matmul__ : Method used by the ``@`` operator which rejects scalar input before calling this method. Notes ----- To perform matrix-vector multiplication on batches of vectors, use `matvec`. For clarity, it is recommended to use the `matvec` or `matmat` methods directly instead of this method when interacting with dense vectors and matrices. rrErrz6Dimension mismatch: array input `x` must have shape `(z,)` or a shape ending in `(z), K)` for some integer `K`. Given shape: N)rrhr_ProductLinearOperatorr6r rrrrJr5rr4rKr)r7r`ruvectorrjr~s r+rzLinearOperator.dot9s^ &&q) a ()$dhh? ? ^(qTXX> >A;'9!'<HH$$Q' 2AWW_FVVq[5QWWR[A%5FfLQCP../S1$$%GG9. !o%{{1~%{{1~%r,cPt|r td|j|S)zMatrix Multiplication. Used by the ``@`` operator. Rejects scalar input. Otherwise, equivalent to `dot`. 0Scalar operands are not allowed, use '*' instead)r r4rrs r+ __matmul__zLinearOperator.__matmul__s' u OP P||E""r,cPt|r td|j|S)zMatrix Multiplication from the right. Used by the ``@`` operator from the right. Rejects scalar input. Otherwise, equivalent to `rdot`. r)r r4__rmul__rs r+ __rmatmul__zLinearOperator.__rmatmul__s' u OP P}}U##r,c$|j|S)zqMultiplication from the right. Used by the ``*`` operator from the right. Equivalent to `rdot`. )rdotrs r+rzLinearOperator.__rmul__s yy|r,cj|t|trt|jSt |rt |jSt|s&t|sjj|}jd}|j|fk(}|jdk\xr|jd|k(}|s#|s!d|d|d|jd}t|fd }|r!jj||S|r'|jj||Sy ) aMulti-purpose multiplication method from the right. .. note :: This method returns ``x A``. To perform adjoint multiplication instead, use one of `rmatvec` or `rmatmat`, or take the adjoint first, like ``self.H.rdot(x)`` or ``x * self.H``. Parameters ---------- x : array_like or `LinearOperator` or scalar Array-like input will be interpreted as a 1-D row vector or 2-D matrix (or batch of matrices) depending on its shape. See the Returns section for details. Returns ------- xA : array or `LinearOperator` - For `LinearOperator` input, operator composition is performed. - For scalar input, a lazily scaled operator is returned. - Otherwise, the input is expected to take the form of a dense 1-D vector or 2-D matrix (or batch of matrices), interpreted as follows (where ``self`` is an ``M`` by ``N`` linear operator): - If `x` has shape ``(M,)`` it is interpreted as a row vector. - If `x` has shape ``(..., K, M)`` for some integer ``K``, it is interpreted as a matrix (or batch of matrices if there are batch dimensions). See Also -------- dot : Multi-purpose multiplication method from the left. __rmul__ : Equivalent method, used by the ``*`` operator from the right. __rmatmul__ : Method used by the ``@`` operator from the right which rejects scalar input before calling this method. rrrrEz*Dimension mismatch: `x` must have shape `(z,)` or a shape ending in `(K, z&)` for some integer `K`. Given shape: .c|jxxdk(r|Sxdk(r|Sdk(r |jS jj|ddS)NrrerrrE)rTr6moveaxis)r`r7s r+mTzLinearOperator.rdot..mTsOff   ss #xx00B;;r,N)rrhrrr6r rrrrJr5rr4rrKr)r7r`rtrrjr~rs` r+rzLinearOperator.rdots/X &&q) a ()!Tdhh? ? ^(qTXX> >A;'9!'<HH$$Q' 2AWW_FVVq[5QWWR[A%5Ff@D1124$$%GG9A/ !o%  <vv}}RU++$&&--1.//r,cv|j|t|rt|||jStSNr)rr _PowerLinearOperatorr6NotImplemented)r7ps r+__pow__zLinearOperator.__pow__s0 &&q) q>'aDHH= =! !r,c|j|t|trt|||jSt S)zLinear operator addition. The input must be a `LinearOperator`. A lazily summed linear operator is returned. r)rrhr_SumLinearOperatorr6rrs r+__add__zLinearOperator.__add__s5 &&q) a (%dA$((; ;! !r,c2t|d|jS)NrEr)rr6r7s r+__neg__zLinearOperator.__neg__ s$T2$((;;r,c&|j| SN)rrs r+__sub__zLinearOperator.__sub__s||QBr,c|jd}ndt|jz}djd|jD}d|d|jj d|dS) Nzunspecified dtypezdtype=r`c32K|]}t|ywr)str).0dims r+ z*LinearOperator.__repr__..s8cS8s< z with >)r/rjoinr5r*__name__)r7dtr5s r+__repr__zLinearOperator.__repr__sa :: $BC O+B8TZZ885'4>>2236"Q??r,c"|jS)aHermitian adjoint. Returns the Hermitian adjoint of this linear operator, also known as the Hermitian conjugate or Hermitian transpose. For a complex matrix, the Hermitian adjoint is equal to the conjugate transpose. Returns ------- `LinearOperator` Hermitian adjoint of self. See Also -------- :attr:`~scipy.sparse.linalg.LinearOperator.H` : Equivalent attribute. )rrs r+razLinearOperator.adjoints"}}r,c"|jS)zHermitian adjoint. See Also -------- scipy.sparse.linalg.LinearOperator.adjoint : Equivalent method. rrs r+rzLinearOperator.H/s||~r,c"|jS)zTranspose. Returns ------- `LinearOperator` Transpose of the linear operator. See Also -------- :attr:`~scipy.sparse.linalg.LinearOperator.T` : Equivalent attribute. ) _transposers r+ transposezLinearOperator.transpose9s  r,c"|jS)zTranspose. See Also -------- scipy.sparse.linalg.LinearOperator.transpose : Equivalent method. )rrs r+rzLinearOperator.TGs~~r,c0t||jS)ziDefault implementation of `_adjoint`. Defers to adjoint functions, e.g. `_rmatvec` for `_matvec`.r)_AdjointLinearOperatorr6rs r+rzLinearOperator._adjointQs&dtxx88r,c0t||jS)z`Default implementation of `_transpose`. For `_matvec`, defers to `_rmatvec` + `np.conj`.r)_TransposedLinearOperatorr6rs r+rzLinearOperator._transposeVs)$((;;r,r)F)1r __module__ __qualname____doc____array_ufunc__ classmethodtypes GenericAliasr__annotations__intrr9r?rCrSr"r!boolrrKrrkrrrrrrrrrrrrrrrrrrrapropertyrrrrr __classcell__r*s@r+rrGs|~O&11C1C%D{D I(* $,* ( 811f&<4>% 6&448 %E !L&\ # $T0l" "< @& !  9 Linear operator defined in terms of user-specified operations.ct||||d|_||_||_||_||_|jy)Nrf)rr9r'"_CustomLinearOperator__matvec_impl#_CustomLinearOperator__rmatvec_impl#_CustomLinearOperator__rmatmat_impl"_CustomLinearOperator__matmat_implrS) r7r5rKrrr/rr8r*s r+r9z_CustomLinearOperator.__init___sI r* #%%# r,c\|j|j|St| |Sr)rrr"r7rZr*s r+r"z_CustomLinearOperator._matmatts/    )%%a( (7?1% %r,c$|j|Sr)rrs r+r!z_CustomLinearOperator._matveczs!!!$$r,cV|j}| td|j|S)Nzrmatvec is not defined)rr)r7r`funcs r+rkz_CustomLinearOperator._rmatvec}s/"" <%&>? ?""1%%r,c\|j|j|St| |Sr)rrrrs r+rz_CustomLinearOperator._rmatmats0    *&&q) )7#A& &r,c tg|jdd|jd|jd|j|j|j|j |j |jS)NrrE)r5rKrrrr/r8)rr5rrrrr/r6rs r+rz_CustomLinearOperator._adjointsm$DDJJsODTZZ^DTZZ^D&&&&&&&&**xx  r,)NNNNN) rrrrr9r"r!rkrrrrs@r+rr\s5H  *& %& '  r,rc<eZdZdZdfd ZdZdZdZdZxZ S)rz$Adjoint of arbitrary Linear Operatorcg|jdd|jd|jd}t| |j||||_|f|_yNrrEr5rr9r/Ar'r7rr8r5r*s r+r9z_AdjointLinearOperator.__init__V9!''#2,9 9QWWR[9 %,D r,c8|jj|Sr)rrkrs r+r!z_AdjointLinearOperator._matvecvvq!!r,c8|jj|Sr)rr!rs r+rkz_AdjointLinearOperator._rmatvecvv~~a  r,c8|jj|Sr)rrrs r+r"z_AdjointLinearOperator._matmatrr,c8|jj|Sr)rr"rs r+rz_AdjointLinearOperator._rmatmatrr,r rrrrr9r!rkr"rrrs@r+rrs. "!"!r,rc<eZdZdZdfd ZdZdZdZdZxZ S)rz*Transposition of arbitrary Linear Operatorcg|jdd|jd|jd}t| |j||||_|f|_yrrrs r+r9z"_TransposedLinearOperator.__init__rr,c|jj|jj|jj|Sr)r6conjrrkrs r+r!z!_TransposedLinearOperator._matvec/xx}}TVV__TXX]]1-=>??r,c|jj|jj|jj|Sr)r6r rr!rs r+rkz"_TransposedLinearOperator._rmatvec/xx}}TVV^^DHHMM!,<=>>r,c|jj|jj|jj|Sr)r6r rrrs r+r"z!_TransposedLinearOperator._matmatr r,c|jj|jj|jj|Sr)r6r rr"rs r+rz"_TransposedLinearOperator._rmatmatrr,rrrs@r+rrs!4 @?@?r,rc|tn|}|g}|D]-}|t|ds|j|j/t |d|iS)z;Returns the promoted dtype from input dtypes and operators.r/r8)r rappendr/r) operatorsdtypesr8r)s r+ _get_dtypersVjbB ~% ?wsG4 MM#)) $% 6 )b ))r,cBeZdZdZdfd ZdZdZdZdZdZ xZ S) rzRepresenting ``A + B``cZt|trt|ts td|j^}}}|j^}}} ||f|| fk7rtd|d|dt j ||} ||f|_t |!t||g|g| |||y)N)both operands have to be a LinearOperatorz cannot add  and : shape mismatchr) rhrr4r5rOrrr'rr9r r7rBr8A_broadcast_dimsA_MA_NB_broadcast_dimsB_MB_Nrr*s r+r9z_SumLinearOperator.__init__s!^,Jq.4QHI I&'gg# 3&'gg# 3 :#s #{1#U1#5EFG G//0@BRSF  QFr24Q6F4Q4QS4QSUVr,c||jdj||jdj|zSNrrer'rKrs r+r!z_SumLinearOperator._matvec3yy|""1% ! (;(;A(>>>r,c||jdj||jdj|zSr%r'rrs r+rkz_SumLinearOperator._rmatvec3yy|##A&1)=)=a)@@@r,c||jdj||jdj|zSr%r'rrs r+rz_SumLinearOperator._rmatmatr*r,c||jdj||jdj|zSr%r'rrs r+r"z_SumLinearOperator._matmatr'r,cR|j\}}|j|jzSrr'rr7rrs r+rz_SumLinearOperator._adjoint!yy1ssQSSyr,r rrrrr9r!rkrr"rrrs@r+rrs'  W?AA?r,rcBeZdZdZdfd ZdZdZdZdZdZ xZ S) rzRepresenting ``A @ B``cRt|trt|ts td|j^}}}|j^}}} ||k7rtd|d|dt j ||} t |t||g|g| || |||f|_ y)Nrzcannot multiply rrr) rhrr4r5rirrrr9rr'rs r+r9z_ProductLinearOperator.__init__s!^,Jq.4QHI I&'gg# 3&'gg# 3 #:/s%s:JKL L../?AQR QFr24Q6F4Q4QS4QSUVF r,cv|jdj|jdj|Sr%r&rs r+r!z_ProductLinearOperator._matvec.yy|""499Q<#6#6q#9::r,cv|jdj|jdj|SNrerr)rs r+rkz_ProductLinearOperator._rmatvec.yy|##DIIaL$8$8$;<*>q*AAAr,cz|jdj|jdj|zSr9)r'rGrrs r+rz_ScaledLinearOperator._rmatmat#rHr,c^|jd|jdj|zSr9r.rs r+r"z_ScaledLinearOperator._matmat&rEr,cZ|j\}}|j|jzSr)r'rrG)r7rrBs r+rz_ScaledLinearOperator._adjoint)s%995ssU__&&&r,rr3rs@r+rr s&$  5BB5'r,rcHeZdZdZd fd ZdZdZdZdZdZ dZ xZ S) rzRepresenting ``A ** p``c0t|ts td|jd|jdk7rd|}t|t |r|dkr tdt |t|g||j|||f|_y)Nr@rrEz7square core-dimensions of LinearOperator expected, got rz"non-negative integer expected as pr) rhrr4r5rrr9rr')r7rrr8r~r*s r+r9z_PowerLinearOperator.__init__1s!^,;< < 772;!''"+ %KA5QCS/ !|q1uAB B QCB/"=F r,cft|}t|jdD] }||} |S)Nre)r rXr')r7funr`resr[s r+_powerz_PowerLinearOperator._power=s5ajtyy|$ Ac(C  r,cT|j|jdj|SNr)rQr'rKrs r+r!z_PowerLinearOperator._matvecC!{{499Q<..22r,cT|j|jdj|SrS)rQr'rrs r+rkz_PowerLinearOperator._rmatvecF!{{499Q<//33r,cT|j|jdj|SrS)rQr'rrs r+rz_PowerLinearOperator._rmatmatIrVr,cT|j|jdj|SrS)rQr'rrs r+r"z_PowerLinearOperator._matmatLrTr,c>|j\}}|j|zSrr0)r7rrs r+rz_PowerLinearOperator._adjointOsyy1ssAv r,r) rrrrr9rQr!rkrr"rrrs@r+rr.s)!  3443r,rc0eZdZdZdfd ZdZdZxZS)MatrixLinearOperatorz8Operator defined by a matrix `A` which implements ``@``.c|t||j|j|||_d|_|f|_yr)rr9r/r5r_MatrixLinearOperator__adjr')r7rr8r*s r+r9zMatrixLinearOperator.__init__Ws3 !''2. D r,c |j|zSr)rrs r+r"zMatrixLinearOperator._matmat]svvzr,c~|j&t|j|j|_|jSr)r]_AdjointMatrixOperatorrr6rs r+rzMatrixLinearOperator._adjoint`s, :: /488DDJzzr,r)rrrrr9r"rrrs@r+r[r[TsB r,r[c*eZdZdZdfd ZdZxZS)r`z5Representing ``A.H``, for `MatrixLinearOperator` `A`.c|tn|}|jdkDr0t|rtj|dd}n|j }n |j }t|!|j|||f|_ y)NrrErr) r rrrswapaxesrrrr9r r')r7rr8A_Tr*s r+r9z_AdjointMatrixOperator.__init__isg*Y" 66A:{ooaR0dd##C "-D r,cJt|jd|jS)Nrr)r[r'r6rs r+rz_AdjointMatrixOperator._adjointus#DIIaLTXX>>r,r)rrrrr9rrrs@r+r`r`fs? ?r,r`c>eZdZdfd ZdZdZdZdZdZxZ S)IdentityOperatorc(t||||yr)rr9)r7r5r/r8r*s r+r9zIdentityOperator.__init__zs r*r,c|Srrfrs r+r!zIdentityOperator._matvec}r,c|Srrfrs r+rkzIdentityOperator._rmatvecrjr,c|Srrfrs r+rzIdentityOperator._rmatmatrjr,c|Srrfrs r+r"zIdentityOperator._matmatrjr,c|Srrfrs r+rzIdentityOperator._adjoints r,NN) rrrr9r!rkrr"rrrs@r+rgrgys!+r,rgct|tr|St|r\t|tjsBt |}t |rtsntj|d|}t||St|r t|St|tjr3tjtj|}t|St|dr~t|drrd}d}d}t|dr |j}t|dr |j }t|d r |j"}t|j$|j&||| St)d ) a%Return `A` as a `LinearOperator`. See the `LinearOperator` documentation for additional information. Parameters ---------- A : object Object to convert to a `LinearOperator`. May be any one of the following types: - `numpy.ndarray` - `numpy.matrix` - `scipy.sparse` array (e.g. `~scipy.sparse.csr_array`, `~scipy.sparse.lil_array`, etc.) - `LinearOperator` - An object with ``.shape`` and ``.matvec`` attributes Returns ------- B : LinearOperator A `LinearOperator` corresponding with `A` 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)rr8rr5rKNrrr/)rrr/ztype not understood)rhrrrirjrr rrO atleast_ndr[r atleast_2drJrrrr/r5rKrM)rr8rrr/s r+rrs+J!^$:a#; Q  !! $_ qqR0A#A"--{#A&&!RYY MM"**Q- (#A&&q'wq(3 1i iiG 1i iiG 1g GGE GGQXXwu   ) **r,ro)+rrnrr#numpyriscipyrscipy._externalrrOscipy._lib._array_apirrrrr r r r r r scipy.sparserscipy.sparse._sputilsrrrr__all__rrrrrrrrrr[r`rgrrfr,r+rzs*X 2   "RR / 0Q <Q <Q ^>!'N!'H#>#L>$?1?&~(F+F+r,