CpjSrSSKrSSKrSSKrSSKrSSKJr SSKJ r SSK J r J r JrJrJrJrJrJrJrJr SSKJr SSKJrJrJrJr SS /r\"5"S S55r"S S \5r"S S\5r "SS\5r!S!Sjr""SS\5r#"SS\5r$"SS\5r%"SS\5r&"SS\5r'"SS\'5r("SS\5r)\"5S 5r*g)"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 isintlikeisshapeLinearOperatoraslinearoperatorcf^\rSrSr%SrSr\"\R5r \\ S'\ \ S'U4Sjr S+Sjr SrS rS rS rS rS,S \4SjjrSrSrSrS,S \4SjjrSrSrSrSrSrSrSrSr Sr!Sr"Sr#Sr$Sr%S r&S!r'S"r(S#r)S$r*\+S%5r,S&r-\+S'5r.S(r/S)r0S*r1U=r2$)-rGaCommon 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.>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.)category stacklevel) rsuper__new___CustomLinearOperatortype_matvec_matmatwarningswarnRuntimeWarning)clsargskwargsobj __class__s Z/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/scipy/sparse/linalg/_interface.pyrLinearOperator.__new__sy . 7?#89 9'/#&CS !!^%;%;;I%%)?)?? <+ Jc(Uc[OUnUbURSUS9Rn[U5n[ U5S:a[ SU<S35e[ USS9(d[ SU<35eXlX l[ U5UlX0l g) 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 emptyr1tuplelen ValueErrorrshaper_xp)selfr1r7xps r,__init__LinearOperator.__init__s *Y"  HHQeH,22Ee  u:>~eY6MNO Ouu-~eY78 8  J r.chURR5nUSRS5US'U$)Nr8r)__dict__copyr3r9states r, __getstate__LinearOperator.__getstate__s1 ""$U|))!,e  r.cx[URS55UlURR U5 g)Nr8)rpopr8r>updater@s r, __setstate__LinearOperator.__setstate__s)"599U#34 U#r.cTURcfURnURURSURS9nUR UR U55nURUlgg![[[4a [R"USS9Ulgf=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. Nr0integral)r:kind) r1r8zerosr7int8asarraymatvec OverflowError TypeError RuntimeErrorxpx default_dtype)r9r:vmatvec_vs r, _init_dtypeLinearOperator._init_dtypes :: BBrww7A ,::dkk!n5&^^   "9l; G ..":F  Gs A55/B'&B'c URnUR[URS5Vs/sHo0R USSS2U45PM snSS9$s snf)aQDefault 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). rJ.Naxis)r8stackranger7r"r9Xr:is r,r#LinearOperator._matmats\XX xx16qwwr{1C D1CA\\!CAI, '1C D2  Ds"Ac`URnURUSUR45S$)a4Default 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)r8r#newaxisr9xr:s r,r"LinearOperator._matvec*s.XX||Ac2::o./77r.adjointcBURn[USUS9nURGtpEnU(aXV4OXe4upx[U[R 5(aXU(aUR U5OURU5n URUS4:XaU RUS5n [U 5$Sn Sn URUS4:H=n (aqU(aSOSn U(aSOS nS U S US US 3n[R"U[[RR[ 54S9 URX45nO8UR"S:a(URSU:H=n (aURSSn U (d'U (d SUSUSUR3n[%U5eU(aUR U5OURU5n [&R("XJ5nU (aURU /UQUP75n U $U (aURU /UQUPSP75n U $)NTsubokr:Fz `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_prefixesrJz6Dimension mismatch: `x` must have a shape ending in `(z,)`, or shape `(z, 1)`. Given shape: )r8rr7 isinstancenpmatrix_rmatvecr"reshaperr$r% FutureWarningospathdirname__file__rr6rTbroadcast_shapes)r9rgrir:self_broadcast_dimsMN inner_dim outer_dimyx_broadcast_dims row_vector column_vector func_namematmat_func_namemsgbroadcasted_dimss r,_shared_matvecLinearOperator._shared_matvec8s XX Qdr *%)ZZ" )0vqf  a # #$+ a aAww9a.(IIi+A; ,. GG 1~5 5= 5'. JI.5{: 9+&K /00QS  MM]8Q7S  1l+A VVq[AGGBK9,DDjD wws| mK/ {; !y*  S/ ! 'DMM! T\\!_//0CV  1< 0<)<=A 1? 0?)?Q?@Ar.c$URU5$)a'Matrix-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. rr9rgs r,rPLinearOperator.matvecks8""1%%r.c"URUSS9$)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. Trirrs r,rmatvecLinearOperator.rmatvecs:""1d"33r.c`[U5R[R:Xam[US5(aV[U5R[R:wa/UR nUR USUR 45S$[eURRU5$)zHDefault implementation of `_rmatvec`. Defers to `_rmatmat` or `adjoint`._rmatmat.rd) r!_adjointrhasattrrr8reNotImplementedErrorHr"rfs r,rsLinearOperator._rmatvecs :  ."9"9 9j))J''>+B+BBXX}}QsBJJ%78@@% %66>>!$ $r.c[U5(d%[U5(d[USURS9nURS:a[ SURS35eUR SU(aUR SOUR S:wa%[ SUR S UR 35eU(aURU5OURU5n[U[R5(a [U5nU$![a2n[U5(d[U5(a [S 5UeeSnAff=f) NTrkrz-Expected at least 2-d ndarray or matrix, not z-drJzDimension 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.)rrrr8rr6r7rr# ExceptionrRrprqrrr)r9r`riYes r,_shared_matmatLinearOperator._shared_matmats 1!44$4884A 66A:LQVVHTVWX X 772;W4::b>$**R. I3DJJ>!$ $Js"Bc X-$)z9Apply this linear operator. Equivalent to `__matmul__`. rnrs r,__call__LinearOperator.__call__s xr.c$URU5$)zBMultiplication. Used by the ``*`` operator. Equivalent to `dot`. )dotrs r,__mul__LinearOperator.__mul__s xx{r.ch[U5(d [S5e[USU- URS9$)z;Scalar Division. Returns a lazily scaled linear operator. z.Can only divide a linear operator by a scalar.g?r:)r r6_ScaledLinearOperatorr8r9others r, __truediv__LinearOperator.__truediv__$s2 5!!MN N$T3;488DDr.c[USS5nUc#[XRRS5SS9nX R:waSURSU3n[ U5eg)Nr8rT) sparse_okz2Mismatched array namespaces.Namespace for self is z, namespace for x is )getattrrr8r3rR)r9rgxp_xrs r,_check_matching_namespace(LinearOperator._check_matching_namespace.siq%& <"1hhnnQ&74HD 88 ))- 2GvO C. r.cURU5 [U[5(a[XURS9$[ U5(a[ XURS9$[U5(d+[U5(dURRU5nURSnURU4:HnURS:=(a URSU:HnU(d'U(d SUSUSUR3n[U5eU(aURU5$U(aURU5$g) axMulti-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. rrJrrz6Dimension mismatch: array input `x` must have shape `(z,)` or a shape ending in `(z), K)` for some integer `K`. Given shape: N)rrpr_ProductLinearOperatorr8r rrrrOr7rr6rPr)r9rgr}vectorrrrs r,rLinearOperator.dot9s^ &&q) a ( ()$dhh? ? ^^(TXX> >A;;'9!'<'<HH$$Q' 2AWW_FVVq[5QWWR[A%5FfLQCP../S1$$%GG9. !o%{{1~%{{1~%r.cZ[U5(a [S5eURU5$)zjMatrix Multiplication. Used by the ``@`` operator. Rejects scalar input. Otherwise, equivalent to `dot`. 0Scalar operands are not allowed, use '*' instead)r r6rrs r, __matmul__LinearOperator.__matmul__s* u  OP P||E""r.cZ[U5(a [S5eURU5$)zMatrix Multiplication from the right. Used by the ``@`` operator from the right. Rejects scalar input. Otherwise, equivalent to `rdot`. r)r r6__rmul__rs r, __rmatmul__LinearOperator.__rmatmul__s* u  OP P}}U##r.c$URU5$)zaMultiplication from the right. Used by the ``*`` operator from the right. Equivalent to `rdot`. )rdotrs r,rLinearOperator.__rmul__s yy|r.c^TRU5 [U[5(a[UTTRS9$[ U5(a[ TUTRS9$[U5(d+[U5(dTRRU5nTRSnURU4:HnURS:=(a URSU:HnU(d(U(d!SUSUSURS3n[U5eU4S jnU(a!TRRU"U55$U(a'U"TRRU"U555$g ) 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. rrrrJz*Dimension mismatch: `x` must have shape `(z,)` or a shape ending in `(K, z&)` for some integer `K`. Given shape: .c>UR==S:Xa U$=S:Xa U$ S:Xa UR$TRRUSS5$)NrrmrrrJ)rTr8moveaxis)rgr9s r,mTLinearOperator.rdot..mTsOff   ss #xx00B;;r.N)rrprrr8r rrrrOr7rr6rrPr)r9rgr|rrrrrs` r,rLinearOperator.rdots9X &&q) a ( ()!Tdhh? ? ^^(qTXX> >A;;'9!'<'<HH$$Q' 2AWW_FVVq[5QWWR[A%5Ff@D1124$$%GG9A/ !o%  <vv}}RU++$&&--1.//r.cxURU5 [U5(a[XURS9$[$Nr)rr _PowerLinearOperatorr8NotImplemented)r9ps r,__pow__LinearOperator.__pow__s0 &&q) q>>'DHH= =! !r.cURU5 [U[5(a[XURS9$[ $)znLinear operator addition. The input must be a `LinearOperator`. A lazily summed linear operator is returned. r)rrpr_SumLinearOperatorr8rrs r,__add__LinearOperator.__add__s6 &&q) a ( (%d$((; ;! !r.c,[USURS9$)NrJr)rr8r9s r,__neg__LinearOperator.__neg__ s$T2$((;;r.c&URU*5$N)rrs r,__sub__LinearOperator.__sub__s||QBr.cURcSnOS[UR5-nSRSUR55nSUSURR SUS3$) Nzunspecified dtypezdtype=rgc38# UHn[U5v M g7fr)str).0dims r, *LinearOperator.__repr__..s8ZcSZs< z with >)r1rjoinr7r+__name__)r9dtr7s r,__repr__LinearOperator.__repr__sa :: $BC O+B8TZZ885'4>>2236"Q??r.c"UR5$)atHermitian 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,riLinearOperator.adjoints"}}r.c"UR5$)zfHermitian adjoint. See Also -------- scipy.sparse.linalg.LinearOperator.adjoint : Equivalent method. rrs r,rLinearOperator.H/s||~r.c"UR5$)zTranspose. Returns ------- `LinearOperator` Transpose of the linear operator. See Also -------- :attr:`~scipy.sparse.linalg.LinearOperator.T` : Equivalent attribute. ) _transposers r, transposeLinearOperator.transpose9s  r.c"UR5$)z`Transpose. See Also -------- scipy.sparse.linalg.LinearOperator.transpose : Equivalent method. )rrs r,rLinearOperator.TGs~~r.c([XRS9$)zaDefault implementation of `_adjoint`. Defers to adjoint functions, e.g. `_rmatvec` for `_matvec`.r)_AdjointLinearOperatorr8rs r,rLinearOperator._adjointQs&dxx88r.c([XRS9$)zXDefault implementation of `_transpose`. For `_matvec`, defers to `_rmatvec` + `np.conj`.r)_TransposedLinearOperatorr8rs r,rLinearOperator._transposeVs)((;;r.)r8r1rr7r)F)3r __module__ __qualname____firstlineno____doc____array_ufunc__ classmethodtypes GenericAliasr__annotations__intrr;rBrGrXr#r"boolrrPrrsrrrrrrrrrrrrrrrrrrripropertyrrrrr__static_attributes__ __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.c>[TU]XQU5 SUlX lX0lX`lX@lUR5 g)Nrn)rr;r("_CustomLinearOperator__matvec_impl#_CustomLinearOperator__rmatvec_impl#_CustomLinearOperator__rmatmat_impl"_CustomLinearOperator__matmat_implrX) r9r7rPrrr1rr:r+s r,r;_CustomLinearOperator.__init___s? r* #%%# r.c^>URbURU5$[TU] U5$r)rrr#r9r`r+s r,r#_CustomLinearOperator._matmatts/    )%%a( (7?1% %r.c$URU5$r)rrs r,r"_CustomLinearOperator._matveczs!!!$$r.cXURnUc [S5eURU5$)Nzrmatvec is not defined)rr)r9rgfuncs r,rs_CustomLinearOperator._rmatvec}s/"" <%&>? ?""1%%r.c^>URbURU5$[TU] U5$r)rrrrs r,r_CustomLinearOperator._rmatmats0    *&&q) )7#A& &r.c [/URSSQURSPURSP7URURURUR UR URS9$)NrrJ)r7rPrrrr1r:)r r7rrrrr1r8rs r,r_CustomLinearOperator._adjointsm$DDJJsODTZZ^DTZZ^D&&&&&&&&**xx  r.) __matmat_impl __matvec_impl__rmatmat_impl__rmatvec_implr()NNNNN) rrrr r r;r#r"rsrrrrrs@r,r r \s:H  *& %& '   r.r cH^\rSrSrSrS U4SjjrSrSrSrSr Sr U=r $) riz$Adjoint of arbitrary Linear Operatorc>/URSSQURSPURSP7n[TU] URX25 XlU4UlgNrrJr7rr;r1Ar(r9r1r:r7r+s r,r;_AdjointLinearOperator.__init__R9!''#2,9 9QWWR[9 %,D r.c8URRU5$r)r1rsrs r,r"_AdjointLinearOperator._matvecvvq!!r.c8URRU5$r)r1r"rs r,rs_AdjointLinearOperator._rmatvecvv~~a  r.c8URRU5$r)r1rrs r,r#_AdjointLinearOperator._matmatr7r.c8URRU5$r)r1r#rs r,r_AdjointLinearOperator._rmatmatr:r.r1r(r rrrr r r;r"rsr#rrrrs@r,rrs$. "!"!!r.rcH^\rSrSrSrS U4SjjrSrSrSrSr Sr U=r $) riz*Transposition of arbitrary Linear Operatorc>/URSSQURSPURSP7n[TU] URX25 XlU4Ulgr/r0r2s r,r;"_TransposedLinearOperator.__init__r4r.cURRURRURRU555$r)r8conjr1rsrs r,r"!_TransposedLinearOperator._matvec/xx}}TVV__TXX]]1-=>??r.cURRURRURRU555$r)r8rEr1r"rs r,rs"_TransposedLinearOperator._rmatvec/xx}}TVV^^DHHMM!,<=>>r.cURRURRURRU555$r)r8rEr1rrs r,r#!_TransposedLinearOperator._matmatrGr.cURRURRURRU555$r)r8rEr1r#rs r,r"_TransposedLinearOperator._rmatmatrJr.r?rr@rs@r,rrs&4 @?@??r.rcUc[OUnUc/nUH6nUcM[US5(dMURUR5 M8 [ USU06$)z;Returns the promoted dtype from input dtypes and operators.r1r:)r rappendr1r) operatorsdtypesr:r*s r, _get_dtyperSsTjbB ~ ?wsG44 MM#)) $ 6 )b ))r.cN^\rSrSrSrS U4SjjrSrSrSrSr Sr S r U=r $) rizRepresenting ``A + B``c^>[U[5(a[U[5(d [S5eURGtpEnURGtpxn XV4X4:wa[SUSUS35e[R "XG5n X4Ul[T U]![X/US9/U QUPUP7U5 g)N)both operands have to be a LinearOperatorz cannot add  and : shape mismatchr) rprr6r7rTrzr(rr;rS r9r1Br:A_broadcast_dimsA_MA_NB_broadcast_dimsB_MB_Nrr+s r,r;_SumLinearOperator.__init__s!^,,Jq.4Q4QHI I&'gg# &'gg#  :# #{1#U1#5EFG G//0@SF  QFr24Q6F4Q4QS4QSUVr.c|URSRU5URSRU5-$Nrrmr(rPrs r,r"_SumLinearOperator._matvec3yy|""1% ! (;(;A(>>>r.c|URSRU5URSRU5-$rcr(rrs r,rs_SumLinearOperator._rmatvec3yy|##A&1)=)=a)@@@r.c|URSRU5URSRU5-$rcr(rrs r,r_SumLinearOperator._rmatmatrjr.c|URSRU5URSRU5-$rcr(rrs r,r#_SumLinearOperator._matmatrfr.cPURupURUR-$rr(rr9r1rZs r,r_SumLinearOperator._adjointyyssQSSyr.r(r rrrr r r;r"rsrr#rrrrs@r,rrs,  W?AA?r.rcN^\rSrSrSrS U4SjjrSrSrSrSr Sr S r U=r $) rizRepresenting ``A @ B``cX>[U[5(a[U[5(d [S5eURGtpEnURGtpxn Xh:wa[SUSUS35e[R "XG5n [ T U][X/US9/U QUPU P7U5 X4Ul g)NrVzcannot multiply rWrXr) rprr6r7rqrzrr;rSr(rYs r,r;_ProductLinearOperator.__init__s!^,,Jq.4Q4QHI I&'gg# &'gg#  :/s%s:JKL L../?R QFr24Q6F4Q4QS4QSUVF r.cvURSRURSRU55$rcrdrs r,r"_ProductLinearOperator._matvec.yy|""499Q<#6#6q#9::r.cvURSRURSRU55$Nrmrrhrs r,rs_ProductLinearOperator._rmatvec.yy|##DIIaL$8$8$;<>[U[5(d [S5e[R"U5(d [S5e[U[ 5(aUR upX$-n[U/U/US9n[TU]%XQRU5 X4Ulg)NLinearOperator expected as Azscalar expected as alphar) rprr6rqisscalarrr(rSrr;r7)r9r1alphar:alpha_originalr1r+s r,r;_ScaledLinearOperator.__init__ s!^,,;< <{{5!!78 8 a. / / ! A*EA3B/ ,J r.c^URSURSRU5-$rrdrs r,r"_ScaledLinearOperator._matvec(yy|diil11!444r.czURSR5URSRU5-$r)r( conjugaterrs r,rs_ScaledLinearOperator._rmatvec 1yy|%%'$))A,*>*>q*AAAr.czURSR5URSRU5-$r)r(rrrs r,r_ScaledLinearOperator._rmatmat#rr.c^URSURSRU5-$rrors r,r#_ScaledLinearOperator._matmat&rr.cXURupURUR5-$r)r(rr)r9r1rs r,r_ScaledLinearOperator._adjoint)s#99ssU__&&&r.rvrrwrs@r,rr s+$  5BB5''r.rcT^\rSrSrSrS U4SjjrSrSrSrSr Sr S r S r U=r $) ri.zRepresenting ``A ** p``cB>[U[5(d [S5eURSURS:waSU<3n[U5e[ U5(aUS:a [S5e[ TU][U/US9URU5 X4Ulg)NrrrJz7square core-dimensions of LinearOperator expected, got rz"non-negative integer expected as pr) rprr6r7rrr;rSr()r9r1rr:rr+s r,r;_PowerLinearOperator.__init__1s!^,,;< < 772;!''"+ %KA5QCS/ !||q1uAB B QCB/"=F r.cj[U5n[URS5H nU"U5nM U$)Nrm)r r^r()r9funrgresras r,_power_PowerLinearOperator._power=s0ajtyy|$Ac(C% r.cTURURSRU5$Nr)rr(rPrs r,r"_PowerLinearOperator._matvecC!{{499Q<..22r.cTURURSRU5$r)rr(rrs r,rs_PowerLinearOperator._rmatvecF!{{499Q<//33r.cTURURSRU5$r)rr(rrs r,r_PowerLinearOperator._rmatmatIrr.cTURURSRU5$r)rr(rrs r,r#_PowerLinearOperator._matmatLrr.c<URupURU-$rrr)r9r1rs r,r_PowerLinearOperator._adjointOsyyssAv r.rvr)rrrr r r;rr"rsrr#rrrrs@r,rr.s.!  3443r.rc<^\rSrSrSrSU4SjjrSrSrSrU=r $)MatrixLinearOperatoriTz8Operator defined by a matrix `A` which implements ``@``.cz>[TU]URURU5 XlSUlU4Ulgr)rr;r1r7r1_MatrixLinearOperator__adjr()r9r1r:r+s r,r;MatrixLinearOperator.__init__Ws1 !''2. D r.c URU-$r)r1rs r,r#MatrixLinearOperator._matmat]svvzr.czURc#[URURS9UlUR$r)r_AdjointMatrixOperatorr1r8rs r,rMatrixLinearOperator._adjoint`s, :: /488DDJzzr.)r1__adjr(r) rrrr r r;r#rrrrs@r,rrTsB r.rc6^\rSrSrSrSU4SjjrSrSrU=r$)rifz5Representing ``A.H``, for `MatrixLinearOperator` `A`.c >Uc[OUnURS:a6[U5(a[R"USS5nOUR nO UR n[TU]!URU5US9 U4Ul g)NrrJrr) r rrrswapaxesrrrr;rEr()r9r1r:A_Tr+s r,r;_AdjointMatrixOperator.__init__isi*Y" 66A:{{ooaR0dd##C "-D r.cD[URSURS9$)Nrr)rr(r8rs r,r_AdjointMatrixOperator._adjointus#DIIaLTXX>>r.rvr) rrrr r r;rrrrs@r,rrfs? ??r.rcJ^\rSrSrS U4SjjrSrSrSrSrSr Sr U=r $) IdentityOperatoriyc&>[TU]X!U5 gr)rr;)r9r7r1r:r+s r,r;IdentityOperator.__init__zs r*r.cU$rrnrs r,r"IdentityOperator._matvec}r.cU$rrnrs r,rsIdentityOperator._rmatvecrr.cU$rrnrs r,rIdentityOperator._rmatmatrr.cU$rrnrs r,r#IdentityOperator._matmatrr.cU$rrnrs r,rIdentityOperator._adjoints r.rnNN) rrrr r;r"rsrr#rrrrs@r,rrys&+r.rcL[U[5(aU$[U5(ae[U[R5(dF[ U5n[ U5(a [(dO[R"USUS9n[XS9$[U5(a [U5$[U[R5(a5[R"[R"U55n[U5$[US5(a[US5(a}SnSnSn[US5(a URn[US5(a UR n[US 5(a UR"n[UR$UR&X#US 9$[)S 5e) aReturn `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)rr:rr7rPNrrr1)rrr1ztype not understood)rprrrqrrrr rrT atleast_ndrr atleast_2drOrrrr1r7rPrR)r1r:rrr1s r,rrsIJ!^$$:a#;#; Q  !! $ $__ qqR0A#A--{{#A&&!RYY MM"**Q- (#A&&q'wq(33 1i iiG 1i iiG 1g  GGE GGQXXwu   ) **r.r)+r rvr r$numpyrqscipyrscipy._externalrrTscipy._lib._array_apirrrrr r r r r r scipy.sparserscipy.sparse._sputilsrrrr__all__rr rrrSrrrrrrrrrnr.r,rs*X 2   "RR / 0Q <Q <Q ^>!'N!'H#>#L>$?1?&~(F+F+r.