+
    ùª¨js¦  ã                   óÆ  € R t ^ RIt^ RIt^ RIt^ RIt^ RIHt ^ RIH	t
 ^ RIHtHtHtHtHtHtHtHtHtHt ^ RIHt ^ RIHtHtHtHt RR.t]! 4        ! R	 R4      4       t ! R
 R]4      t ! R R]4      t  ! R R]4      t!R R lt" ! R R]4      t# ! R R]4      t$ ! R R]4      t% ! R R]4      t& ! R R]4      t' ! R R]'4      t( ! R R]4      t)]! 4       R 4       t*R# )!aU  Abstract 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Ú_asarrayÚarray_namespaceÚis_array_api_objÚis_pydata_sparse_arrayÚ	np_compatÚxp_capabilitiesÚxp_copyÚxp_isscalarÚxp_result_type)Úissparse)ÚasmatrixÚis_pydata_spmatrixÚ	isintlikeÚisshapeÚLinearOperatorÚaslinearoperatorc                   ón  a a€ ] tR t^Gt oRtRt]! ]P                  4      t	V 3R lt
R*R ltR tR tR tR tR	 tR+V3R
 lR lltR tR tR tR+V3R lR lltR tR tR tR tR tR tR tR tR tR tR t R t!R t"R t#R t$R  t%R! t&R" t'](R# 4       t)R$ t*](R% 4       t+R& t,R' t-V3R( lt.R)t/Vt0V ;t1# ),r   a  Common 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 <https://pylops.readthedocs.io>`_.

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 \         J d   \        SV `	  \        4      # \        SV `	  V 4      p\	        V4      P
                  \         P
                  8X  dF   \	        V4      P                  \         P                  8X  d   \        P                  ! R \        ^R7       V# )zMLinearOperator subclass should implement at least one of _matvec and _matmat.)ÚcategoryÚ
stacklevel)
r   ÚsuperÚ__new__Ú_CustomLinearOperatorÚtypeÚ_matvecÚ_matmatÚwarningsÚwarnÚRuntimeWarning)ÚclsÚargsÚkwargsÚobjÚ	__class__s   &*, €ÚZC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\scipy\sparse\linalg\_interface.pyr   ÚLinearOperator.__new__Ï   sy   ø€ Ø”.Ó ä‘7‘?Ô#8Ó9Ð9ä‘'‘/ #Ó&ˆCô �S“	×!Ñ!¤^×%;Ñ%;Ô;Ü˜“I×%Ñ%¬×)?Ñ)?Ô?ä—’ð<ä+Ø õ	ð ˆJó    c                ó>  € Vf   \         MTpVe   VP                  ^ VR7      P                  p\        V4      p\	        V4      ^8  d   \        RV: R24      h\        VRR7      '       g   \        RV: 24      hWn        W n        \	        V4      V n        W0n	        R# )z‹Initialize this LinearOperator.

To be called by subclasses. ``dtype`` may be None; ``shape`` should
be convertible to a length >=2 tuple.
N©Údtypezinvalid shape z (must be at least 2-d)F)Úcheck_nd)
r	   Úemptyr,   ÚtupleÚlenÚ
ValueErrorr   ÚshapeÚndimÚ_xp)Úselfr,   r2   Úxps   &&&&r'   Ú__init__ÚLinearOperator.__init__ã   s�   € ð š*�Y¨"ˆØÒØ—H‘H˜Q e�HÓ,×2Ñ2ˆEä�e“ˆÜˆu‹:˜Œ>Ü˜~¨e©YÐ6MÐNÓOÐOÜ�u u×-Ó-Ü˜~¨e©YÐ7Ó8Ð8àŒ
ØŒ
Ü˜“JˆŒ	ØŽr)   c                óp   € V P                   P                  4       pVR ,          P                  ^ 4      VR &   V# )r4   )Ú__dict__Úcopyr.   ©r5   Ústates   & r'   Ú__getstate__ÚLinearOperator.__getstate__ø   s1   € Ø—‘×"Ñ"Ó$ˆØ˜U•|×)Ñ)¨!Ó,ˆˆe‰Øˆr)   c                óz   € \        VP                  R 4      4      V n        V P                  P	                  V4       R# )r4   N)r   Úpopr4   r:   Úupdater<   s   &&r'   Ú__setstate__ÚLinearOperator.__setstate__ý   s)   € Ü" 5§9¡9¨UÓ#3Ó4ˆŒØ�‰×Ñ˜UÖ#r)   c                ór  € V P                   fo   V P                  pVP                  V P                  R,          VP                  R7      p VP                  V P                  V4      4      pVP                   V n         R# R#   \        \        \        3 d"    \        P                  ! TRR7      T n          R# i ; i)aÀ  Determine 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)r6   Úkindéÿÿÿÿ)r,   r4   Úzerosr2   Úint8ÚasarrayÚmatvecÚOverflowErrorÚ	TypeErrorÚRuntimeErrorÚxpxÚdefault_dtype)r5   r6   ÚvÚmatvec_vs   &   r'   Ú_init_dtypeÚLinearOperator._init_dtype  s�   € ð �:‰:ÒØ—‘ˆBØ—‘˜Ÿ™ B�¨r¯w©w�Ó7ˆAð,ØŸ:™: d§k¡k°!£nÓ5�ð &Ÿ^™^�–
ñ øô
 "¤9¬lÐ;ô GÜ ×.Ò.°"¸:ÔF�—
ðGús   Á
 A? Á?3B6Â5B6c               óÎ   € V P                   pTP                  \        VP                  R,          4       Uu. uF  q0P	                  VRRV3,          4      NK  	  upRR7      # u upi )aQ  Default 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).
.ºNNN©ÚaxisrH   )r4   ÚstackÚranger2   r   ©r5   ÚXr6   Úis   ""  r'   r   ÚLinearOperator._matmat  s\   € ð �X‰Xˆð �x‰xÜ16°q·w±w¸rµ{Ô1CÓDÑ1C¨A�\‰\˜!˜C  A˜I�,Ö'Ñ1CÑDÈ2ð ó 
ð 	
ùÚDs   ¶#A"c                óp   € V P                   pV P                  VRVP                  3,          4      R,          # )a4  Default 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.
.©.é    )r4   r   Únewaxis©r5   Úxr6   s   && r'   r   ÚLinearOperator._matvec*  s.   € ð �X‰XˆØ�|‰|˜A˜c 2§:¡:˜oÕ.Ó/°Õ7Ð7r)   c                ó    <€ V ^8„  d   QhRS[ /# ©é   Úadjoint©Úbool)ÚformatÚ__classdict__s   "€r'   Ú__annotate__ÚLinearOperator.__annotate__8  s   ø€ ÷ 1ñ 1©ñ 1r)   c                ór  € V P                   p\        VR VR7      pV P                  Ev rEpV'       d   WV3MWe3w  rx\        V\        P
                  4      '       d[   V'       d   V P                  V4      MV P                  V4      p	VP                  V^38X  d   V	P                  V^4      p	\        V	4      # Rp
