_MhdZddlZddlmZmZmZmZmZm Z m Z m Z m Z ddl mZgdZGddeZGd d eZGd d eZid ddgdddgdddgdddgdddgdddgdddgd d!d"gd#d$d%gd&d'd(gd)d*d+gd,d-d.gd/d0d1gd2d3d4gd5d6d7gd8d9d:gd;dd?gd@dAgdBdCgdDZeejejejejejejejejejejej ej!ej"ej#ej$ej%ej&ej'gZ(dEZ)GdFdGZ*GdHdIZ+e*je+_dJZ,dKZ-dS)LzBase class for sparse matricesN) asmatrixcheck_reshape_kwargs check_shape get_sum_dtypeisdense isscalarlikematrix validateaxisgetdtype)spmatrix) isspmatrixissparsesparray SparseWarningSparseEfficiencyWarningceZdZdS)rN__name__ __module__ __qualname__R/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/sparse/_base.pyrrDrrceZdZdS)SparseFormatWarningNrrrrrrrrrceZdZdS)rNrrrrrrrrrcsczCompressed Sparse ColumncsrzCompressed Sparse RowdokzDictionary Of Keyslilz List of ListsdodzDictionary of DictionariesssszSymmetric Sparse Skylinecoo COOrdinatelbazLinpack BAndedegdz#Ellpack-itpack Generalized Diagonaldia DIAgonalbsr zBlock Sparse Rowmsr zModified compressed Sparse Rowbsc zBlock Sparse Columnmsc z!Modified compressed Sparse ColumnsskzSymmetric SKylinenskzNonsymmetric SKylinejadzJAgged DiagonalzUnsymmetric Sparse SkylinezVariable Block Row Undefined)ussvbrund2ceZdZdZdZdZdZedefdZ edZ edZ ed Z ed Z ed Zed Zed ZedZdddZedZdZdZdtdZedZedZdZdZdZdudZdudZedefdZedefd Z ede!fd!Z"ed"Z#ed#Z$ed$Z%d%Z&d&Z'd'Z(e(Z)d(Z*dvd*Z+d+Z,d,Z-d-Z.d.Z/dud/Z0dvd0Z1d1Z2d2Z3d3Z4d4Z5d5Z6d6Z7d7Z8dwd9Z9d:Z:d;Z;d<ZZ>d?Z?d@Z@dAZAdBZBdCZCdDZDdEZEdFZFdGZGdHZHdIZIdJZJdKZKdLZLdxdMZMdNZNdOZOdPZPdQZQdRZRdSZSdTZTdUZUdVZVdWZWdXZXdydYZYdzdZZZdzd[Z[eZje[_d\Z\d]Z]d^Z^d_Z_d`Z`d{daZad{dbZbdvdcZcdvddZddvdeZedvdfZfdvdgZgdydhZhdvdiZidjZjd|dkZkd|dlZldwdmZmdwdnZndwdoZodpZpdqZqd}dsZrdS)~_spbasez This class provides a base class for all sparse arrays. It cannot be instantiated. Most of the work is provided by subclasses. g333333$@rG)r"returnc*t|jSN)len_shapeselfs rndimz _spbase.ndimFs4;rcN|j}t|dkr d|dfn|S)Nr)rOrN)rQss r _shape_as_2dz_spbase._shape_as_2dJs) K VVq[[1R5zza/rcddlm}|S)Nr) bsr_array)_bsrrX)rQrXs r_bsr_containerz_spbase._bsr_containerO######rcddlm}|S)Nr) coo_array)_coor])rQr]s r_coo_containerz_spbase._coo_containerTr[rcddlm}|S)Nr) csc_array)_cscra)rQras r_csc_containerz_spbase._csc_containerYr[rcddlm}|S)Nr) csr_array)_csrre)rQres r_csr_containerz_spbase._csr_container^r[rcddlm}|S)Nr) dia_array)_diari)rQris r_dia_containerz_spbase._dia_containercr[rcddlm}|S)Nr) dok_array)_dokrm)rQrms r_dok_containerz_spbase._dok_containerhr[rcddlm}|S)Nr) lil_array)_lilrq)rQrqs r_lil_containerz_spbase._lil_containermr[rNmaxprintcd|_|jjdkrtdt |t r#t j|rtd|tn||_ dS)NrJz7This class is not intended to be instantiated directly.zEscipy sparse array classes do not support instantiation from a scalar) rO __class__r ValueError isinstancernpisscalarMAXPRINTru)rQarg1rus r__init__z_spbase.__init__rs~ > "i / /=>> > dG $ $ T):): W %-$4( rc|jSrM)rOrPs rshapez _spbase.shape}s {rct||jtdd}t|\}}||jkr|r|S|S||||dS)areshape(self, shape, order='C', copy=False) Gives a new shape to a sparse array/matrix without changing its data. Parameters ---------- shape : length-2 tuple of ints The new shape should be compatible with the original shape. order : {'C', 'F'}, optional Read the elements using this index order. 'C' means to read and write the elements using C-like index order; e.g., read entire first row, then second row, etc. 'F' means to read and write the elements using Fortran-like index order; e.g., read entire first column, then second column, etc. copy : bool, optional Indicates whether or not attributes of self should be copied whenever possible. The degree to which attributes are copied varies depending on the type of sparse array being used. Returns ------- reshaped : sparse array/matrix A sparse array/matrix with the given `shape`, not necessarily of the same format as the current object. See Also -------- numpy.reshape : NumPy's implementation of 'reshape' for ndarrays rA)allow_ndcopyF)orderr)rrrangerrtocooreshape)rQargskwargsrrrs rrz_spbase.reshapesBD$*uQ||DDD*622 t DJ   yy{{" zztz$$,,U%e,LLLrcJtt|jd)aResize the array/matrix in-place to dimensions given by ``shape`` Any elements that lie within the new shape will remain at the same indices, while non-zero elements lying outside the new shape are removed. Parameters ---------- shape : (int, int) number of rows and columns in the new array/matrix Notes ----- The semantics are not identical to `numpy.ndarray.resize` or `numpy.resize`. Here, the same data will be maintained at each index before and after reshape, if that index is within the new bounds. In numpy, resizing maintains contiguity of the array, moving elements around in the logical array but not within a flattened representation. We give no guarantees about whether the underlying data attributes (arrays, etc.) will be modified in place or replaced with new objects. z.resize is not implemented)NotImplementedErrortyper)rQrs rresizez_spbase.resizes.0"Dzz" > > >@@ @runsafeTct|}|j|krB|||||jS|r|S|S)aCast the array/matrix elements to a specified type. Parameters ---------- dtype : string or numpy dtype Typecode or data-type to which to cast the data. casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional Controls what kind of data casting may occur. Defaults to 'unsafe' for backwards compatibility. 'no' means the data types should not be cast at all. 'equiv' means only byte-order changes are allowed. 'safe' means only casts which can preserve values are allowed. 'same_kind' means only safe casts or casts within a kind, like float64 to float32, are allowed. 'unsafe' means any data conversions may be done. copy : bool, optional If `copy` is `False`, the result might share some memory with this array/matrix. If `copy` is `True`, it is guaranteed that the result and this array/matrix do not share any memory. )castingr)r dtypetocsrastypeasformatformatr)rQrrrs rrz_spbase.astypess, :  ::<<&&wT'333;8DK3H3H I  99;; Krc jt|trtj|fi|St |fi|SrM) issubclassrrzasarrayrclsXrs r _ascontainerz_spbase._ascontainersB c7 # # ):a**6** *A(((( (rc jt|trtj|fi|St |fi|SrM)rrrzarrayr rs r _containerz_spbase._containersB c7 # # '8A(((( (!&&v&& &rcgd}|jj|vr|S|D]6}|jtj|kr||cS7t d|jjd)z6Upcast array to a floating point format (if necessary))fdFDzcannot upcast [z] to a floating point format)rcharrzr TypeErrorname)rQfp_typesfp_types r _asfptypez_spbase._asfptypes('' :?h & &K# 0 0:'!2!222;;w/////3O$*/OOO rc#XKt|jdD] }||V dS)Nr)rr)rQrs r__iter__z_spbase.__iter__s<tz!}%%  Aq'MMMM  rc|jS)z3Maximum number of elements to display when printed.rtrPs r _getmaxprintz_spbase._getmaxprints }rc@|jj}td|d)aNumber of non-zero entries, equivalent to np.count_nonzero(a.toarray(), axis=axis) Unlike the nnz property, which return the number of stored entries (the length of the data attribute), this method counts the actual number of non-zero entries in data. Duplicate entries are summed before counting. Parameters ---------- axis : {-2, -1, 0, 1, None} optional Count nonzeros for the whole array, or along a specified axis. .. versionadded:: 1.15.0 Returns ------- numpy array A reduced array (no axis `axis`) holding the number of nonzero values for each of the indices of the nonaxis dimensions. Notes ----- If you want to count nonzero and explicit zero stored values (e.g. nnz) along an axis, two fast idioms are provided by `numpy` functions for the common CSR, CSC, COO formats. For the major axis in CSR (rows) and CSC (cols) use `np.diff`: >>> import numpy as np >>> import scipy as sp >>> A = sp.sparse.csr_array([[4, 5, 0], [7, 0, 0]]) >>> major_axis_stored_values = np.diff(A.indptr) # -> np.array([2, 1]) For the minor axis in CSR (cols) and CSC (rows) use `numpy.bincount` with minlength ``A.shape[1]`` for CSR and ``A.shape[0]`` for CSC: >>> csr_minor_stored_values = np.bincount(A.indices, minlength=A.shape[1]) For COO, use the minor axis approach for either `axis`: >>> A = A.tocoo() >>> coo_axis0_stored_values = np.bincount(A.coords[0], minlength=A.shape[1]) >>> coo_axis1_stored_values = np.bincount(A.coords[1], minlength=A.shape[0]) Examples -------- >>> A = sp.sparse.csr_array([[4, 5, 0], [7, 0, 0]]) >>> A.count_nonzero(axis=0) array([2, 1, 0]) z"count_nonzero not implemented for .rwrrrQaxisclsnames r count_nonzeroz_spbase.count_nonzero s)n.)!"Qw"Q"Q"QRRRrc@|jj}td|d)a6Number of stored values, including explicit zeros. Parameters ---------- axis : {-2, -1, 0, 1, None} optional Report stored values for the whole array, or along a specified axis. See also -------- count_nonzero : Number of non-zero entries zgetnnz not implemented for rrrs r_getnnzz_spbase._getnnzFs(.)!"J"J"J"JKKKrc*|S)zNumber of stored values, including explicit zeros. See also -------- count_nonzero : Number of non-zero entries rrPs rnnzz _spbase.nnzU||~~rc*|S)zwNumber of stored values. See also -------- count_nonzero : Number of non-zero values. rrPs rsizez _spbase.size_rrc|jS)zFormat string for matrix.)_formatrPs rrz_spbase.formatis |rc*|S)z Transpose.) transposerPs rTz _spbase.Tns~~rc*|SrM)_realrPs rrealz _spbase.realszz||rc*|SrM)_imagrPs rimagz _spbase.imagwrrc t|j\}}t|trdnd}d|d|d|jd|jd|jd S) Nrr )_formatsrryrrrr)rQ_ format_name sparse_clss r__repr__z_spbase.__repr__{s!$+.; *4 9 9GWWx  I  I IZ I IDJ I Ih I I;?: I I I rc|}|}d}t|}|jdkr|S|dz }|j|kr|dz||t fd|jD|jdz }|dz }|z ||t fd|jD|j dz }n|||j|jz }|S)Ncttd|D|}dd|DS)Nc3>K|]}|VdSrM)tolist).0cs r z1_spbase.__str__..tostr..s*99Qahhjj999999r c3,K|]\}}d|d|VdS)z  Nr)ridxvals rrz1_spbase.__str__..tostr..s7EE83.#....EEEEEEr)zipjoin)coordsdatapairss rtostrz_spbase.__str__..tostrsF99&999:DAAE99EEuEEEEE Errz Coords Values r"c3,K|]}|dVdSrMrrrhalfs rrz"_spbase.__str__..s+::Aq$x::::::rz : : c3.K|]}| dVdSrMrrs rrz"_spbase.__str__..s-;;Qq$y;;;;;;r)rrreprrtuplerr)rQruAroutrs @r__str__z_spbase.__str__s%$$&& JJLL F F F4jj 8q==J %% 8h  q=D 55:::::::::AF5D5MJJ JC < Cd?D 55;;;;!(;;;;;QVTEFF^LL LCC 5516** *C rcL|jdkr |jdkStd)N)rrrz\The truth value of an array with more than one element is ambiguous. Use a.any() or a.all().)rrrxrPs r__bool__z_spbase.__bool__s6 :  8q= MNN Nrc td)Nz:sparse array length is ambiguous; use getnnz() or shape[0])rrPs r__len__z_spbase.__len__s'(( (rFc| ||jkr|r|S|S t|d|z}n&#t$r}t d|d|d}~wwxYw ||S#t $r |cYSwxYw)aReturn this array/matrix in the passed format. Parameters ---------- format : {str, None} The desired sparse format ("csr", "csc", "lil", "dok", "array", ...) or None for no conversion. copy : bool, optional If True, the result is guaranteed to not share data with self. Returns ------- A : This array/matrix in the passed format. NtozFormat z is unknown.r)rrgetattrAttributeErrorrxr)rQrrconvert_methodes rrz_spbase.asformats >Vt{22 yy{{"  H!(tf}!=!=! H H H !?6!?!?!?@@aG H (%~40000 ( ( (%~''''' (s'; AAA" A..BBct|r||S||S)z2Point-wise multiplication by another array/matrix.)r _mul_scalarrmultiplyrQothers rrz_spbase.multiplysB    +##E** *zz||$$U+++rcP||S)z;Element-wise maximum between this and another array/matrix.)rmaximumrs rrz_spbase.maximumzz||##E***rcP||S)z;Element-wise minimum between this and another array/matrix.)rminimumrs rrz_spbase.minimumrrc>tj|r||zS||zS)a/Ordinary dot product Examples -------- >>> import numpy as np >>> from scipy.sparse import csr_array >>> A = csr_array([[1, 2, 0], [0, 0, 3], [4, 0, 5]]) >>> v = np.array([1, 0, -1]) >>> A.dot(v) array([ 1, -3, -1], dtype=int64) )rzr{rs rdotz _spbase.dots* ;u   %< %< rcT|||S)zElement-wise power.r)rpower)rQnrs rrz _spbase.powers#zz||!!!5!111rc|j|kr|r|n|S|||SrM)rrr _broadcast_to)rQrrs rr z_spbase._broadcast_tosD :  "&0499;;;D 0::<<--eT:: :rcP||SrM)r__eq__rs rr z_spbase.__eq__zz||""5)))rcP||SrM)r__ne__rs rrz_spbase.__ne__rrcP||SrM)r__lt__rs rrz_spbase.__lt__rrcP||SrM)r__gt__rs rrz_spbase.__gt__rrcP||SrM)r__le__rs rrz_spbase.__le__ rrcP||SrM)r__ge__rs rrz_spbase.__ge__ rrcDt|SrM)absrrPs r__abs__z_spbase.__abs__s4::<<   rrcHt||S)N)ndigits)roundr)rQrs r __round__z_spbase.__round__sTZZ\\73333rcP||SrM)r _add_sparsers rr!z_spbase._add_sparsezz||''...rcP||SrM)r _add_densers rr$z_spbase._add_denseszz||&&u---rcP||SrM)r _sub_sparsers rr&z_spbase._sub_sparser"rc0||z SrMtodensers r _sub_densez_spbase._sub_denses||~~%%rc0||z SrMr(rs r _rsub_densez_spbase._rsub_dense!st||~~%%rct|r)|dkr|Stdt|r4|j|jkrt d||St|r/tj ||j}| |StS)Nrz:adding a nonzero scalar to a sparse array is not supportedinconsistent shapes) r rrrrrxr!rrz broadcast_tor$NotImplementedrs r__add__z_spbase.__add__%s    "zzyy{{"%'FGG G e__ "{dj(( !6777##E** * U^^ "OE4:66E??5)) )! !rc,||SrM)r1rs r__radd__z_spbase.__radd__6s||E"""rct|r)|dkr|Stdt|r4|j|jkrt d||St|r/tj ||j}| |StS)NrzAsubtracting a nonzero scalar from a sparse array is not supportedr.) r rrrrrxr&rrzr/r*r0rs r__sub__z_spbase.__sub__9s    "zzyy{{"%'FGG G e__ "{dj(( !6777##E** * U^^ "OE4:66E??5)) )! !rct|r*|dkr| Stdt|r/t j||j}||StS)NrzAsubtracting a sparse array from a nonzero scalar is not supported) r rrrrzr/rr,r0rs r__rsub__z_spbase.__rsub__Is    "zz |#%'HII I U^^ "OE4:66E##E** *! !rc|j\}}|jtjur|j|fkr||S|j|dfkr]||}|jdkr|dS||dS|jdkr&|jd|kr| |St|r| |Sd}t|rI||jdkr#t|d|d|jdd||Stj|}|jdkr|jtjkrt$S |jn#t&$r|}YnwxYw|jdks|jdkr|jddkr|jd|kr#t|d|d|jdd|tj|}t)|tjr||}|jdkrH|jddkr7|jdkr|d}n|d d}|S|jdkr|jd|kr#t|d|d|jdd| tj|}t)|tjr||}|Std ) anp.array-like matmul & `np.matrix`-like mul, i.e. `dot` or `NotImplemented` interpret other and call one of the following self._mul_scalar() self._matmul_vector() self._matmul_multivector() self._matmul_sparse() rr"rz)matmul: dimension mismatch with signaturez (n,k=z),(k=z ,m)->(n,m)z ,1?)->(n,1?)rTzcould not interpret dimensions)rVrwrzndarrayr_matmul_vectorravelrRr_matmul_multivectorr rrrx_matmul_sparse asanyarrayrobject_r0rryr rr)rQrMNresult err_prefixother_as r_matmul_dispatchz_spbase._matmul_dispatchUsu 1 ?bj ( ({qd""**5111A&&,,U[[]];;9>>!>>!,,,~~a+++qU[^q%8%8//666    +##E** *@ E?? .EKN"" !KKKKQKKK&&u-- --&& <1  "*!Q#6#69>>#^^A..FF#^^B22FM Z1__{1~"" !KKKKQKKK--bj.?.?@@F%++ 3**622M=>> >sF F+*F+c,||SrMrrs r__mul__z_spbase.__mul__}}U###rc,||SrMrGrs r__rmul__z_spbase.__rmul__rIrcP||SrM)rrrs rrz_spbase._mul_scalarr"rcP||SrM)rr:rs rr:z_spbase._matmul_vectorzz||**5111rcP||SrM)rr<rs rr<z_spbase._matmul_multivectorszz||//666rcP||SrM)rr=rs rr=z_spbase._matmul_sparserNrcxt|r||S |}n6#t$r)t j|}YnwxYw||}|turtS|SrM)r rrrrzrrEr0)rQrtrrets r_rmatmul_dispatchz_spbase._rmatmul_dispatchs    ###E** * 3__&&! 3 3 3Z&&0022 3..""33B77Cn$$%%==?? "s;0A.-A.cht|rtd||SNz0Scalar operands are not allowed, use '*' instead)r rxrErs r __matmul__z_spbase.__matmul__s=    0/00 0$$U+++rcht|rtd||SrV)r rxrTrs r __rmatmul__z_spbase.__rmatmul__s=    0/00 0%%e,,,rcDt|r=|rP|r'tj||Stj||S|rYtj|jtjr5|tj d|z S| d|z }tj |j}tj |jtj r9tj |tj r||jS|St|r|sB|rtjd|}ntjd|}||S|r'tj||Stj||St|r|r|||dS|}|rVtj|jtjr2|tj|S||St&S)N?F)rdivide)r rz true_divider)dividecan_castrfloat64rrr issubdtypeintegerrrr_divider_divide_sparser0)rQrr]r\r scalar_dtyperecipself_csrs rrcz_spbase._divides2   ) " <<>%@@@9UDLLNN;;; r{4:rzBB {{2:..::2e8DDD$$RX..!z%006 M$*bj99 lBJ??88DJ///H U^^ " <1N2u55EEIb%00E}}U+++<>%@@@9UDLLNN;;; e__ " G}}T;}FFFzz||H 6r{4:rzBB 6rz22AA%HHH..u555! !rc0||dSNT)r]rcrs r __truediv__z_spbase.__truediv__s||Et|444rc0||dSrirjrs r__div__z_spbase.__div__s||Et|444rctSrMr0rs r __rtruediv__z_spbase.__rtruediv__rctSrMrors r__rdiv__z_spbase.__rdiv__rqrc,| SrM)rrPs r__neg__z_spbase.__neg__#s }rctSrMrors r__iadd__z_spbase.__iadd__&rctSrMrors r__isub__z_spbase.__isub__)rxrctSrMrors r__imul__z_spbase.__imul__,rxrc,||SrM) __itruediv__rs r__idiv__z_spbase.__idiv__/s  '''rctSrMrors rr~z_spbase.__itruediv__2rxrc|j|i|SrM)r)rQrrs r__pow__z_spbase.__pow__5stz4*6***rcX|||dS)a Reverses the dimensions of the sparse array/matrix. Parameters ---------- axes : None, optional This argument is in the signature *solely* for NumPy compatibility reasons. Do not pass in anything except for the default value. copy : bool, optional Indicates whether or not attributes of `self` should be copied whenever possible. The degree to which attributes are copied varies depending on the type of sparse array/matrix being used. Returns ------- p : `self` with the dimensions reversed. Notes ----- If `self` is a `csr_array` or a `csc_array`, then this will return a `csc_array` or a `csr_array`, respectively. See Also -------- numpy.transpose : NumPy's implementation of 'transpose' for ndarrays rF)axesr)rr)rQrrs rrz_spbase.transpose8s+:zztz$$..Du.EEErctj|jtjr*||dS|r|S|S)aElement-wise complex conjugation. If the array/matrix is of non-complex data type and `copy` is False, this method does nothing and the data is not copied. Parameters ---------- copy : bool, optional If True, the result is guaranteed to not share data with self. Returns ------- A : The element-wise complex conjugate. rF)rzrarcomplexfloatingr conjugaterrQrs rrz_spbase.conjugateWs] =R%7 8 8 ::4:((222>> >  99;; Krc.||S)Nr)rrs rconjz _spbase.conjns~~4~(((rcN|SrM)rrrPs rrz _spbase._realszz||!!###rcN|SrM)rrrPs rrz _spbase._imagvrrc|}|jdktfd|jDS)aNonzero indices of the array/matrix. Returns a tuple of arrays (row,col) containing the indices of the non-zero elements of the array. Examples -------- >>> from scipy.sparse import csr_array >>> A = csr_array([[1, 2, 0], [0, 0, 3], [4, 0, 5]]) >>> A.nonzero() (array([0, 0, 1, 2, 2], dtype=int32), array([0, 1, 2, 0, 2], dtype=int32)) rc3(K|] }|V dSrMr)rrnz_masks rrz"_spbase.nonzero..s'66cS\666666r)rrrr)rQrrs @rnonzeroz_spbase.nonzeroysB JJLL&A+6666QX666666rc|jdkrtd|jd}|dkr||z }|dks||krtd|dg|gdggf|df|j}||z}|S)zeReturns a copy of column j of the array, as an (m x 1) sparse array (column vector). rz4getcol not provided for 1d arrays. Use indexing A[j]rTrindex out of boundsrr)rRrxr IndexErrorrcr)rQjrA col_selectorrBs r_getcolz_spbase._getcols 9>>STT T JrN q55 FA q55AFF233 3**QC1#s+<23Qtz+KK  $ rc|jdkrtd|jd}|dkr||z }|dks||krtd|dgdg|ggfd|f|j}||zS)z^Returns a copy of row i of the array, as a (1 x n) sparse array (row vector). rz$getrow not meaningful for a 1d arrayrrr)rRrxrrrgr)rQir@ row_selectors r_getrowz_spbase._getrows 9>>CDD D JqM q55 FA q55AFF233 3**QC1#s+<23Qtz+KK d""rcV||||S)a6 Return a dense representation of this sparse array. Parameters ---------- order : {'C', 'F'}, optional Whether to store multi-dimensional data in C (row-major) or Fortran (column-major) order in memory. The default is 'None', which provides no ordering guarantees. Cannot be specified in conjunction with the `out` argument. out : ndarray, 2-D, optional If specified, uses this array as the output buffer instead of allocating a new array to return. The provided array must have the same shape and dtype as the sparse array on which you are calling the method. Returns ------- arr : ndarray, 2-D An array with the same shape and containing the same data represented by the sparse array, with the requested memory order. If `out` was passed, the same object is returned after being modified in-place to contain the appropriate values. rr)rtoarrayrQrrs rr)z_spbase.todenses(8  Es!C!CDDDrcX|d||S)a Return a dense ndarray representation of this sparse array/matrix. Parameters ---------- order : {'C', 'F'}, optional Whether to store multidimensional data in C (row-major) or Fortran (column-major) order in memory. The default is 'None', which provides no ordering guarantees. Cannot be specified in conjunction with the `out` argument. out : ndarray, 2-D, optional If specified, uses this array as the output buffer instead of allocating a new array to return. The provided array must have the same shape and dtype as the sparse array/matrix on which you are calling the method. For most sparse types, `out` is required to be memory contiguous (either C or Fortran ordered). Returns ------- arr : ndarray, 2-D An array with the same shape and containing the same data represented by the sparse array/matrix, with the requested memory order. If `out` was passed, the same object is returned after being modified in-place to contain the appropriate values. Frr)rrrs rrz_spbase.toarrays+<zzuz%%--Es-CCCrcV||dS)zConvert this array/matrix to Compressed Sparse Row format. With copy=False, the data/indices may be shared between this array/matrix and the resultant csr_array/matrix. rF)rrrs rrz _spbase.tocsr) zztz$$***666rcV||dS)zConvert this array/matrix to Dictionary Of Keys format. With copy=False, the data/indices may be shared between this array/matrix and the resultant dok_array/matrix. rF)rtodokrs rrz _spbase.todokrrcV|d|S)zConvert this array/matrix to COOrdinate format. With copy=False, the data/indices may be shared between this array/matrix and the resultant coo_array/matrix. Fr)rrrs rrz _spbase.tocoo) zzuz%%+++666rcV|d|S)zConvert this array/matrix to List of Lists format. With copy=False, the data/indices may be shared between this array/matrix and the resultant lil_array/matrix. Fr)rtolilrs rrz _spbase.tolilrrcV||dS)zConvert this array/matrix to sparse DIAgonal format. With copy=False, the data/indices may be shared between this array/matrix and the resultant dia_array/matrix. rF)rtodiars rrz _spbase.todia'rrcX|d||S)a+Convert this array/matrix to Block Sparse Row format. With copy=False, the data/indices may be shared between this array/matrix and the resultant bsr_array/matrix. When blocksize=(R, C) is provided, it will be used for construction of the bsr_array/matrix. Fr) blocksizer)rtobsr)rQrrs rrz _spbase.tobsr/s+zzuz%%++id+KKKrcV||dS)zConvert this array/matrix to Compressed Sparse Column format. With copy=False, the data/indices may be shared between this array/matrix and the resultant csc_array/matrix. rF)rtocscrs rrz _spbase.tocsc:rrc0||dS)zReturns a copy of this array/matrix. No data/indices will be shared between the returned value and current array/matrix. Tr)rwrPs rrz _spbase.copyBs ~~d~...rct|t|j}|jdkrH|dvrt d|t j|j|z}|||S|j\}}|C|| t j|df|z||S|dkr|dz }|dkr/| t jd|f||z}n.|| t j|df|z}|||| S) a Sum the array/matrix elements over a given axis. Parameters ---------- axis : {-2, -1, 0, 1, None} optional Axis along which the sum is computed. The default is to compute the sum of all the array/matrix elements, returning a scalar (i.e., `axis` = `None`). dtype : dtype, optional The type of the returned array/matrix and of the accumulator in which the elements are summed. The dtype of `a` is used by default unless `a` has an integer dtype of less precision than the default platform integer. In that case, if `a` is signed then the platform integer is used while if `a` is unsigned then an unsigned integer of the same precision as the platform integer is used. .. versionadded:: 0.18.0 out : np.matrix, optional Alternative output matrix in which to place the result. It must have the same shape as the expected output, but the type of the output values will be cast if necessary. .. versionadded:: 0.18.0 Returns ------- sum_along_axis : np.matrix A matrix with the same shape as `self`, with the specified axis removed. See Also -------- numpy.matrix.sum : NumPy's implementation of 'sum' for matrices rNrTraxis must be None, -1 or 0rrrNrr"rrr) r rrrRrxrzonesrsumr) rQrrr res_dtyperesr@rArSs rrz _spbase.sumJsoL T"$*-- 9>>=(( !=>>>9====C77C700 0 z1 <t((!Qy)I)I)IJJJc3c'' ( !88 AID 199##Ai000CC **Ai000CwwD3w777rc t||jj}tj|jtjp#tj|jtj}||r tj}ntj|j}|r tjn|}||}|j dkr:|dvrtd||j dz }| ||S|3||j d|j dzz ||S|dkr|dz }|dkr)|d |j dz z d|| S|d |j dz z d|| S) a Compute the arithmetic mean along the specified axis. Returns the average of the array/matrix elements. The average is taken over all elements in the array/matrix by default, otherwise over the specified axis. `float64` intermediate and return values are used for integer inputs. Parameters ---------- axis : {-2, -1, 0, 1, None} optional Axis along which the mean is computed. The default is to compute the mean of all elements in the array/matrix (i.e., `axis` = `None`). dtype : data-type, optional Type to use in computing the mean. For integer inputs, the default is `float64`; for floating point inputs, it is the same as the input dtype. .. versionadded:: 0.18.0 out : np.matrix, optional Alternative output matrix in which to place the result. It must have the same shape as the expected output, but the type of the output values will be cast if necessary. .. versionadded:: 0.18.0 Returns ------- m : np.matrix See Also -------- numpy.matrix.mean : NumPy's implementation of 'mean' for matrices NrrrrTrrr"r[r) r rrrzrarbbool_r`rrRrxrr) rQrrrrintegral inter_dtype inter_selfrs rmeanz _spbase.meansJ TJO M$*bj998M$*bh77  = 'J ,I%-;bjj) [[-- 9>>=(( !=>>>tz"~-C77744 4 <$*Q-$*Q-"?@9#.. / !88 AID 199# 1 "56;;iS<22 2# 1 "56;;iS<22 2rcR||S)aXReturns the kth diagonal of the array/matrix. Parameters ---------- k : int, optional Which diagonal to get, corresponding to elements a[i, i+k]. Default: 0 (the main diagonal). .. versionadded:: 1.0 See also -------- numpy.diagonal : Equivalent numpy function. Examples -------- >>> from scipy.sparse import csr_array >>> A = csr_array([[1, 2, 0], [0, 0, 3], [4, 0, 5]]) >>> A.diagonal() array([1, 0, 5]) >>> A.diagonal(k=1) array([2, 3]) k)rdiagonal)rQrs rrz_spbase.diagonals#0zz||$$q$)))rcR||S)aReturns the sum along diagonals of the sparse array/matrix. Parameters ---------- offset : int, optional Which diagonal to get, corresponding to elements a[i, i+offset]. Default: 0 (the main diagonal). r)rr)rQoffsets rtracez _spbase.traces$}}v}&&**,,,rc|j\}}|dkr||ks |dkr| |krtd|tj||dS)a Set diagonal or off-diagonal elements of the array/matrix. Parameters ---------- values : array_like New values of the diagonal elements. Values may have any length. If the diagonal is longer than values, then the remaining diagonal entries will not be set. If values are longer than the diagonal, then the remaining values are ignored. If a scalar value is given, all of the diagonal is set to it. k : int, optional Which off-diagonal to set, corresponding to elements a[i,i+k]. Default: 0 (the main diagonal). rzk exceeds array dimensionsN)rrx_setdiagrzr)rQvaluesrr@rAs rsetdiagz_spbase.setdiagse(z1 EEa1ff!a%%QB!GG9:: : bj((!,,,,,rcZ|j\}}|dkr|jdkr1t||z|}t|D] }||||z |f< dSt||z|t |}|dkrdSt |d|D]\}}||||z |f<dS|jdkr1t|||z }t|D] }|||||zf< dSt|||z t |}|dkrdSt |d|D]\}}|||||zf<dS)zZThis part of the implementation gets overridden by the different formats. rN)rrRminrrN enumerate)rQrrr@rA max_indexrvs rrz_spbase._setdiag!sz1 q55{a!QKK y)),,A%+DQNN,, !QF 44 >>F%fZiZ&899''DAq%&DQNN''{a1Q3KK y)),,A%+DAENN,, 1Q3F 44 >>F%fZiZ&899''DAq%&DAENN''rc|G|td|j|jks|j|jkrtdd|d<|Stj|j|j|S)Nz,order cannot be specified if out is not Nonez6out array must be same dtype and shape as sparse arrayg.)rr)rxrrrzzerosrs r_process_toarray_argsz_spbase._process_toarray_args?s ?  "/000yDJ&&#)tz*A*A "0111CHJ8DJdjFFF FrrcTddlm}||||ot|t S)a Determine index dtype for array. This wraps _sputils.get_index_dtype, providing compatibility for both array and matrix API sparse matrices. Matrix API sparse matrices would attempt to downcast the indices - which can be computationally expensive and undesirable for users. The array API changes this behaviour. See discussion: https://github.com/scipy/scipy/issues/16774 The get_index_dtype import is due to implementation details of the test suite. It allows the decorator ``with_64bit_maxval_limit`` to mock a lower int32 max value for checks on the matrix API's downcasting behaviour. r)get_index_dtype)_sputilsrryr)rQarraysmaxvalcheck_contentsrs r_get_index_dtypez_spbase._get_index_dtypeLsI" .-----v% . Pz$7P7P3PSS Sr)rTrM)F)r)FF)NF)T)NN)NNN)rNF)srrr__doc____array_priority__r _allow_ndpropertyintrRrVrZr_rcrgrkrorsr~rrrr classmethodrrrrrrrrrstrrrrrrrr __nonzero__rrrrrrrr r rrrrrrrr!r$r&r*r,r1r3r5r7rErHrKrr:r<r=rTrWrYrcrkrmrprsrurwrzr|rr~rrrrrrrrrr)rrrrrrrrrrrrrrrrrrrrrJrJ=s&GI  c   X 00X0XXXXXXX*. C C C C CX)M)M)MV@@@6>))[) ''['  8S8S8S8St L L L LSXcXX  X XX   4NNN K (((((((N,,, ++++++   $2222;;;; ******************!!!4444///...///&&&&&&""""###""" " " "\?\?\?|$$$$$$///222777222 # # #$,,, ---*"*"*"*"X555555(((+++FFFF>.))))$DL$$$$$$777(&###LEEEE<DDDDF77777777777777777777 L L L L7777///K8K8K8K8ZI2I2I2I2V****4 - - - -----2'''< G G GSSSSSSrrJceZdZdZdS)rz3A namespace class to separate sparray from spmatrixN)rrrrrrrrres====rrc,t|tS)aIs `x` of a sparse array or sparse matrix type? Parameters ---------- x object to check for being a sparse array or sparse matrix Returns ------- bool True if `x` is a sparse array or a sparse matrix, False otherwise Notes ----- Use `isinstance(x, sp.sparse.sparray)` to check between an array or matrix. Use `a.format` to check the sparse format, e.g. `a.format == 'csr'`. Examples -------- >>> import numpy as np >>> from scipy.sparse import csr_array, csr_matrix, issparse >>> issparse(csr_matrix([[5]])) True >>> issparse(csr_array([[5]])) True >>> issparse(np.array([[5]])) False >>> issparse(5) False )ryrJxs rrrls> a ! !!rc,t|tS)aIs `x` of a sparse matrix type? Parameters ---------- x object to check for being a sparse matrix Returns ------- bool True if `x` is a sparse matrix, False otherwise Examples -------- >>> import numpy as np >>> from scipy.sparse import csr_array, csr_matrix, isspmatrix >>> isspmatrix(csr_matrix([[5]])) True >>> isspmatrix(csr_array([[5]])) False >>> isspmatrix(np.array([[5]])) False >>> isspmatrix(5) False )ryr rs rrrs4 a " ""r).rnumpyrzrrrrrrr r r r _matrixr __all__Warningrrrr frozensetsintanarcsinarctansinhtanharcsinharctanhrintsignexpm1log1pdeg2radrad2degfloorceiltruncsqrt _ufuncs_with_fixed_point_at_zeror|rJrrrrrrrs$$7777777777777777777777 7 7 7     G        -        m    EA12  A./  A+,  A'  A34   A12   A|$   A'(  A<=  Az?  B*+  B89  B-.  B;<  B+,  B./  B)*! "45,- $'   0$-9  29bgrw  BGRWbh"* BHbgrx.:$;$; eSeSeSeSeSeSeSeSP)>>>>>>>>/"""D#####r