+ nDjRt^RIt^RIt^RIt^RIt^RIHt^RIH t ^RI H t H t HtHtHtHtHtHtHtHt^RIHt^RIHtHtHtHtRR.t]!4!R R44t!R R ]4t!R R ]4t !RR]4t!R Rlt"!RR]4t#!RR]4t$!RR]4t%!RR]4t&!RR]4t'!RR]'4t(!RR]4t)]!4R4t*R#)!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 isintlikeisshapeLinearOperatoraslinearoperatorcnaa]tRt^GtoRtRt]!]P4t V3Rlt R*Rlt Rt Rt RtRtR tR+V3R lR lltR tR tRtR+V3RlRlltRtRtRtRtRtRtRtRtRtRtRt Rt!Rt"Rt#Rt$R t%R!t&R"t'](R#4t)R$t*](R%4t+R&t,R't-V3R(lt.R)t/Vt0V;t1#),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.]) Nc:<V\Jd\SV` \4#\SV` V4p\ V4P \P 8XdF\ V4P \P 8Xd\P!R\^R7V#)zMLinearOperator subclass should implement at least one of _matvec and _matmat.)category stacklevel) rsuper__new___CustomLinearOperatortype_matvec_matmatwarningswarnRuntimeWarning)clsargskwargsobj __class__s&*, X/data/cameron/venvs/s3viz/lib/python3.14/site-packages/scipy/sparse/linalg/_interface.pyrLinearOperator.__new__sy . 7?#89 9'/#&CS !!^%;%;;I%%)?)?? <+ Jc >Vf\MTpVeVP^VR7Pp\V4p\ V4^8d\ RV: R24h\ VRR7'g\ RV: 24hWnW n\ V4VnW0n R#)zInitialize this LinearOperator. To be called by subclasses. ``dtype`` may be None; ``shape`` should be convertible to a length >=2 tuple. Ndtypezinvalid shape z (must be at least 2-d)F)check_nd) r emptyr,tuplelen ValueErrorrshapendim_xp)selfr,r2xps&&&&r'__init__LinearOperator.__init__s *Y"  HHQeH,22Ee  u:>~eY6MNO Ouu--~eY78 8  J r)cpVPP4pVR,P^4VR&V#)r4)__dict__copyr.r5states& r' __getstate__LinearOperator.__getstate__s1 ""$U|))!,e  r)cz\VPR44VnVPP V4R#)r4N)rpopr4r:updater<s&&r' __setstate__LinearOperator.__setstate__s)"599U#34 U#r)c rVPfoVPpVPVPR,VPR7pVP VP V44pVPVnR#R# \\\3d"\P!TRR7TnR#i;i)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)r6kind) r,r4zerosr2int8asarraymatvec OverflowError TypeError RuntimeErrorxpx default_dtype)r5r6vmatvec_vs& r' _init_dtypeLinearOperator._init_dtypes :: BBrww7A ,::dkk!n5&^^   "9l; G ..":F  Gs A??3B65B6c  VPpTP\VPR,4Uu.uFq0P VRRV3,4NK upRR7#uupi)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). .NNNaxisrH)r4stackranger2rr5Xr6is"" r'rLinearOperator._matmats\XX xx16qwwr{1C D1CA\\!CAI, '1C D2  Ds#A"c pVPpVPVRVP3,4R,#)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. ..)r4rnewaxisr5xr6s&& r'rLinearOperator._matvec*s.XX||Ac2::o./77r)c <V^8dQhRS[/#adjointbool)format __classdict__s"r' __annotate__LinearOperator.__annotate__8s111r)crVPp\VRVR7pVPEvrEpV'dWV3MWe3wrx\V\P 4'd[V'dVP V4MVPV4p VPV^38XdV PV^4p \V 4#Rp Rp VPV^38H;p 'dwV'dRMRp V'dRMRpRV RV R V R 2p\P!V\\PP\ 43R 7VPW34pM>VP"^8d.VPR,V8H;p 'dVPR Rp V 'g)V 'g!R V RV RVP 2p\%V4hV'dVP V4MVPV4p \&P(!WJ4pV 'dVPV .VOVN54p V #V 'dVPV .VOVN^N54p V #)Tsubokr6Fz `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_prefixesNz6Dimension mismatch: `x` must have a shape ending in `(z,)`, or shape `(z, 1)`. Given shape: rH)r4rr2 isinstancenpmatrix_rmatvecrreshaperrr FutureWarningospathdirname__file__r3r1rPbroadcast_shapes)r5rerjr6self_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 $VPV4#)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. rr5res&&r'rLLinearOperator.matvecks8""1%%r)c (VPVRR7#)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. Trjrrs&&r'rmatvecLinearOperator.rmatvecs:""1d"33r)c v\V4P\P8Xdx\VR4'd`\V4P\P8wd8VP pVP VRVP 3,4R,#\hVPPV4#)zHDefault implementation of `_rmatvec`. Defers to `_rmatmat` or `adjoint`._rmatmat.ra) r_adjointrhasattrrr4rcNotImplementedErrorHrrds&& r'ryLinearOperator._rmatvecs :  ."9"9 9j))J''>+B+BBXX}}QsBJJ%78@@% %66>>!$ $r)c <V^8dQhRS[/#rhrk)rmrns"r'rorpsr)c\V4'g*\V4'g\VRVPR7pVP^8d\ RVP R24hVP R,V'dVP R,MVP R ,8wd&\ RVP RVP 24hV'dVPV4MVPV4p\T\P4'd \T4pT# \d5p\T4'g\T4'd \R4ThhRp?ii;i) Trrz-Expected at least 2-d ndarray or matrix, not z-dzDimension 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.NrH)rrrr4r3r1r2rr ExceptionrNrvrwrxr)r5r]rjYes&&& r'_shared_matmatLinearOperator._shared_matmats 1!44$4884A 66A:LQVVHTVWX X 772;W4::b>$**R. I3DJJ>!$ $Js#B%c W,#)z9Apply this linear operator. Equivalent to `__matmul__`. rurs&&r'__call__LinearOperator.__call__s xr)c $VPV4#)zBMultiplication. Used by the ``*`` operator. Equivalent to `dot`. )dotrs&&r'__mul__LinearOperator.__mul__s xx{r)c x\V4'g \R4h\VRV, VPR7#)z;Scalar Division. Returns a lazily scaled linear operator. z.Can only divide a linear operator by a scalar.g?r6)r r1_ScaledLinearOperatorr4r5others&&r' __truediv__LinearOperator.__truediv__$s2 5!!MN N$T3;488DDr)c\VRR4pVf'\WPP^4RR7pW P8wdRVP RV 2p\ V4hR#)r4NT) sparse_okz2Mismatched array namespaces.Namespace for self is z, namespace for x is )getattrrr4r.rN)r5rexp_xrs&& r'_check_matching_namespace(LinearOperator._check_matching_namespace.siq%& <"1hhnnQ&74HD 88 ))- 2GvO C. r)c VPV4\V\4'd\WVPR7#\ V4'd\ WVPR7#\V4'g-\V4'gVPPV4pVPR,pVPV38HpVP^8;'dVPR,V8HpV'g)V'g!RV RV RVP 2p\V4hV'dVPV4#V'dVPV4#R#)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. rz6Dimension mismatch: array input `x` must have shape `(z,)` or a shape ending in `(z), K)` for some integer `K`. Given shape: NrHr)rrvr_ProductLinearOperatorr4r rrrrKr2r3r1rLr)r5rervectorrxrs&& r'rLinearOperator.dot9s^ &&q) a ( ()$dhh? ? ^^(TXX> >A;;'9!'<'<HH$$Q' 2AWW_FVVq[55QWWR[A%5FfLQCP../S1$$%GG9. !o%{{1~%{{1~%r)c \\V4'd \R4hVPV4#)zjMatrix Multiplication. Used by the ``@`` operator. Rejects scalar input. Otherwise, equivalent to `dot`. 0Scalar operands are not allowed, use '*' instead)r r1rrs&&r' __matmul__LinearOperator.__matmul__s* u  OP P||E""r)c \\V4'd \R4hVPV4#)zMatrix Multiplication from the right. Used by the ``@`` operator from the right. Rejects scalar input. Otherwise, equivalent to `rdot`. r)r r1__rmul__rs&&r' __rmatmul__LinearOperator.__rmatmul__s* u  OP P}}U##r)c $VPV4#)zaMultiplication from the right. Used by the ``*`` operator from the right. Equivalent to `rdot`. )rdotrs&&r'rLinearOperator.__rmul__s yy|r)c aSPV4\V\4'd\VSSPR7#\ V4'd\ SVSPR7#\V4'g-\V4'gSPPV4pSPR,pVPV38HpVP^8;'dVPR ,V8HpV'g*V'g"RV RV RVP R2p\V4hV3RlpV'd"SPPV!V44#V'd(V!SPPV!V444#R#) 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. rz*Dimension mismatch: `x` must have shape `(z,)` or a shape ending in `(K, z&)` for some integer `K`. Given shape: .c<VP;;^8XdV#;^8XdV#^8Xd TP#SPPTRR4#)rbrrH)r3Tr4moveaxis)rer5s&r'mTLinearOperator.rdot..mTsOff   ss #xx00B;;r)NrrH)rrvrrr4r rrrrKr2r3r1rrLr)r5rerrrxrrsf& r'rLinearOperator.rdots<X &&q) a ( ()!Tdhh? ? ^^(qTXX> >A;;'9!'<'<HH$$Q' 2AWW_FVVq[55QWWR[A%5Ff@D1124$$%GG9A/ !o%  <vv}}RU++$&&--1.//r)cVPV4\V4'd\WVPR7#\#)r)rr _PowerLinearOperatorr4NotImplemented)r5ps&&r'__pow__LinearOperator.__pow__s0 &&q) q>>'DHH= =! !r)c VPV4\V\4'd\WVPR7#\ #)znLinear operator addition. The input must be a `LinearOperator`. A lazily summed linear operator is returned. r)rrvr_SumLinearOperatorr4rrs&&r'__add__LinearOperator.__add__s6 &&q) a ( (%d$((; ;! !r)c2\VRVPR7#)rrH)rr4r5s&r'__neg__LinearOperator.__neg__ s$T2$((;;r)c&VPV)4#N)rrs&&r'__sub__LinearOperator.__sub__s||QBr)cVPfRpMR\VP4,pRPRVP44pRV RVPP RV R2#) Nzunspecified dtypezdtype=rec38"TFp\V4xK R#5ir)str).0dims& r' *LinearOperator.__repr__..s8ZcSZs< z with >)r,rjoinr2r&__name__)r5dtr2s& r'__repr__LinearOperator.__repr__sa :: $BC O+B8TZZ885'4>>2236"Q??r)c "VP4#)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'rjLinearOperator.adjoints"}}r)c "VP4#)zfHermitian adjoint. See Also -------- scipy.sparse.linalg.LinearOperator.adjoint : Equivalent method. rrs&r'rLinearOperator.H/s||~r)c "VP4#)zTranspose. Returns ------- `LinearOperator` Transpose of the linear operator. See Also -------- :attr:`~scipy.sparse.linalg.LinearOperator.T` : Equivalent attribute. ) _transposers&r' transposeLinearOperator.transpose9s  r)c "VP4#)z`Transpose. See Also -------- scipy.sparse.linalg.LinearOperator.transpose : Equivalent method. )rrs&r'rLinearOperator.TGs~~r)c .\WPR7#)zaDefault implementation of `_adjoint`. Defers to adjoint functions, e.g. `_rmatvec` for `_matvec`.r)_AdjointLinearOperatorr4rs&r'rLinearOperator._adjointQs&dxx88r)c .\WPR7#)zXDefault implementation of `_transpose`. For `_matvec`, defers to `_rmatvec` + `np.conj`.r)_TransposedLinearOperatorr4rs&r'rLinearOperator._transposeVs)((;;r)c2<V^8dQh/S[;R&S[;R&#)ri__class_getitem__r3) classmethodint)rmrns"r'rorpGs"H#DIL IMr))r4r,r3r2r)F)2r __module__ __qualname____firstlineno____doc____array_ufunc__rtypes GenericAliasrrr7r>rCrTrrrrLrryrrrrrrrrrrrrrrrrrrrjpropertyrrrrr__annotate_func____static_attributes____classdictcell__ __classcell__r&rns@@r'rrGs |~O&11C1C%D(* $,* ( 811f&<4>% 6&448 %E !L&\ # $T0l" "< @& !  9 <_r)cdaa]tRtRtoRtR V3RlltV3RltRtRtV3Rlt Rt R t Vt V;t #) ri\z>Linear operator defined in terms of user-specified operations.c<\SV`WQV4RVnW nW0nW`nW@nVP4R#)Nru)rr7r#"_CustomLinearOperator__matvec_impl#_CustomLinearOperator__rmatvec_impl#_CustomLinearOperator__rmatmat_impl"_CustomLinearOperator__matmat_implrT) r5r2rLrrr,rr6r&s &&&&&&&&r'r7_CustomLinearOperator.__init___s? r* #%%# r)c`<VPeVPV4#\SV` V4#r)r$rrr5r]r&s&&r'r_CustomLinearOperator._matmatts/    )%%a( (7?1% %r)c$VPV4#r)r!rs&&r'r_CustomLinearOperator._matveczs!!!$$r)cZVPpVf \R4hVPV4#)Nzrmatvec is not defined)r"r)r5refuncs&& r'ry_CustomLinearOperator._rmatvec}s/"" <%&>? ?""1%%r)c`<VPeVPV4#\SV` V4#r)r#rrr's&&r'r_CustomLinearOperator._rmatmats0    *&&q) )7#A& &r)c  \.VPRROVPR,NVPR,N5VPVPVPVP VP VPR7#)N)r2rLrrrr,r6rrH)rr2r"r!r#r$r,r4rs&r'r_CustomLinearOperator._adjointsm$DDJJsODTZZ^DTZZ^D&&&&&&&&**xx  r)) __matmat_impl __matvec_impl__rmatmat_impl__rmatvec_implr#)NNNNN)rrrrrr7rrryrrrrrrs@@r'rr\s+H*& %& '   r)rcRaa]tRtRtoRtR V3RlltRtRtRtRt Rt Vt V;t #) r iz$Adjoint of arbitrary Linear Operatorc<.VPRROVPR,NVPR,N5p\SV` VPW24WnV3VnR#NrrHr2rr7r,Ar#r5r:r6r2r&s&&& r'r7_AdjointLinearOperator.__init__R9!''#2,9 9QWWR[9 %,D r)c8VPPV4#r)r:ryrs&&r'r_AdjointLinearOperator._matvecvvq!!r)c8VPPV4#r)r:rrs&&r'ry_AdjointLinearOperator._rmatvecvv~~a  r)c8VPPV4#r)r:rrs&&r'r_AdjointLinearOperator._matmatr@r)c8VPPV4#r)r:rrs&&r'r_AdjointLinearOperator._rmatmatrCr)r:r#r rrrrrr7rryrrrrrrs@@r'r r s&. "!"!!r)r cRaa]tRtRtoRtR V3RlltRtRtRtRt Rt Vt V;t #) r iz*Transposition of arbitrary Linear Operatorc<.VPRROVPR,NVPR,N5p\SV` VPW24WnV3VnR#r8r9r;s&&& r'r7"_TransposedLinearOperator.__init__r=r)cVPPVPPVPPV444#r)r4conjr:ryrs&&r'r!_TransposedLinearOperator._matvec/xx}}TVV__TXX]]1-=>??r)cVPPVPPVPPV444#r)r4rNr:rrs&&r'ry"_TransposedLinearOperator._rmatvec/xx}}TVV^^DHHMM!,<=>>r)cVPPVPPVPPV444#r)r4rNr:rrs&&r'r!_TransposedLinearOperator._matmatrPr)cVPPVPPVPPV444#r)r4rNr:rrs&&r'r"_TransposedLinearOperator._rmatmatrSr)rHrrIrs@@r'r r s(4 @?@??r)r cVf\MTpVf.pVF8pVfK \VR4'gKVPVP4K: \ VRV/#)z;Returns the promoted dtype from input dtypes and operators.r,r6)r rappendr,r ) operatorsdtypesr6r%s&&& r' _get_dtyper\sTjbB ~ ?wsG44 MM#)) $ 6 )b ))r)cXaa]tRtRtoRtR V3RlltRtRtRtRt Rt R t Vt V;t #) rizRepresenting ``A + B``cl<\V\4'd\V\4'g \R4hVPEvrEpVPEvrxp WV3W38wd\RV RV R24h\P !WG4p W3Vn\S V`!\W.VR7.V OVNVN5V4R#))both operands have to be a LinearOperatorz cannot add  and : shape mismatchrN) rvrr1r2rPrr#rr7r\ r5r:Br6A_broadcast_dimsA_MA_NB_broadcast_dimsB_MB_Nrr&s &&&& r'r7_SumLinearOperator.__init__s!^,,Jq.4Q4QHI I&'gg# &'gg#  :# #{1#U1#5EFG G//0@SF  QFr24Q6F4Q4QS4QSUVr)cVP^,PV4VP^,PV4,#rbr#rLrs&&r'r_SumLinearOperator._matvec3yy|""1% ! (;(;A(>>>r)cVP^,PV4VP^,PV4,#rlr#rrs&&r'ry_SumLinearOperator._rmatvec3yy|##A&1)=)=a)@@@r)cVP^,PV4VP^,PV4,#rlr#rrs&&r'r_SumLinearOperator._rmatmatrsr)cVP^,PV4VP^,PV4,#rlr#rrs&&r'r_SumLinearOperator._matmatror)cXVPwrVPVP,#rr#rr5r:rcs& r'r_SumLinearOperator._adjointyyssQSSyr)r#rrrrrrr7rryrrrrrrrs@@r'rrs.  W?AA?r)rcXaa]tRtRtoRtR V3RlltRtRtRtRt Rt R t Vt V;t #) rizRepresenting ``A @ B``cf<\V\4'd\V\4'g \R4hVPEvrEpVPEvrxp Wh8wd\RV RV R24h\P !WG4p \ S V`\W.VR7.V OVNV N5V4W3Vn R#)r_zcannot multiply r`rarN) rvrr1r2rwrrr7r\r#rbs &&&& r'r7_ProductLinearOperator.__init__s!^,,Jq.4Q4QHI I&'gg# &'gg#  :/s%s:JKL L../?R QFr24Q6F4Q4QS4QSUVF r)cVP^,PVP^,PV44#rlrmrs&&r'r_ProductLinearOperator._matvec.yy|""499Q<#6#6q#9::r)cVP^,PVP^,PV44#rrqrs&&r'ry_ProductLinearOperator._rmatvec.yy|##DIIaL$8$8$;<*>q*AAAr)cVP^,P4VP^,PV4,#r)r#rrrs&&r'r_ScaledLinearOperator._rmatmat#rr)cvVP^,VP^,PV4,#rrxrs&&r'r_ScaledLinearOperator._matmat&rr)c`VPwrVPVP4,#r)r#rr)r5r:rs& r'r_ScaledLinearOperator._adjoint)s#99ssU__&&&r)rrrrs@@r'rr s-$  5BB5''r)rc^aa]tRtRtoRtR V3RlltRtRtRtRt Rt R t R t Vt V;t#) ri.zRepresenting ``A ** p``cb<\V\4'g \R4hVPR,VPR,8wdRV: 2p\V4h\ V4'dV^8d \R4h\ SV`\V.VR7VPV4W3VnR#)rz7square core-dimensions of LinearOperator expected, got z"non-negative integer expected as prNrrH) rvrr1r2rrr7r\r#)r5r:rr6rr&s&&&& r'r7_PowerLinearOperator.__init__1s!^,,;< < 772;!''"+ %KA5QCS/ !||q1uAB B QCB/"=F r)cr\V4p\VP^,4F pV!V4pK V#r)r r[r#)r5funreresr^s&&& r'_power_PowerLinearOperator._power=s0ajtyy|$Ac(C% r)c\VPVP^,PV4#rl)rr#rLrs&&r'r_PowerLinearOperator._matvecC!{{499Q<..22r)c\VPVP^,PV4#rl)rr#rrs&&r'ry_PowerLinearOperator._rmatvecF!{{499Q<//33r)c\VPVP^,PV4#rl)rr#rrs&&r'r_PowerLinearOperator._rmatmatIrr)c\VPVP^,PV4#rl)rr#rrs&&r'r_PowerLinearOperator._matmatLrr)cDVPwrVPV,#rr{)r5r:rs& r'r_PowerLinearOperator._adjointOsyyssAv r)rr)rrrrrr7rrryrrrrrrrs@@r'rr.s0!  3443r)rcFaa]tRtRtoRtRV3RlltRtRtRtVt V;t #)MatrixLinearOperatoriTz8Operator defined by a matrix `A` which implements ``@``.c|<\SV`VPVPV4WnRVnV3VnR#r)rr7r,r2r:_MatrixLinearOperator__adjr#)r5r:r6r&s&&&r'r7MatrixLinearOperator.__init__Ws1 !''2. D r)c(VPV,#r)r:rs&&r'rMatrixLinearOperator._matmat]svvzr)cVPf'\VPVPR7VnVP#)Nr)r_AdjointMatrixOperatorr:r4rs&r'rMatrixLinearOperator._adjoint`s, :: /488DDJzzr))r:__adjr#r) rrrrrr7rrrrrrs@@r'rrTsB r)rc@aa]tRtRtoRtRV3RlltRtRtVtV;t #)rifz5Representing ``A.H``, for `MatrixLinearOperator` `A`.c<Vf\MTpVP^8d8\V4'd\P!VRR4pMVP pM VP p\SV`!VPV4VR7V3Vn R#)NrrHr) r r3rrswapaxesrrrr7rNr#)r5r:r6A_Tr&s&&& r'r7_AdjointMatrixOperator.__init__isi*Y" 66A:{{ooaR0dd##C "-D r)cR\VP^,VPR7#)rbr)rr#r4rs&r'r_AdjointMatrixOperator._adjointus#DIIaLTXX>>r)rr) rrrrrr7rrrrrs@@r'rrfs? ??r)rcTaa]tRtRtoR V3RlltRtRtRtRtRt Rt Vt V;t #) IdentityOperatoriyc(<\SV`W!V4R#r)rr7)r5r2r,r6r&s&&&&r'r7IdentityOperator.__init__zs r*r)cV#rrurs&&r'rIdentityOperator._matvec}r)cV#rrurs&&r'ryIdentityOperator._rmatvecrr)cV#rrurs&&r'rIdentityOperator._rmatmatrr)cV#rrurs&&r'rIdentityOperator._matmatrr)cV#rrurs&r'rIdentityOperator._adjoints r)ruNN) rrrrr7rryrrrrrrrs@@r'rrys(+r)rcv\V\4'dV#\V4'do\V\P4'gO\ V4p\ V4'd\'gM\P!V^VR7p\WR7#\V4'd \V4#\V\P4'd6\P!\P!V44p\V4#\VR4'd\VR4'dRpRpRp\VR4'd VPp\VR4'd VP p\VR4'd VP"p\VP$VP&W#VR 7#\)R 4h) 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> )r3r6rr2rLNrrr,)rrr,ztype not understood)rvrrrwrxrrrrP atleast_ndrr atleast_2drKrrrr,r2rLrN)r:r6rrr,s& r'rrsIJ!^$$:a#;#; Q  !! $ $__ qqR0A#A--{{#A&&!RYY MM"**Q- (#A&&q'wq(33 1i iiG 1i iiG 1g  GGE GGQXXwu   ) **r)r)+rr|rrnumpyrwscipyrscipy._externalrrPscipy._lib._array_apirrrrrr r r r r scipy.sparserscipy.sparse._sputilsrrrr__all__rrr r r\rrrrrrrrrur)r'rs*X 2   "RR / 0Q <Q <Q ^>!'N!'H#>#L>$?1?&~(F+F+r)