RpVP                  V^38H  ;p'       dw   V'       d   RMRpV'       d   RMRpRV RV R	V R
2p\        P                  ! V\        \        P                  P                  \         4      3R7       VP                  W34      pM>VP"                  ^8¼  d.   VP                  R,          V8H  ;p'       d   VP                  RR p
V'       g)   V'       g!   RV RV RVP                   2p\%        V4      hV'       d   V P                  V4      MV P                  V4      p	\&        P(                  ! WJ4      pV'       d   VP                  V	. VOVN54      p	V	# V'       d   VP                  V	. VOVN^N54      p	V	# )T©Úsubokr6   Fz	`rmatvec`z`matvec`z	`rmatmat`z`matmat`zCalling 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   )r4   r   r2   Ú
isinstanceÚnpÚmatrixÚ_rmatvecr   Úreshaper   r   r    ÚFutureWarningÚosÚpathÚdirnameÚ__file__r3   r1   rP   Úbroadcast_shapes)r5   re   rj   r6   Úself_broadcast_dimsÚMÚNÚ	inner_dimÚ	outer_dimÚyÚx_broadcast_dimsÚ
row_vectorÚcolumn_vectorÚ	func_nameÚmatmat_func_nameÚmsgÚbroadcasted_dimss   &&&              r'   Ú_shared_matvecÚLinearOperator._shared_matvec8  s  € Ø�X‰Xˆä�Q˜d rÔ*ˆà%)§Z¡ZÑ"Ð	 ß)0 ™v°q°fÑˆ	ô �aœŸ™×#Ò#ß$+�—‘˜aÔ °·±¸a³ˆAØ�w‰w˜9 a˜.Ô(Ø—I‘I˜i¨Ó+�Ü˜A“;Ðà,.ÐØ ˆ
ØŸG™G¨	°1 ~Ñ5Ð5ˆ=Ö5ß'.™°JˆIß.5™{¸:Ðà˜9˜+ð &Ø�Kð  à/Ð0Ð0QðSð ô �MŠMØ”]¼¿¹¿¹ÌÓ8QÐ7Sõð —
‘
˜1˜lÓ+‰AØ�V‰V�qŒ[¨A¯G©G°B­K¸9Ñ,DÐD˜jÖDØ Ÿw™w s¨˜|ÐçŸmðØ�KÐ/°	¨{ð ; Ø !§¡˜yð*ð ô
 ˜S“/Ð!ç 'ˆD�M‰M˜!Ô¨T¯\©\¸!«_ˆä×/Ò/Ð0CÓVÐßØ—
‘
˜1Ð<Ð 0Ð<°)Ñ<Ó=ˆAð ˆ÷ Ø—
‘
˜1Ð?Ð 0Ð?°)Ð?¸QÑ?Ó@ˆAàˆr)   c                ó$   € V P                  V4      # )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.
©rŽ   ©r5   re   s   &&r'   rL   ÚLinearOperator.matveck  s   € ð8 ×"Ñ" 1Ó%Ð%r)   c                ó(   € V P                  VRR7      # )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.
T©rj   r‘   r’   s   &&r'   ÚrmatvecÚLinearOperator.rmatvec‰  s   € ð: ×"Ñ" 1¨dÐ"Ó3Ð3r)   c                óv  € \        V 4      P                  \        P                  8X  dx   \        V R4      '       d`   \        V 4      P                  \        P                  8w  d8   V P
                  pV P	                  VRVP                  3,          4      R,          # \        hV P                  P                  V4      # )zHDefault implementation of `_rmatvec`.
Defers to `_rmatmat` or `adjoint`.Ú_rmatmat.ra   )
r   Ú_adjointr   Úhasattrr™   r4   rc   ÚNotImplementedErrorÚHr   rd   s   && r'   ry   ÚLinearOperator._rmatvec¨  s†   € ô �‹:×Ñ¤.×"9Ñ"9Ô9ô ˜˜j×)Ò)Ü˜“J×'Ñ'¬>×+BÑ+BÔBà—X‘X�à—}‘} Q s¨B¯J©J Õ%7Ó8¸Õ@Ð@Ü%Ð%à—6‘6—>‘> !Ó$Ð$r)   c                ó    <€ V ^8„  d   QhRS[ /# rh   rk   )rm   rn   s   "€r'   ro   rp   ¸  s   ø€ ÷ ñ ©ñ r)   c                óÐ  € \        V4      '       g*   \        V4      '       g   \        VR V P                  R7      pVP                  ^8  d   \        RVP                   R24      hVP                  R,          V'       d   V P                  R,          MV P                  R	,          8w  d&   \        RV P                   RVP                   24      h V'       d   V P                  V4      MV P                  V4      p\        T\        P                  4      '       d   \        T4      pT#   \         d5   p\        T4      '       g   \        T4      '       d   \        R4      Thh Rp?ii ; i)
Trr   z-Expected at least 2-d ndarray or matrix, not z-dzDimension mismatch: z, z³Multipliying LinearOperator with a sparse matrix failed. Try wrapping the matrix with `aslinearoperator` first, or ensuring the operator's `matmat` function supports sparse input.NéþÿÿÿrH   )r   r   r   r4   r3   r1   r2   r™   r   Ú	ExceptionrN   rv   rw   rx   r   )r5   r]   rj   ÚYÚes   &&&  r'   Ú_shared_matmatÚLinearOperator._shared_matmat¸  s  € Ü˜—’Ô1°!×4Ò4Ü˜ $¨4¯8©8Ô4ˆAà�6‰6�AŒ:ÜÐLÈQÏVÉVÈHÐTVÐWÓXÐXà�7‰7�2�;¯W˜4Ÿ:™: bž>¸$¿*¹*ÀR½.ÔIÜÐ3°D·J±J°<¸rÀ!Ç'Á'ÀÐKÓLÐLð
	ß$+�—‘˜aÔ °·±¸a³ˆAô �aœŸ™×#Ò#Ü˜“ˆAàˆøô ô 	Ü˜�{Š{Ô0°×3Ò3Üð.óð
 ðð ûð	ús   ÃD& Ã"D& Ä&E%Ä1/E Å E%c                ó$   € V P                  V4      # )aI  Matrix-matrix multiplication.

Performs the operation ``A @ X`` where ``A`` is an ``M`` x ``N``
linear operator (or batch of linear operators)
and `X` is a dense ``N`` x ``K`` matrix
(or batch of dense matrices).

Parameters
----------
X : {matrix, ndarray}
    An array with shape ``(..., N, K)`` representing the dense matrix
    (or batch of dense matrices).

Returns
-------
Y : {matrix, ndarray}
    An array with shape ``(..., M, K)``.

Notes
-----
This method wraps any user-specified ``matmat`` routine or overridden
``_matmat`` method to ensure that `Y` has the correct type.
©r¥   ©r5   r]   s   &&r'   ÚmatmatÚLinearOperator.matmatÓ  s   € ð0 ×"Ñ" 1Ó%Ð%r)   c                ó(   € V P                  VRR7      # )aˆ  Adjoint matrix-matrix multiplication.

Performs the operation ``A^H @ X`` where ``A`` is an ``M`` x ``N``
linear operator (or batch of linear operators)
and `X` is a dense ``M`` x ``K`` matrix
(or batch of dense matrices).
The default implementation defers to the adjoint.

Parameters
----------
X : {matrix, ndarray}
    An array with shape ``(..., M, K)`` representing the dense matrix
    (or batch of dense matrices).

Returns
-------
Y : {matrix, ndarray}
    An array with shape ``(..., N, K)``.

Notes
-----
This method wraps any user-specified ``rmatmat`` routine or overridden
``_rmatmat`` method to ensure that `Y` has the correct type.

Tr•   r¨   r©   s   &&r'   ÚrmatmatÚLinearOperator.rmatmatí  s   € ð4 ×"Ñ" 1¨dÐ"Ó3Ð3r)   c               óT  € \        V 4      P                  \        P                  8X  db   V P                  pTP	                  \        VP                  R,          4       Uu. uF  q0P                  VRRV3,          4      NK  	  upRR7      # V P                  P                  V4      # u upi )zGDefault implementation of `_rmatmat`; defers to `rmatvec` or `adjoint`..rW   rX   rH   )
r   rš   r   r4   rZ   r[   r2   ry   r�   r   r\   s   ""  r'   r™   ÚLinearOperator._rmatmat	  s‹   € ä�‹:×Ñ¤.×"9Ñ"9Ô9Ø—‘ˆBð —8‘8Ü6;¸A¿G¹GÀB½KÔ6HÓIÑ6H°—‘˜q  a¨ �|Ö,Ñ6HÑIÐPRð ó ð ð —6‘6—>‘> !Ó$Ð$ùò Js   Á#B%c                ó   € W,          # )z9Apply this linear operator.

Equivalent to `__matmul__`.
ru   r’   s   &&r'   Ú__call__ÚLinearOperator.__call__  s   € ð
 �xˆr)   c                ó$   € V P                  V4      # )zBMultiplication.

Used by the ``*`` operator. Equivalent to `dot`.
)Údotr’   s   &&r'   Ú__mul__ÚLinearOperator.__mul__  s   € ð
 �x‰x˜‹{Ðr)   c                óx   € \        V4      '       g   \        R4      h\        V RV,          V P                  R7      # )z;Scalar Division.

Returns a lazily scaled linear operator.
z.Can only divide a linear operator by a scalar.g      ð?©r6   )r   r1   Ú_ScaledLinearOperatorr4   ©r5   Úothers   &&r'   Ú__truediv__ÚLinearOperator.__truediv__$  s2   € ô
 ˜5×!Ò!ÜÐMÓNÐNä$ T¨3°­;¸4¿8¹8ÔDÐDr)   c                óÎ   € \        VR R4      pVf'   \        WP                  P                  ^ 4      RR7      pW P                  8w  d   RV P                   RV 2p\	        V4      hR# )r4   NT)Ú	sparse_okz2Mismatched array namespaces.Namespace for self is z, namespace for x is )Úgetattrr   r4   r.   rN   )r5   re   Úxp_xrŒ   s   &&  r'   Ú_check_matching_namespaceÚ(LinearOperator._check_matching_namespace.  si   € Ü�q˜% Ó&ˆØŠ<Ü" 1§h¡h§n¡n°QÓ&7À4ÔHˆDØ—8‘8Ôð)Ø)-¯©¨
Ð2GÈÀvðOð ô ˜C“.Ð ñ r)   c                ó°  € V P                  V4       \        V\        4      '       d   \        WV P                  R7      # \        V4      '       d   \        WV P                  R7      # \        V4      '       g-   \        V4      '       g   V P                  P                  V4      pV P                  R,          pVP                  V38H  pVP                  ^8¬  ;'       d    VP                  R,          V8H  pV'       g)   V'       g!   RV RV RVP                   2p\        V4      hV'       d   V P                  V4      # V'       d   V P                  V4      # R# )ax  Multi-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.

r¹   z6Dimension mismatch: array input `x` must have shape `(z,)` or a shape ending in `(z), K)` for some integer `K`. Given shape: NrH   r¡   )rÃ   rv   r   Ú_ProductLinearOperatorr4   r   rº   r   r   rK   r2   r3   r1   rL   rª   )r5   re   rƒ   Úvectorrx   rŒ   s   &&    r'   rµ   ÚLinearOperator.dot9  s  € ð^ 	×&Ñ& qÔ)Ü�aœ×(Ò(Ü)¨$°d·h±hÔ?Ð?Ü˜�^Š^Ü(¨°T·X±XÔ>Ð>ä˜A—;’;Ô'9¸!×'<Ò'<ð —H‘H×$Ñ$ QÓ'�à—
‘
˜2•ˆAð —W‘W  ‘_ˆFØ—V‘V˜q‘[×5Ð5 Q§W¡W¨R¥[°AÑ%5ˆFçŸfàLÈQÈCð P.Ø./¨Sð 1$Ø$%§G¡G 9ð.ð ô
 ! “oÐ%çØ—{‘{ 1“~Ð%ßØ—{‘{ 1“~Ð%ñ r)   c                ó\   € \        V4      '       d   \        R4      hV P                  V4      # )zjMatrix Multiplication.

Used by the ``@`` operator.
Rejects scalar input.
Otherwise, equivalent to `dot`.
ú0Scalar operands are not allowed, use '*' instead)r   r1   r¶   r»   s   &&r'   Ú
__matmul__ÚLinearOperator.__matmul__‡  s*   € ô �u×ÒÜÐOÓPÐPØ�|‰|˜EÓ"Ð"r)   c                ó\   € \        V4      '       d   \        R4      hV P                  V4      # )z‰Matrix Multiplication from the right.

Used by the ``@`` operator from the right.
Rejects scalar input.
Otherwise, equivalent to `rdot`.
rÊ   )r   r1   Ú__rmul__r»   s   &&r'   Ú__rmatmul__ÚLinearOperator.__rmatmul__’  s*   € ô �u×ÒÜÐOÓPÐPØ�}‰}˜UÓ#Ð#r)   c                ó$   € V P                  V4      # )zaMultiplication from the right.

Used by the ``*`` operator from the right. Equivalent to `rdot`.
)Úrdotr’   s   &&r'   rÎ   ÚLinearOperator.__rmul__�  s   € ð
 �y‰y˜‹|Ðr)   c                ó  a € S P                  V4       \        V\        4      '       d   \        VS S P                  R7      # \        V4      '       d   \        S VS P                  R7      # \        V4      '       g-   \        V4      '       g   S P                  P                  V4      pS P                  R,          pVP                  V38H  pVP                  ^8¬  ;'       d    VP                  R	,          V8H  pV'       g*   V'       g"   RV RV RVP                   R2p\        V4      hV 3R lpV'       d"   S P                  P                  V! V4      4      # V'       d(   V! S P                  P                  V! V4      4      4      # R# )
a€  Multi-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.
r¹   z*Dimension mismatch: `x` must have shape `(z,)` or a shape ending in `(K, z&)` for some integer `K`. Given shape: Ú.c                 óª   <€ V P                   ;;^ 8X  d     V # ;^8X  d     V #  ^8X  d   T P                  #  SP                  P                  T RR4      # )rb   r¡   rH   )r3   ÚTr4   Úmoveaxis)re   r5   s   &€r'   ÚmTÚLinearOperator.rdot.<locals>.mTí  sO   ø€ Ø—f‘fØž˜Ù ˜ö ˜Ù ˜ð åØ Ÿs™s˜
ØØ#Ÿx™x×0Ñ0°°B¸Ó;Ð;r)   Nr¡   rH   )rÃ   rv   r   rÆ   r4   r   rº   r   r   rK   r2   r3   r1   r×   rL   rª   )r5   re   r‚   rÇ   rx   rŒ   rÙ   s   f&     r'   rÒ   ÚLinearOperator.rdot¤  s<  ø€ ðX 	×&Ñ& qÔ)Ü�aœ×(Ò(Ü)¨!¨T°d·h±hÔ?Ð?Ü˜�^Š^Ü(¨¨q°T·X±XÔ>Ð>ä˜A—;’;Ô'9¸!×'<Ò'<ð —H‘H×$Ñ$ QÓ'�à—
‘
˜2•ˆAð —W‘W  ‘_ˆFØ—V‘V˜q‘[×5Ð5 Q§W¡W¨R¥[°AÑ%5ˆFçŸfà@ÀÀð D1Ø12°ð 4$Ø$%§G¡G 9¨Að/ð ô
 ! “oÐ%õ
<÷ Ø—v‘v—}‘}¡R¨£UÓ+Ð+ßÙ˜$Ÿ&™&Ÿ-™-©¨1«Ó.Ó/Ð/ñ r)   c                ó€   € V P                  V4       \        V4      '       d   \        WV P                  R 7      # \        # )r¹   )rÃ   r   Ú_PowerLinearOperatorr4   ÚNotImplemented)r5   Úps   &&r'   Ú__pow__ÚLinearOperator.__pow__ú  s0   € Ø×&Ñ& qÔ)Ü�q�>Š>Ü'¨°D·H±HÔ=Ð=ä!Ð!r)   c                óŠ   € V P                  V4       \        V\        4      '       d   \        WV P                  R7      # \
        # )znLinear operator addition.

The input must be a `LinearOperator`.
A lazily summed linear operator is returned.
r¹   )rÃ   rv   r   Ú_SumLinearOperatorr4   rÞ   r’   s   &&r'   Ú__add__ÚLinearOperator.__add__  s6   € ð 	×&Ñ& qÔ)Ü�aœ×(Ò(Ü% d°$·(±(Ô;Ð;ä!Ð!r)   c                ó2   € \        V RV P                  R7      # )é   r¹   rH   )rº   r4   ©r5   s   &r'   Ú__neg__ÚLinearOperator.__neg__  s   € Ü$ T¨2°$·(±(Ô;Ð;r)   c                ó&   € V P                  V) 4      # ©N)rä   r’   s   &&r'   Ú__sub__ÚLinearOperator.__sub__  s   € Ø�|‰|˜Q˜BÓÐr)   c                óà   € V P                   f   RpMR\        V P                   4      ,           pRP                  R V P                   4       4      pRV RV P                  P
                   RV R2# )	Nzunspecified dtypezdtype=re   c              3   ó8   "  € T F  p\        V4      x € K  	  R # 5irì   )Ústr)Ú.0Údims   & r'   Ú	<genexpr>Ú*LinearOperator.__repr__.<locals>.<genexpr>  s   é € Ð8©Z cœ˜SŸ˜«Zùs   ‚Ú<Ú z with Ú>)r,   rñ   Újoinr2   r&   Ú__name__)r5   Údtr2   s   &  r'   Ú__repr__ÚLinearOperator.__repr__  sa   € Ø�:‰:ÒØ$‰BàœC §
¡
›OÕ+ˆBà—‘Ñ8¨T¯ZªZÓ8Ó8ˆØ�5�'˜˜4Ÿ>™>×2Ñ2Ð3°6¸"¸¸QÐ?Ð?r)   c                ó"   € V P                  4       # )at  Hermitian 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.
)rš   rè   s   &r'   rj   ÚLinearOperator.adjoint  s   € ð" �}‰}‹Ðr)   c                ó"   € V P                  4       # )zfHermitian adjoint.

See Also
--------
scipy.sparse.linalg.LinearOperator.adjoint : Equivalent method.
r•   rè   s   &r'   r�   ÚLinearOperator.H/  s   € ð �|‰|‹~Ðr)   c                ó"   € V P                  4       # )z¬Transpose.

Returns
-------
`LinearOperator`
    Transpose of the linear operator.

See Also
--------
:attr:`~scipy.sparse.linalg.LinearOperator.T` : Equivalent attribute.
)Ú
_transposerè   s   &r'   Ú	transposeÚLinearOperator.transpose9  s   € ð �‰Ó Ð r)   c                ó"   € V P                  4       # )z`Transpose.

