o 5ήc5@sddlZddlZddlmZddlmZddlmZddl m Z m Z ddl m Z ejdr7dd lmZd Znd Zdd lmZejjjZd gZddZddZ  ddd ZdS)N)_arpack)eigsh)check_random_state)LinearOperatoraslinearoperator)lobpcgSCIPY_USE_PROPACK)_svdpTF)svdsvdscCs |jSN)TconjxrG/tmp/pip-target-vg8gfxp4/lib/python/scipy/sparse/linalg/_eigen/_svds.py_herms rc  Csrt|}hd} || vrtd| dt|}t|jtjs0t|jtjs0d} t| t |j dkr>d} t| |dkrGt |j nt |j d} t ||ks_d|kr^| ksend } t| t |}|d kr|durt ||ks||krt |j ksnd } t| t |}|dkst |sd } t| t|}t|}d dh} || vrtd| d|durt|}t|jtjst|jtjsd} t| |dkr|j dfnt |j f}|j |krd|d} t| |dur t ||ks|dkr d} t| |durt |n|}hd}||vr)td|dt| } |||||||||| f S)N>arpackrpropackzsolver must be one of .z6`A` must be of floating or complex floating data type.rz`A` must not be empty.rrz9`k` must be an integer satisfying `0 < k < min(A.shape)`.rz=`ncv` must be an integer satisfying `k < ncv < min(A.shape)`.z2`tol` must be a non-negative floating point value.LMSMz`which` must be in z7`v0` must be of floating or complex floating data type.z`v0` must have shape z%`maxiter` must be a positive integer.>FTuvhz%`return_singular_vectors` must be in )strlower ValueErrorrnp issubdtypedtypecomplexfloatingfloatingprodshapeminintisfinitefloatupper atleast_1dr)Akncvtolwhichv0maxiterreturn_singularsolver random_statesolversmessagekmaxwhichsr% rs_optionsrrr_ivsj  "(     " r;rrc ! sp| du} t|||||||||| } | \ }}}}}}}}}} |dk} |j\}}||kr9|j|j|j|jd}n#|j|j|j|jd}t|dd}|dur\|t |dgj }fdd}fd d }t ||j |t |jt |jfd }|d kr|dkr|durt |d }n| rtjdt |j|}n | jt |j|fd}t|||d|| d\}}tj|\}}n|dkrtstd|dv}|dv}|dk}t|||d|d|||||| d }|\}}}}|ddd}|dddddf}|ddd}|r |nd}|r|nd}|r|||fS|S|dks(|durI|dur:| s:| jt |jfd}t|||d||||d\}}|}|s^t|ddd}|dddSt|ddd\}}}|dddddf}|ddd}|ddd}|dv}|dv}|r|r|t|nd} |rt|nd}| }n|sd}|r|t|nd}|||fS)a2 Partial singular value decomposition of a sparse matrix. Compute the largest or smallest `k` singular values and corresponding singular vectors of a sparse matrix `A`. The order in which the singular values are returned is not guaranteed. In the descriptions below, let ``M, N = A.shape``. Parameters ---------- A : ndarray, sparse matrix, or LinearOperator Matrix to decompose of a floating point numeric dtype. k : int, default: 6 Number of singular values and singular vectors to compute. Must satisfy ``1 <= k <= kmax``, where ``kmax=min(M, N)`` for ``solver='propack'`` and ``kmax=min(M, N) - 1`` otherwise. ncv : int, optional When ``solver='arpack'``, this is the number of Lanczos vectors generated. See :ref:`'arpack' ` for details. When ``solver='lobpcg'`` or ``solver='propack'``, this parameter is ignored. tol : float, optional Tolerance for singular values. Zero (default) means machine precision. which : {'LM', 'SM'} Which `k` singular values to find: either the largest magnitude ('LM') or smallest magnitude ('SM') singular values. v0 : ndarray, optional The starting vector for iteration; see method-specific documentation (:ref:`'arpack' `, :ref:`'lobpcg' `), or :ref:`'propack' ` for details. maxiter : int, optional Maximum number of iterations; see method-specific documentation (:ref:`'arpack' `, :ref:`'lobpcg' `), or :ref:`'propack' ` for details. return_singular_vectors : {True, False, "u", "vh"} Singular values are always computed and returned; this parameter controls the computation and return of singular vectors. - ``True``: return singular vectors. - ``False``: do not return singular vectors. - ``"u"``: if ``M <= N``, compute only the left singular vectors and return ``None`` for the right singular vectors. Otherwise, compute all singular vectors. - ``"vh"``: if ``M > N``, compute only the right singular vectors and return ``None`` for the left singular vectors. Otherwise, compute all singular vectors. If ``solver='propack'``, the option is respected regardless of the matrix shape. solver : {'arpack', 'propack', 'lobpcg'}, optional The solver used. :ref:`'arpack' `, :ref:`'lobpcg' `, and :ref:`'propack' ` are supported. Default: `'arpack'`. random_state : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional Pseudorandom number generator state used to generate resamples. If `random_state` is ``None`` (or `np.random`), the `numpy.random.RandomState` singleton is used. If `random_state` is an int, a new ``RandomState`` instance is used, seeded with `random_state`. If `random_state` is already a ``Generator`` or ``RandomState`` instance then that instance is used. options : dict, optional A dictionary of solver-specific options. No solver-specific options are currently supported; this parameter is reserved for future use. Returns ------- u : ndarray, shape=(M, k) Unitary matrix having left singular vectors as columns. s : ndarray, shape=(k,) The singular values. vh : ndarray, shape=(k, N) Unitary matrix having right singular vectors as rows. Notes ----- This is a naive implementation using ARPACK or LOBPCG as an eigensolver on ``A.conj().T @ A`` or ``A @ A.conj().T``, depending on which one is more efficient, followed by the Rayleigh-Ritz method as postprocessing; see https://w.wiki/4zms Alternatively, the PROPACK solver can be called. ``form="array"`` Choices of the input matrix ``A`` numeric dtype may be limited. Only ``solver="lobpcg"`` supports all floating point dtypes real: 'np.single', 'np.double', 'np.longdouble' and complex: 'np.csingle', 'np.cdouble', 'np.clongdouble'. The ``solver="arpack"`` supports only 'np.single', 'np.double', and 'np.cdouble'. Examples -------- Construct a matrix ``A`` from singular values and vectors. >>> from scipy.stats import ortho_group >>> from scipy.sparse import csc_matrix, diags >>> from scipy.sparse.linalg import svds >>> rng = np.random.default_rng() >>> orthogonal = csc_matrix(ortho_group.rvs(10, random_state=rng)) >>> s = [0.0001, 0.001, 3, 4, 5] # singular values >>> u = orthogonal[:, :5] # left singular vectors >>> vT = orthogonal[:, 5:].T # right singular vectors >>> A = u @ diags(s) @ vT With only three singular values/vectors, the SVD approximates the original matrix. >>> u2, s2, vT2 = svds(A, k=3) >>> A2 = u2 @ np.diag(s2) @ vT2 >>> np.allclose(A2, A.toarray(), atol=1e-3) True With all five singular values/vectors, we can reproduce the original matrix. >>> u3, s3, vT3 = svds(A, k=5) >>> A3 = u3 @ np.diag(s3) @ vT3 >>> np.allclose(A3, A.toarray()) True The singular values match the expected singular values, and the singular vectors are as expected up to a difference in sign. >>> (np.allclose(s3, s) and ... np.allclose(np.abs(u3), np.abs(u.toarray())) and ... np.allclose(np.abs(vT3), np.abs(vT.toarray()))) True The singular vectors are also orthogonal. >>> (np.allclose(u3.T @ u3, np.eye(5)) and ... np.allclose(vT3 @ vT3.T, np.eye(5))) True NrFTr!rc |Sr rr)XH_dotX_dotrr matvec_XH_X zsvds..matvec_XH_Xcr=r rr)XH_matX_matmatrr matmat_XH_XrAzsvds..matmat_XH_X)matvecr!matmatr%r)r4)size)r/r2largestrz`solver='propack'` is opt-in due to potential issues on Windows, it can be enabled by setting the `SCIPY_USE_PROPACK` environment variable before importing scipy>Tr>Trr) r-r/r0r2 compute_u compute_virl_moder8r1r5rGr)r-r/r2r.r0r1) compute_uv overwrite_a) full_matricesrP)r;r%rErFrmatvecrmatmatgetattrdotrzerosr!rr&reshaperandom RandomStaterandnuniformrlinalgqr HAS_PROPACKrr rr r)!r,r-r.r/r0r1r2return_singular_vectorsr4r5options rs_was_NoneargsrKnm transposer!r@rDXH_XX_eigvecjobujobvrNresrsrAvu_tmpr)r>rBr?rCrr hs        ) r<NrrNNTrNN)osnumpyrrrrscipy._lib._utilrscipy.sparse.linalg._interfacerr!scipy.sparse.linalg._eigen.lobpcgrenvirongetscipy.sparse.linalg._svdpr r^ scipy.linalgr timingnbxr! arpack_int__all__rr;r rrrrs(        O