Bpj2SrSr/SQrSSKrSSKJr SSKJrJ r SSK J r J r SS K Jr SS KJr "S S \5rS r"SS\\ 5r"SS\\5rg)z&Compressed Sparse Column matrix formatzrestructuredtext en) csc_array csc_matrixisspmatrix_cscN)spmatrix)_spbasesparray) csr_tocsc expandptr)upcast) _cs_matrixcZ\rSrSrSrSSjr\R R\lSrSSjr \RR\ lSSjr \RR\ lSr \ RR\ lS r S rS rS rS rSrSrSr\S5rSrg) _csc_basecscNcUbUS:wa [S5eURup4URURURUR 4XC4US9$)N)rrzvSparse arrays/matrices do not support an 'axes' parameter because swapping dimensions is the only logical permutation.copy) ValueErrorshape_csr_containerdataindicesindptr)selfaxesrMNs M/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/scipy/sparse/_csc.py transpose_csc_base.transposesi  LM Mzz""DIIt||$(KK$134&t#E Ec#@# UR5ShvN gN7fN)tocsr)rs r__iter___csc_base.__iter__!s::<s c4U(aUR5$U$r$r)rrs rtocsc_csc_base.tocsc$s 99; Kr"c FURup#URURUR4[ UR U5S9n[ R"US-US9n[ R"UR US9n[ R"UR [UR5S9n[X2URRUSS9URRUSS9URUUU5 URXvU4URSS9nSUlU$)N)maxvalrdtypeFr)rrT)r_get_index_dtyperrmaxnnznpemptyr r.r astyperrhas_sorted_indices) rrrr idx_dtyperrrAs rr%_csc_base.tocsr,sjj))4;; *E+.txx+;*= !a%y1((48895xxtzz(:;!++$$YU$;,,%%ie%<))      F #**5   $r"czURUR5upURn[R"[ U5URR S9n[XRU5 URXC45upVURS:gnXWnXgn[R"USS9nXXnXhnXV4$)Nr-r mergesort)kind) _swaprrr2r3lenr.r rrargsort) r major_dim minor_dim minor_indices major_indicesrowcolnz_maskinds rnonzero_csc_base.nonzeroEs $zz$**5  ]!34<<;M;MN )[[-8::}<=))q.lljj;/hhxr"cURup#[U5nUS:aX- nUS:dX:a[SUS35eURUS9R 5$)zMReturns a copy of row i of the matrix, as a (1 x n) CSR matrix (row vector). rindex () out of rangeminor)rint IndexError_get_submatrixr%rirrs r_getrow_csc_base._getrow^sbzz F q5 FA q5AFwqc89 9"""+1133r"cURup#[U5nUS:aX- nUS:dX:a[SUS35eURUSS9$)zSReturns a copy of column i of the matrix, as a (m x 1) CSC matrix (column vector). rrJrKT)majorr)rrNrOrPrQs r_getcol_csc_base._getcoljs[zz F q5 FA q5AFwqc89 9"""66r"c>URU5RUS9$)NrL)_major_index_fancyrPrrCrDs r_get_intXarray_csc_base._get_intXarrayvs!&&s+:::EEr"c~URS;aURX!SS9$URU5RUS9$)NrNTrVrMrrL)steprP _major_slicer[s r_get_intXslice_csc_base._get_intXsliceysC 88y &&S$&G G  %4434??r"c~URS;aURX!SS9$URUS9RU5$)Nr_Tr`rV)rarP _minor_slicer[s r_get_sliceXint_csc_base._get_sliceXint~sC 88y &&S$&G G"""-::3??r"cBURU5RU5$r$)rZrgr[s r_get_sliceXarray_csc_base._get_sliceXarrays&&s+88==r"cURUS9RU5nURS:aURUR5$U$)Nrfr)rP_minor_index_fancyndimreshaper)rrCrDress r_get_arrayXint_csc_base._get_arrayXintsC!!!,??D 88a<;;syy) ) r"cBURU5RU5$r$)rbrnr[s r_get_arrayXslice_csc_base._get_arrayXslices  %88==r"cUSUS4$)zBswap the members of x if this is a column-oriented matrix rrxs rr<_csc_base._swapstQqTzr"rx)NF)F)__name__ __module__ __qualname____firstlineno___formatr r__doc__r&r)r%rGr rSrWr\rcrhrkrrru staticmethodr<__static_attributes__rxr"rrrsG E ))11I  MM))EM.MM))EM.!((00GO 4 7F@ @ > > r"rc"[U[5$)a0Is `x` of csc_matrix type? .. warning:: SciPy sparse is shifting from a sparse matrix interface to a sparse array interface. In the next few releases we expect to deprecate the sparse matrix interface. For documentation of the matrix interface, see the :ref:`spmatrix interface docs `. For guidance on converting existing code to sparse arrays, see :ref:`Migration from spmatrix to sparray `. Parameters ---------- x object to check for being a csc matrix Returns ------- bool True if `x` is a csc matrix, False otherwise Examples -------- >>> from scipy.sparse import csc_array, csc_matrix, coo_matrix, isspmatrix_csc >>> isspmatrix_csc(csc_matrix([[5]])) True >>> isspmatrix_csc(csc_array([[5]])) False >>> isspmatrix_csc(coo_matrix([[5]])) False ) isinstancerrys rrrs@ a $$r"c\rSrSrSrSrg)ra Compressed Sparse Column array. This can be instantiated in several ways: csc_array(D) where D is a 2-D ndarray csc_array(S) with another sparse array or matrix S (equivalent to S.tocsc()) csc_array((M, N), [dtype]) to construct an empty array with shape (M, N) dtype is optional, defaulting to dtype='d'. csc_array((data, (row_ind, col_ind)), [shape=(M, N)]) where ``data``, ``row_ind`` and ``col_ind`` satisfy the relationship ``a[row_ind[k], col_ind[k]] = data[k]``. csc_array((data, indices, indptr), [shape=(M, N)]) is the standard CSC representation where the row indices for column i are stored in ``indices[indptr[i]:indptr[i+1]]`` and their corresponding values are stored in ``data[indptr[i]:indptr[i+1]]``. If the shape parameter is not supplied, the array dimensions are inferred from the index arrays. Attributes ---------- data : ndarray CSC format data array of the array indices : ndarray CSC format index array of the array indptr : ndarray CSC format index pointer array of the array has_sorted_indices : bool Whether indices are sorted has_canonical_format : bool Whether indices are sorted and no duplicate entries exist dtype : dtype Data type of the array shape : 2-tuple Shape of the array ndim : int Number of dimensions (this is always 2) format : str Three letter code for the format of the array storage, e.g. 'csc' nnz : int Number of values stored in the array size : int Number of values stored in the array T : csc_array The transpose of the array mT : csc_array The matrix transpose of the array Notes ----- Sparse arrays can be used in arithmetic operations: they support addition, subtraction, multiplication, division, and matrix power. Advantages of the CSC format - efficient arithmetic operations CSC + CSC, CSC * CSC, etc. - efficient column slicing - fast matrix vector products (CSR, BSR may be faster) Disadvantages of the CSC format - slow row slicing operations (consider CSR) - changes to the sparsity structure are expensive (consider LIL or DOK) Canonical format - Within each column, indices are sorted by row. - There are no duplicate entries. Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_array >>> csc_array((3, 4), dtype=np.int8).toarray() array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=int8) >>> row = np.array([0, 2, 2, 0, 1, 2]) >>> col = np.array([0, 0, 1, 2, 2, 2]) >>> data = np.array([1, 2, 3, 4, 5, 6]) >>> csc_array((data, (row, col)), shape=(3, 3)).toarray() array([[1, 0, 4], [0, 0, 5], [2, 3, 6]]) >>> indptr = np.array([0, 2, 3, 6]) >>> indices = np.array([0, 2, 2, 0, 1, 2]) >>> data = np.array([1, 2, 3, 4, 5, 6]) >>> csc_array((data, indices, indptr), shape=(3, 3)).toarray() array([[1, 0, 4], [0, 0, 5], [2, 3, 6]]) rxNr|r}r~rrrrxr"rrrsdr"rc\rSrSrSrSrg)ri$aL Compressed Sparse Column matrix. .. warning:: SciPy sparse is shifting from a sparse matrix interface to a sparse array interface. In the next few releases we expect to deprecate the sparse matrix interface. For documentation of the matrix interface, see the :ref:`spmatrix interface docs `. For guidance on converting existing code to sparse arrays, see :ref:`Migration from spmatrix to sparray `. This can be instantiated in several ways: csc_matrix(D) where D is a 2-D ndarray csc_matrix(S) with another sparse array or matrix S (equivalent to S.tocsc()) csc_matrix((M, N), [dtype]) to construct an empty matrix with shape (M, N) dtype is optional, defaulting to dtype='d'. csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)]) where ``data``, ``row_ind`` and ``col_ind`` satisfy the relationship ``a[row_ind[k], col_ind[k]] = data[k]``. csc_matrix((data, indices, indptr), [shape=(M, N)]) is the standard CSC representation where the row indices for column i are stored in ``indices[indptr[i]:indptr[i+1]]`` and their corresponding values are stored in ``data[indptr[i]:indptr[i+1]]``. If the shape parameter is not supplied, the matrix dimensions are inferred from the index arrays. Attributes ---------- data : ndarray CSC format data array of the matrix indices : ndarray CSC format index array of the matrix indptr : ndarray CSC format index pointer array of the matrix has_sorted_indices : bool Whether indices are sorted has_canonical_format : bool Whether indices are sorted and no duplicate entries exist dtype : dtype Data type of the matrix shape : 2-tuple Shape of the matrix ndim : int Number of dimensions (this is always 2) format : str Three letter code for the format of the matrix storage, e.g. 'csc' nnz : int Number of values stored in the matrix size : int Number of values stored in the matrix T : csc_matrix The transpose of the matrix mT : csc_matrix The matrix transpose Notes ----- Sparse matrices can be used in arithmetic operations: they support addition, subtraction, multiplication, division, and matrix power. Advantages of the CSC format - efficient arithmetic operations CSC + CSC, CSC * CSC, etc. - efficient column slicing - fast matrix vector products (CSR, BSR may be faster) Disadvantages of the CSC format - slow row slicing operations (consider CSR) - changes to the sparsity structure are expensive (consider LIL or DOK) Canonical format - Within each column, indices are sorted by row. - There are no duplicate entries. Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> csc_matrix((3, 4), dtype=np.int8).toarray() array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=int8) >>> row = np.array([0, 2, 2, 0, 1, 2]) >>> col = np.array([0, 0, 1, 2, 2, 2]) >>> data = np.array([1, 2, 3, 4, 5, 6]) >>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray() array([[1, 0, 4], [0, 0, 5], [2, 3, 6]]) >>> indptr = np.array([0, 2, 3, 6]) >>> indices = np.array([0, 2, 2, 0, 1, 2]) >>> data = np.array([1, 2, 3, 4, 5, 6]) >>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray() array([[1, 0, 4], [0, 0, 5], [2, 3, 6]]) rxNrrxr"rrr$smr"r)r __docformat____all__numpyr2_matrixr_baserr _sparsetoolsr r _sputilsr _compressedr rrrrrxr"rrs\,% 7#.#D DN %He 7ePn9nr"