See Also
--------
scipy.sparse.linalg.LinearOperator.transpose : Equivalent method.
)r  rè   s   &r'   r×   ÚLinearOperator.TG  s   € ð �~‰~ÓÐr)   c                ó.   € \        W P                  R7      # )zaDefault implementation of `_adjoint`.
Defers to adjoint functions, e.g. `_rmatvec` for `_matvec`.r¹   )Ú_AdjointLinearOperatorr4   rè   s   &r'   rš   ÚLinearOperator._adjointQ  s   € ô & d¯x©xÔ8Ð8r)   c                ó.   € \        W P                  R7      # )zXDefault implementation of `_transpose`.
For `_matvec`, defers to `_rmatvec` + `np.conj`.r¹   )Ú_TransposedLinearOperatorr4   rè   s   &r'   r  ÚLinearOperator._transposeV  s   € ô )¨·(±(Ô;Ð;r)   c                ó2   <€ V ^8„  d   Qh/ S[ ;R&   S[;R&   # )ri   Ú__class_getitem__r3   )ÚclassmethodÚint)rm   rn   s   "€r'   ro   rp   G   s"   ø‡ ‚ ñH #ÑDñI ñL �IòM r)   )r4   r,   r3   r2   rì   )F)2rú   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú__array_ufunc__r  ÚtypesÚGenericAliasr  r   r7   r>   rC   rT   r   r   rŽ   rL   r–   ry   r¥   rª   r­   r™   r²   r¶   r½   rÃ   rµ   rË   rÏ   rÎ   rÒ   rà   rä   ré   rí   rü   rj   Úpropertyr�   r  r×   rš   r  Ú__annotate_func__Ú__static_attributes__Ú__classdictcell__Ú__classcell__©r&   rn   s   @@r'   r   r   G   s  ù‡ € ñ|ð~ €Oñ &1°×1CÑ1CÓ%DÐõô(ò*ò
$ò,ò*
ò(8÷1ò 1òf&ò<4ò>%÷ ò ò6&ò44ò8%òòòEò	!òL&ò\	#ò	$òòT0òl"ò
"ò<ò ò@òð& ñó ðò!ð ñ ó ð ò9ò
<÷_ … r)   c                   ód   a a€ ] tR tRt oRtR
V 3R lltV 3R ltR tR tV 3R lt	R t
R	tVtV ;t# )r   i\  z>Linear operator defined in terms of user-specified operations.c                ó†   <€ \         SV `  WQV4       RV n        W n        W0n        W`n        W@n        V P                  4        R # )Nru   )r   r7   r#   Ú"_CustomLinearOperator__matvec_implÚ#_CustomLinearOperator__rmatvec_implÚ#_CustomLinearOperator__rmatmat_implÚ"_CustomLinearOperator__matmat_implrT   )	r5   r2   rL   r–   rª   r,   r­   r6   r&   s	   &&&&&&&&€r'   r7   Ú_CustomLinearOperator.__init___  s?   ø€ ô 	‰Ñ˜ rÔ*àˆŒ	à#ÔØ%ÔØ%ÔØ#Ôà×ÑÖr)   c                ó`   <€ V P                   e   V P                  V4      # \        SV `	  V4      # rì   )r$  r   r   ©r5   r]   r&   s   &&€r'   r   Ú_CustomLinearOperator._matmatt  s/   ø€ Ø×ÑÒ)Ø×%Ñ% aÓ(Ð(ä‘7‘? 1Ó%Ð%r)   c                ó$   € V P                  V4      # rì   )r!  r’   s   &&r'   r   Ú_CustomLinearOperator._matvecz  s   € Ø×!Ñ! !Ó$Ð$r)   c                óZ   € V P                   pVf   \        R4      hV P                  V4      # )Nzrmatvec is not defined)r"  rœ   )r5   re   Úfuncs   && r'   ry   Ú_CustomLinearOperator._rmatvec}  s/   € Ø×"Ñ"ˆØŠ<Ü%Ð&>Ó?Ð?Ø×"Ñ" 1Ó%Ð%r)   c                ó`   <€ V P                   e   V P                  V4      # \        SV `	  V4      # rì   )r#  r   r™   r'  s   &&€r'   r™   Ú_CustomLinearOperator._rmatmatƒ  s0   ø€ Ø×ÑÒ*Ø×&Ñ& qÓ)Ð)ä‘7Ñ# AÓ&Ð&r)   c           
     ó
  € \        . V P                  R R OV P                  R,          NV P                  R,          N5V P                  V P                  V P                  V P
                  V P                  V P                  R7      # )N)r2   rL   r–   rª   r­   r,   r6   r¡   rH   )r   r2   r"  r!  r#  r$  r,   r4   rè   s   &r'   rš   Ú_CustomLinearOperator._adjoint‰  sm   € Ü$ØD�D—J‘J˜s �OÐD T§Z¡Z°¥^ÐD°T·Z±ZÀµ^ÑDØ×&Ñ&Ø×&Ñ&Ø×&Ñ&Ø×&Ñ&Ø—*‘*Ø�x‰xô
ð 	
r)   )Ú__matmat_implÚ__matvec_implÚ__rmatmat_implÚ__rmatvec_implr#   )NNNNN)rú   r  r  r  r  r7   r   r   ry   r™   rš   r  r  r  r  s   @@r'   r   r   \  s+   ù‡ € ÙH÷õ*&ò%ò&õ'÷	
ò 	
r)   r   c                   óR   a a€ ] tR tRt oRtR	V 3R lltR tR tR tR t	Rt
VtV ;t# )
r	  i•  z$Adjoint of arbitrary Linear Operatorc                óÈ   <€ . VP                   R R OVP                   R,          NVP                   R,          N5p\        SV `	  VP                  W24       Wn        V3V n        R # ©Nr¡   rH   ©r2   r   r7   r,   ÚAr#   ©r5   r:  r6   r2   r&   s   &&& €r'   r7   Ú_AdjointLinearOperator.__init__˜  óR   ø€ Ø9�!—'‘'˜#˜2�,Ð9 §¡¨¥Ð9¨Q¯W©W°R­[Ñ9ˆÜ‰Ñ˜Ÿ™ %Ô,ØŒØ�DˆŽ	r)   c                ó8   € V P                   P                  V4      # rì   )r:  ry   r’   s   &&r'   r   Ú_AdjointLinearOperator._matvecž  ó   € Ø�v‰v�‰˜qÓ!Ð!r)   c                ó8   € V P                   P                  V4      # rì   )r:  r   r’   s   &&r'   ry   Ú_AdjointLinearOperator._rmatvec¡  ó   € Ø�v‰v�~‰~˜aÓ Ð r)   c                ó8   € V P                   P                  V4      # rì   )r:  r™   r’   s   &&r'   r   Ú_AdjointLinearOperator._matmat¤  r@  r)   c                ó8   € V P                   P                  V4      # rì   )r:  r   r’   s   &&r'   r™   Ú_AdjointLinearOperator._rmatmat§  rC  r)   ©r:  r#   rì   ©rú   r  r  r  r  r7   r   ry   r   r™   r  r  r  r  s   @@r'   r	  r	  •  s&   ù‡ € Ù.÷ò"ò!ò"÷!ò !r)   r	  c                   óR   a a€ ] tR tRt oRtR	V 3R lltR tR tR tR t	Rt
VtV ;t# )
r  i«  z*Transposition of arbitrary Linear Operatorc                óÈ   <€ . VP                   R R OVP                   R,          NVP                   R,          N5p\        SV `	  VP                  W24       Wn        V3V n        R # r8  r9  r;  s   &&& €r'   r7   Ú"_TransposedLinearOperator.__init__®  r=  r)   c                óœ   € V P                   P                  V P                  P                  V P                   P                  V4      4      4      # rì   )r4   Úconjr:  ry   r’   s   &&r'   r   Ú!_TransposedLinearOperator._matvec´  ó/   € Ø�x‰x�}‰}˜TŸV™VŸ_™_¨T¯X©X¯]©]¸1Ó-=Ó>Ó?Ð?r)   c                óœ   € V P                   P                  V P                  P                  V P                   P                  V4      4      4      # rì   )r4   rN  r:  r   r’   s   &&r'   ry   Ú"_TransposedLinearOperator._rmatvec·  ó/   € Ø�x‰x�}‰}˜TŸV™VŸ^™^¨D¯H©H¯M©M¸!Ó,<Ó=Ó>Ð>r)   c                óœ   € V P                   P                  V P                  P                  V P                   P                  V4      4      4      # rì   )r4   rN  r:  r™   r’   s   &&r'   r   Ú!_TransposedLinearOperator._matmatº  rP  r)   c                óœ   € V P                   P                  V P                  P                  V P                   P                  V4      4      4      # rì   )r4   rN  r:  r   r’   s   &&r'   r™   Ú"_TransposedLinearOperator._rmatmat½  rS  r)   rH  rì   rI  r  s   @@r'   r  r  «  s(   ù‡ € Ù4÷ò@ò?ò@÷?ò ?r)   r  c                ó¸   € Vf   \         MTpVf   . pV  F8  pVf   K	  \        VR4      '       g   K  VP                  VP                  4       K:  	  \	        VRV/ # )z;Returns the promoted dtype from input dtypes and operators.r,   r6   )r	   r›   Úappendr,   r   )Ú	operatorsÚdtypesr6   r%   s   &&& r'   Ú
_get_dtyper\  Á  sT   € à’j� b€BØ‚~ØˆÛˆØŒ?œw s¨G×4Ô4Ø�M‰M˜#Ÿ)™)Ö$ñ ô ˜6Ð) bÑ)Ð)r)   c                   óX   a a€ ] tR tRt oRtR
V 3R lltR tR tR tR t	R t
R	tVtV ;t# )rã   iÌ  zRepresenting ``A + B``c                ól  <€ \        V\        4      '       d   \        V\        4      '       g   \        R 4      hVP                  Ev rEpVP                  Ev rxp	WV3W‰38w  d   \        RV RV R24      h\        P
                  ! WG4      p
W3V n        \        SV `!  \        W.VR7      . V
OVNVN5V4       R# )ú)both operands have to be a LinearOperatorzcannot add ú and ú: shape mismatchr¹   N)
rv   r   r1   r2   rP   r€   r#   r   r7   r\  ©r5   r:  ÚBr6   ÚA_broadcast_dimsÚA_MÚA_NÚB_broadcast_dimsÚB_MÚB_Nr�   r&   s   &&&&       €r'   r7   Ú_SumLinearOperator.__init__Ï  s´   ø€ Ü˜!œ^×,Ò,´J¸qÄ.×4QÒ4QÜÐHÓIÐIØ&'§g¡gÑ#Ð	 Ø&'§g¡gÑ#Ð	 Øˆ:˜#˜Ô#Ü˜{¨1¨#¨U°1°#Ð5EÐFÓGÐGÜ×/Ò/Ð0@ÓSÐØ�FˆŒ	Ü‰Ñœ Q F¨rÔ2Ð4QÐ6FÐ4QÈÐ4QÈSÑ4QÐSUÖVr)   c                ó”   € V P                   ^ ,          P                  V4      V P                   ^,          P                  V4      ,           # ©rb   ©r#   rL   r’   s   &&r'   r   Ú_SumLinearOperator._matvecÚ  ó3   € Ø�y‰y˜�|×"Ñ" 1Ó%¨¯	©	°!­×(;Ñ(;¸AÓ(>Õ>Ð>r)   c                ó”   € V P                   ^ ,          P                  V4      V P                   ^,          P                  V4      ,           # rl  ©r#   r–   r’   s   &&r'   ry   Ú_SumLinearOperator._rmatvecÝ  ó3   € Ø�y‰y˜�|×#Ñ# AÓ&¨¯©°1­×)=Ñ)=¸aÓ)@Õ@Ð@r)   c                ó”   € V P                   ^ ,          P                  V4      V P                   ^,          P                  V4      ,           # rl  ©r#   r­   r’   s   &&r'   r™   Ú_SumLinearOperator._rmatmatà  rs  r)   c                ó”   € V P                   ^ ,          P                  V4      V P                   ^,          P                  V4      ,           # rl  ©r#   rª   r’   s   &&r'   r   Ú_SumLinearOperator._matmatã  ro  r)   c                óX   € V P                   w  rVP                  VP                  ,           # rì   ©r#   r�   ©r5   r:  rc  s   &  r'   rš   Ú_SumLinearOperator._adjointæ  ó   € Ø�y‰y‰ˆØ�s‰s�Q—S‘S�yÐr)   ©r#   rì   ©rú   r  r  r  r  r7   r   ry   r™   r   rš   r  r  r  r  s   @@r'   rã   rã   Ì  s.   ù‡ € Ù ÷	Wò?òAòAò?÷ò r)   rã   c                   óX   a a€ ] tR tRt oRtR
V 3R lltR tR tR tR t	R t
R	tVtV ;t# )rÆ   ië  zRepresenting ``A @ B``c                óf  <€ \        V\        4      '       d   \        V\        4      '       g   \        R 4      hVP                  Ev rEpVP                  Ev rxp	Wh8w  d   \        RV RV R24      h\        P
                  ! WG4      p
\        SV `  \        W.VR7      . V
OVNV	N5V4       W3V n	        R# )r_  zcannot multiply r`  ra  r¹   N)
rv   r   r1   r2   rw   r€   r   r7   r\  r#   rb  s   &&&&       €r'   r7   Ú_ProductLinearOperator.__init__î  s®   ø€ Ü˜!œ^×,Ò,´J¸qÄ.×4QÒ4QÜÐHÓIÐIØ&'§g¡gÑ#Ð	 Ø&'§g¡gÑ#Ð	 ØŒ:ÜÐ/°¨s°%¸°sÐ:JÐKÓLÐLÜ×.Ò.Ð/?ÓRÐÜ‰Ñœ Q F¨rÔ2Ð4QÐ6FÐ4QÈÐ4QÈSÑ4QÐSUÔVØ�FˆŽ	r)   c                ó†   € V P                   ^ ,          P                  V P                   ^,          P                  V4      4      # rl  rm  r’   s   &&r'   r   Ú_ProductLinearOperator._matvecù  ó.   € Ø�y‰y˜�|×"Ñ" 4§9¡9¨Q¥<×#6Ñ#6°qÓ#9Ó:Ð:r)   c                ó†   € V P                   ^,          P                  V P                   ^ ,          P                  V4      4      # ©rç   rq  r’   s   &&r'   ry   Ú_ProductLinearOperator._rmatvecü  ó.   € Ø�y‰y˜�|×#Ñ# D§I¡I¨a¥L×$8Ñ$8¸Ó$;Ó<Ð<r)   c                ó†   € V P                   ^,          P                  V P                   ^ ,          P                  V4      4      # rˆ  ru  r’   s   &&r'   r™   Ú_ProductLinearOperator._rmatmatÿ  rŠ  r)   c                ó†   € V P                   ^ ,          P                  V P                   ^,          P                  V4      4      # rl  rx  r’   s   &&r'   r   Ú_ProductLinearOperator._matmat  r†  r)   c                óX   € V P                   w  rVP                  VP                  ,          # rì   r{  r|  s   &  r'   rš   Ú_ProductLinearOperator._adjoint  r~  r)   r  rì   r€  r  s   @@r'   rÆ   rÆ   ë  s+   ù‡ € Ù ÷	ò;ò=ò=ò;÷ò r)   rÆ   c                   óX   a a€ ] tR tRt oRtR
V 3R lltR tR tR tR t	R t
R	tVtV ;t# )rº   i
  zRepresenting ``alpha * A``c                óT  <€ \        V\        4      '       g   \        R 4      h\        P                  ! V4      '       g   \        R4      h\        V\
        4      '       d   VP                  w  rW$,          p\        V.V.VR7      p\        SV `%  WQP                  V4       W3V n        R# )úLinearOperator expected as Azscalar expected as alphar¹   N)rv   r   r1   rw   Úisscalarrº   r#   r\  r   r7   r2   )r5   r:  Úalphar6   Úalpha_originalr,   r&   s   &&&&  €r'   r7   Ú_ScaledLinearOperator.__init__  s‰   ø€ Ü˜!œ^×,Ò,ÜÐ;Ó<Ð<Ü�{Š{˜5×!Ò!ÜÐ7Ó8Ð8Ü�aÔ.×/Ò/Ø !§¡ÑˆAð Õ*ˆEä˜A˜3  ¨BÔ/ˆÜ‰Ñ˜§¡¨Ô,Ø�JˆŽ	r)   c                óv   € V P                   ^,          V P                   ^ ,          P                  V4      ,          # rˆ  rm  r’   s   &&r'   r   Ú_ScaledLinearOperator._matvec  ó(   € Ø�y‰y˜�|˜dŸi™i¨�l×1Ñ1°!Ó4Õ4Ð4r)   c                ó’   € V P                   ^,          P                  4       V P                   ^ ,          P                  V4      ,          # rˆ  )r#   Ú	conjugater–   r’   s   &&r'   ry   Ú_ScaledLinearOperator._rmatvec   ó1   € Ø�y‰y˜�|×%Ñ%Ó'¨$¯)©)°A­,×*>Ñ*>¸qÓ*AÕAÐAr)   c                ó’   € V P                   ^,          P                  4       V P                   ^ ,          P                  V4      ,          # rˆ  )r#   rœ  r­   r’   s   &&r'   r™   Ú_ScaledLinearOperator._rmatmat#  rž  r)   c                óv   € V P                   ^,          V P                   ^ ,          P                  V4      ,          # rˆ  rx  r’   s   &&r'   r   Ú_ScaledLinearOperator._matmat&  rš  r)   c                ó`   € V P                   w  rVP                  VP                  4       ,          # rì   )r#   r�   rœ  )r5   r:  r•  s   &  r'   rš   Ú_ScaledLinearOperator._adjoint)  s#   € Ø—9‘9‰ˆØ�s‰s�U—_‘_Ó&Õ&Ð&r)   r  rì   r€  r  s   @@r'   rº   rº   
  s-   ù‡ € Ù$÷ò 5òBòBò5÷'ò 'r)   rº   c                   ó^   a a€ ] tR tRt oRtRV 3R lltR tR tR tR t	R t
R	 tR
tVtV ;t# )rÝ   i.  zRepresenting ``A ** p``c                ób  <€ \        V\        4      '       g   \        R 4      hVP                  R,          VP                  R,          8w  d   RV: 2p\        V4      h\	        V4      '       d   V^ 8  d   \        R4      h\
        SV `  \        V.VR7      VP                  V4       W3V n        R# )r“  z7square core-dimensions of LinearOperator expected, got z"non-negative integer expected as pr¹   Nr¡   rH   )	rv   r   r1   r2   r   r   r7   r\  r#   )r5   r:  rß   r6   rŒ   r&   s   &&&& €r'   r7   Ú_PowerLinearOperator.__init__1  sŒ   ø€ Ü˜!œ^×,Ò,ÜÐ;Ó<Ð<Ø�7‰7�2�;˜!Ÿ'™' "�+Ô%ØKÈAÉ5ÐQˆCÜ˜S“/Ð!Ü˜�|Š|˜q 1œuÜÐAÓBÐBä‰Ñœ Q C¨BÔ/°·±¸"Ô=Ø�FˆŽ	r)   c                ór   € \        V4      p\        V P                  ^,          4       F  pV! V4      pK  	  V# rˆ  )r   r[   r#   )r5   Úfunre   Úresr^   s   &&&  r'   Ú_powerÚ_PowerLinearOperator._power=  s0   € Ü�a‹jˆÜ�t—y‘y •|Ö$ˆAÙ�c“(ŠCñ %àˆ
r)   c                ó\   € V P                  V P                  ^ ,          P                  V4      # rl  )r«  r#   rL   r’   s   &&r'   r   Ú_PowerLinearOperator._matvecC  ó!   € Ø�{‰{˜4Ÿ9™9 Q�<×.Ñ.°Ó2Ð2r)   c                ó\   € V P                  V P                  ^ ,          P                  V4      # rl  )r«  r#   r–   r’   s   &&r'   ry   Ú_PowerLinearOperator._rmatvecF  ó!   € Ø�{‰{˜4Ÿ9™9 Q�<×/Ñ/°Ó3Ð3r)   c                ó\   € V P                  V P                  ^ ,          P                  V4      # rl  )r«  r#   r­   r’   s   &&r'   r™   Ú_PowerLinearOperator._rmatmatI  r²  r)   c                ó\   € V P                  V P                  ^ ,          P                  V4      # rl  )r«  r#   rª   r’   s   &&r'   r   Ú_PowerLinearOperator._matmatL  r¯  r)   c                óD   € V P                   w  rVP                  V,          # rì   r{  )r5   r:  rß   s   &  r'   rš   Ú_PowerLinearOperator._adjointO  s   € Ø�y‰y‰ˆØ�s‰s�A�vˆr)   r  rì   )rú   r  r  r  r  r7   r«  r   ry   r™   r   rš   r  r  r  r  s   @@r'   rÝ   rÝ   .  s0   ù‡ € Ù!÷
òò3ò4ò4ò3÷ò r)   rÝ   c                   óF   a a€ ] tR tRt oRtRV 3R lltR tR tRtVt	V ;t
# )ÚMatrixLinearOperatoriT  z8Operator defined by a matrix `A` which implements ``@``.c                ó|   <€ \         SV `  VP                  VP                  V4       Wn        R V n        V3V n        R # rì   )r   r7   r,   r2   r:  Ú_MatrixLinearOperator__adjr#   )r5   r:  r6   r&   s   &&&€r'   r7   ÚMatrixLinearOperator.__init__W  s1   ø€ Ü‰Ñ˜Ÿ™ !§'¡'¨2Ô.ØŒØˆŒ
Ø�DˆŽ	r)   c                ó(   € V P                   V,          # rì   )r:  r©   s   &&r'   r   ÚMatrixLinearOperator._matmat]  s   € Ø�v‰v˜�zÐr)   c                ó‚   € V P                   f'   \        V P                  V P                  R7      V n         V P                   # )Nr¹   )r¼  Ú_AdjointMatrixOperatorr:  r4   rè   s   &r'   rš   ÚMatrixLinearOperator._adjoint`  s,   € Ø�:‰:ÒÜ/°·±¸4¿8¹8ÔDˆDŒJØ�z‰zÐr)   )r:  Ú__adjr#   rì   )rú   r  r  r  r  r7   r   rš   r  r  r  r  s   @@r'   rº  rº  T  s   ù‡ € ÙB÷ò÷ò r)   rº  c                   ó@   a a€ ] tR tRt oRtRV 3R lltR tRtVtV ;t	# )rÁ  if  z5Representing ``A.H``, for `MatrixLinearOperator` `A`.c                ó  <€ Vf   \         MTpVP                  ^8”  d8   \        V4      '       d   \        P                  ! VRR4      pMVP
                  pMVP                  p\        SV `!  VP                  V4      VR7       V3V n
        R # )Nr¹   rH   r¡   )r	   r3   r   r   ÚswapaxesrÙ   r×   r   r7   rN  r#   )r5   r:  r6   ÚA_Tr&   s   &&& €r'   r7   Ú_AdjointMatrixOperator.__init__i  si   ø€ Øš*�Y¨"ˆØ�6‰6�AŒ:Ü˜�{Š{Ü—o’o a¨¨RÓ0‘à—d‘d‘à—#‘#ˆCÜ‰Ñ˜Ÿ™ ›¨"ÐÔ-Ø�DˆŽ	r)   c                óR   € \        V P                  ^ ,          V P                  R7      # )rb   r¹   )rº  r#   r4   rè   s   &r'   rš   Ú_AdjointMatrixOperator._adjointu  s   € Ü# D§I¡I¨a¥L°T·X±XÔ>Ð>r)   r  rì   )
rú   r  r  r  r  r7   rš   r  r  r  r  s   @@r'   rÁ  rÁ  f  s   ù‡ € Ù?÷
÷?ò ?r)   rÁ  c                   óT   a a€ ] tR tRt oR	V 3R lltR tR tR tR tR t	Rt
VtV ;t# )
ÚIdentityOperatoriy  c                ó(   <€ \         SV `  W!V4       R # rì   )r   r7   )r5   r2   r,   r6   r&   s   &&&&€r'   r7   ÚIdentityOperator.__init__z  s   ø€ Ü‰Ñ˜ rÖ*r)   c                ó   € V# rì   ru   r’   s   &&r'   r   ÚIdentityOperator._matvec}  ó   € Øˆr)   c                ó   € V# rì   ru   r’   s   &&r'   ry   ÚIdentityOperator._rmatvec€  rÑ  r)   c                ó   € V# rì   ru   r’   s   &&r'   r™   ÚIdentityOperator._rmatmatƒ  rÑ  r)   c                ó   € V# rì   ru   r’   s   &&r'   r   ÚIdentityOperator._matmat†  rÑ  r)   c                ó   € V # rì   ru   rè   s   &r'   rš   ÚIdentityOperator._adjoint‰  s   € Øˆr)   ru   ©NN)rú   r  r  r  r7   r   ry   r™   r   rš   r  r  r  r  s   @@r'   rÌ  rÌ  y  s(   ù‡ € ÷+òòòò÷ò r)   rÌ  c                óv  € \        V \        4      '       d   V # \        V 4      '       do   \        V \        P                  4      '       gO   \        V 4      p\        V 4      '       d   \        '       g   M\        P                  ! V ^VR7      p \        WR7      # \        V 4      '       d   \        V 4      # \        V \        P                  4      '       d6   \        P                  ! \        P                  ! V 4      4      p \        V 4      # \        V R4      '       d–   \        V R4      '       d„   RpRpRp\        V R4      '       d   V P                  p\        V R4      '       d   V P                   p\        V R4      '       d   V P"                  p\        V P$                  V P&                  W#VR	7      # \)        R
4      h)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>
)r3   r6   r¹   r2   rL   Nr–   r­   r,   )r–   r­   r,   ztype not understood)rv   r   r   rw   rx   r   r   r   rP   Ú
atleast_ndrº  r   Ú
atleast_2drK   r›   r–   r­   r,   r2   rL   rN   )r:  r6   r–   r­   r,   s   &    r'   r   r   �  sI  € ôJ �!”^×$Ò$Øˆô ˜×Ò¤:¨a´·±×#;Ò#;Ü˜QÓˆÜ! !×$Ò$¯_«_Øä—’˜q q¨RÔ0ˆAÜ# AÔ-Ð-ä�‡{‚{Ü# AÓ&Ð&ä�!”R—Y‘Y×ÒÜ�MŠMœ"Ÿ*š* Q›-Ó(ˆÜ# AÓ&Ð&äˆq�'×Òœw q¨(×3Ò3ØˆØˆØˆä�1�i× Ò Ø—i‘iˆGÜ�1�i× Ò Ø—i‘iˆGÜ�1�g×ÒØ—G‘GˆEÜØ�G‰G�Q—X‘X wÀuô
ð 	
ô Ð)Ó
*Ð*r)   rÚ  )+r  r|   r  r   Únumpyrw   Úscipyr   Úscipy._externalr   rP   Úscipy._lib._array_apir   r   r   r   r   r	   r
   r   r   r   Úscipy.sparser   Úscipy.sparse._sputilsr   r   r   r   Ú__all__r   r   r	  r  r\  rã   rÆ   rº   rÝ   rº  rÁ  rÌ  r   ru   r)   r'   Ú<module>rå     sþ   ðñ*óX 
Û Û ã å Ý 2÷÷ ÷ õ "ß RÓ RàÐ/Ð
0€ñ Ó÷Q<ð Q<ó ðQ<ôh6
˜Nô 6
ôr!˜^ô !ô,? ô ?ô,*ô˜ô ô>˜^ô ô>!'˜Nô !'ôH#˜>ô #ôL˜>ô ô$?Ð1ô ?ô&�~ô ñ( ÓñF+ó òF+r)   