(phNSrSSKrSSKJrJrJrJrJrJ r J r J r J r SSK Jr /SQr"SS\5r"S S \5r"S S \5r0S SS/_SSS/_SSS/_SSS/_SSS/_SSS/_SSS/_S S!S"/_S#S$S%/_S&S'S(/_S)S*S+/_S,S-S./_S/S0S1/_S2S3S4/_S5S6S7/_S8S9S:/_S;SS?/S@SA/SBSC/SD.Er\"\R,\R.\R0\R2\R4\R6\R8\R:\R<\R>\R@\RB\RD\RF\RH\RJ\RL\RN/5r(SEr)"SFSG5r*"SHSI5r+\*R\+lSJr,SKr-g)LzBase class for sparse matricesN) asmatrixcheck_reshape_kwargs check_shape get_sum_dtypeisdense isscalarlikematrix validateaxisgetdtype)spmatrix) isspmatrixissparsesparray SparseWarningSparseEfficiencyWarningc\rSrSrSrg)rN__name__ __module__ __qualname____firstlineno____static_attributes__rE/var/www/html/venv/lib/python3.13/site-packages/scipy/sparse/_base.pyrrrrc\rSrSrSrg)SparseFormatWarningrNrrrrr r rrr c\rSrSrSrg)rrNrrrrrrrrrcsczCompressed 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 SKylinenskrzNonsymmetric SKylinejadzJAgged DiagonalzUnsymmetric Sparse SkylinezVariable Block Rowr! Undefined)ussvbrund2c\rSrSrSrSrSrSr\S\ 4Sj5r \S5r \S 5r \S 5r \S 5r\S 5r\S 5r\S5r\S5rSS.Sjr\S5rSrSrSqSjr\S5r\S5rSrSrSrSrSjrSrSjr\S\ 4Sj5r \S\ 4Sj5r!\S\"4S j5r#\S!5r$\S"5r%\S#5r&S$r'S%r(S&r)\)r*S'r+SsS(jr,S)r-S*r.S+r/S,r0SrS-jr1SsS.jr2S/r3S0r4S1r5S2r6S3r7S4r8S5r9StS6jr:S7r;S8rS;r?S<r@S=rAS>rBS?rCS@rDSArESBrFSCrGSDrHSErISFrJSGrKSHrLSIrMSuSJjrNSKrOSLrPSMrQSNrRSOrSSPrTSQrUSRrVSSrWSTrXSUrYSvSVjrZSwSWjr[SwSXjr\\[R\\lSYr]SZr^S[r_S\r`S]raSxS^jrbSxS_jrcSsS`jrdSsSajreSsSbjrfSsScjrgSsSdjrhSvSejriSsSfjrjSgrkSyShjrlSySijrmStSjjrnStSkjroStSljrpSmrqSnrrSzSojrsSprtg){_spbase=zThis class provides a base class for all sparse arrays. It cannot be instantiated. Most of the work is provided by subclasses. g333333$@rJ)r'returnc,[UR5$N)len_shapeselfs rndim _spbase.ndimFs4;;rcJURn[U5S:XaSUS4$U$)Nr)rSrR)rUss r _shape_as_2d_spbase._shape_as_2dJs( KK Vq[1R5z/a/rcSSKJn U$)Nr) bsr_array)_bsrr^)rUr^s r_bsr_container_spbase._bsr_containerO #rcSSKJn U$)Nr) coo_array)_coord)rUrds r_coo_container_spbase._coo_containerTrbrcSSKJn U$)Nr) csc_array)_cscri)rUris r_csc_container_spbase._csc_containerYrbrcSSKJn U$)Nr) csr_array)_csrrn)rUrns r_csr_container_spbase._csr_container^rbrcSSKJn U$)Nr) dia_array)_diars)rUrss r_dia_container_spbase._dia_containercrbrcSSKJn U$)Nr) dok_array)_dokrx)rUrxs r_dok_container_spbase._dok_containerhrbrcSSKJn U$)Nr) lil_array)_lilr})rUr}s r_lil_container_spbase._lil_containermrbrNmaxprintcSUlURRS:Xa [S5e[ U[ 5(a&[ R"U5(a [S5eUc [Ul gUUl g)NrMz7This class is not intended to be instantiated directly.zEscipy sparse array classes do not support instantiation from a scalar) rS __class__r ValueError isinstancernpisscalarMAXPRINTr)rUarg1rs r__init___spbase.__init__rsl >> " "i /=> > dG $ $T):):W %-$4 ( rcUR$rQ)rSrTs rshape _spbase.shape}s {{rc[XR[SS5S9n[U5upEX0R:XaU(aUR 5$U$UR US9R X4SS9$)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)rUargskwargsrrrs rr_spbase.reshapesfBD**uQ|D*62  JJ yy{" zztz$,,Ue,LLrcD[[U5RS35e)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)rUrs rresize_spbase.resizes)0"Dz""##= >@ @rc[U5nURU:wa7UR5RXUS9R UR 5$U(aUR 5$U$)aqCast 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)rUrrrs rr_spbase.astypes_, :: ::<&&T'33;8DKK3H I 99; Krc r[U[5(a[R"U40UD6$[ U40UD6$rQ) issubclassrrasarrayrclsXrs r _ascontainer_spbase._ascontainers3 c7 # #::a*6* *A(( (rc r[U[5(a[R"U40UD6$[ U40UD6$rQ)rrrarrayr rs r _container_spbase._containers3 c7 # #88A(( (!&v& &rc/SQnURRU;aU$UH:nUR[R"U5::dM)URU5s $ [ SURR S35e)z6Upcast array to a floating point format (if necessary))fdFDzcannot upcast [z] to a floating point format)rcharrr TypeErrorname)rUfp_typesfp_types r _asfptype_spbase._asfptypesq( ::??h &K#::'!22;;w//$!$**//!22NO rc#V# [URS5H nXv M g7f)Nr)rr)rUrs r__iter___spbase.__iter__s#tzz!}%A'M&s')cUR$)z3Maximum number of elements to display when printed.rrTs r _getmaxprint_spbase._getmaxprints }}rcLURRn[SUS35e)ajNumber 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 .rrrrUaxisclsnames r count_nonzero_spbase.count_nonzero s)n..))!$Fwiq"QRRrcLURRn[SUS35e)zNumber 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_getnnz_spbase._getnnzFs(..))!$?y"JKKrc"UR5$)zqNumber of stored values, including explicit zeros. See also -------- count_nonzero : Number of non-zero entries rrTs rnnz _spbase.nnzU||~rc"UR5$)zWNumber of stored values. See also -------- count_nonzero : Number of non-zero values. rrTs rsize _spbase.size_rrcUR$)zFormat string for matrix.)_formatrTs rr_spbase.formatis||rc"UR5$)z Transpose.) transposerTs rT _spbase.Tns~~rc"UR5$rQ)_realrTs rreal _spbase.realszz|rc"UR5$rQ)_imagrTs rimag _spbase.imagwrrc [URup[U[5(aSOSnSUSUSURSUR SUR S3 $) Nrr )_formatsrrrrrr)rU_ format_name sparse_clss r__repr___spbase.__repr__{sc!$++. *4 9 9Wx  }HZL DJJ<HhhZ:4::,a I rc^UR5nUR5nSn[U5nURS:XaU$US- nURU:a|US-mXC"[ U4SjUR 55UR ST5- nUS- nUT- mXC"[ U4SjUR 55UR T*S5- nU$XC"UR UR 5- nU$)Ncd[[SU56U5nSRSU55$)Nc3@# UHoR5v M g7frQ)tolist).0cs r 1_spbase.__str__..tostr..s9&Qhhjj&s c36# UHupSUSU3v M g7f)z  Nr)ridxvals rrrsEu83r#b.us)zipjoin)coordsdatapairss rtostr_spbase.__str__..tostrs.9&9:DAE99EuEE Errz Coords Values r'c3,># UH oSTv M g7frQrrrhalfs rr"_spbase.__str__..s:A$xz : : c3.># UH oT*Sv M g7frQrr s rrr s;(Q$y(s)rrreprrtuplerr)rUrAroutr s @r__str___spbase.__str__s$$& JJL F4j 88q=J %% 88h q=D 5:::AFF5DMJ JC < Cd?D 5;!((;;QVVTEF^L LC  5166* *C rcVURS:XaURS:g$[S5e)N)rrrz\The truth value of an array with more than one element is ambiguous. Use a.any() or a.all().)rrrrTs r__bool___spbase.__bool__s1 :: 88q= MN Nrc[S5e)Nz:sparse array length is ambiguous; use getnnz() or shape[0])rrTs r__len___spbase.__len__s'( (rcUbXR:XaU(aUR5$U$[USU-5nU"US9$![an[ SUS35UeSnAff=f![ a U"5s$f=f)aYReturn 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)rrgetattrAttributeErrorrr)rUrrconvert_methodes rr_spbase.asformats >V{{2yy{"  H!(tf}!=  (%400 " H 76(,!?@aG H  (%'' (s(AA% A" AA"%A98A9c[U5(aURU5$UR5RU5$)z2Point-wise multiplication by another array/matrix.)r _mul_scalarrmultiplyrUothers rr#_spbase.multiplys5   ##E* *zz|$$U++rc@UR5RU5$)z;Element-wise maximum between this and another array/matrix.)rmaximumr$s rr(_spbase.maximumzz|##E**rc@UR5RU5$)z;Element-wise minimum between this and another array/matrix.)rminimumr$s rr,_spbase.minimumr*rcH[R"U5(aX-$X-$)zOrdinary 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) )rrr$s rdot _spbase.dots# ;;u  < < rc<UR5RXS9$)zElement-wise power.r)rpower)rUnrs rr3 _spbase.powerszz|!!!!11rcURU:XaU(aUR5$U$UR5RX5$rQ)rrr _broadcast_to)rUrrs rr7_spbase._broadcast_tos8 :: "&499; 0D 0::<--e: :rc@UR5RU5$rQ)r__eq__r$s rr:_spbase.__eq__zz|""5))rc@UR5RU5$rQ)r__ne__r$s rr>_spbase.__ne__r<rc@UR5RU5$rQ)r__lt__r$s rrA_spbase.__lt__r<rc@UR5RU5$rQ)r__gt__r$s rrD_spbase.__gt__r<rc@UR5RU5$rQ)r__le__r$s rrG_spbase.__le__ r<rc@UR5RU5$rQ)r__ge__r$s rrJ_spbase.__ge__ r<rc4[UR55$rQ)absrrTs r__abs___spbase.__abs__s4::<  rc2[UR5US9$)N)ndigits)roundr)rUrQs r __round___spbase.__round__sTZZ\733rc@UR5RU5$rQ)r _add_sparser$s rrV_spbase._add_sparsezz|''..rc@UR5RU5$rQ)r _add_denser$s rrZ_spbase._add_denseszz|&&u--rc@UR5RU5$rQ)r _sub_sparser$s rr]_spbase._sub_sparserXrc(UR5U- $rQtodenser$s r _sub_dense_spbase._sub_denses||~%%rc&XR5- $rQr`r$s r _rsub_dense_spbase._rsub_dense!s||~%%rc~[U5(a!US:XaUR5$[S5e[U5(a6URUR:wa [ S5eUR U5$[U5(a1[R"XR5nURU5$[$)Nrz:adding a nonzero scalar to a sparse array is not supportedinconsistent shapes) r rrrrrrVrr broadcast_torZNotImplementedr$s r__add___spbase.__add__%s   zyy{"%'FG G e__{{djj( !677##E* * U^^OOE::6E??5) )! !rc$URU5$rQ)rkr$s r__radd___spbase.__radd__6s||E""rc~[U5(a!US:XaUR5$[S5e[U5(a6URUR:wa [ S5eUR U5$[U5(a1[R"XR5nURU5$[$)NrzAsubtracting a nonzero scalar from a sparse array is not supportedrh) r rrrrrr]rrrirbrjr$s r__sub___spbase.__sub__9s   zyy{"%'FG G e__{{djj( !677##E* * U^^OOE::6E??5) )! !rc[U5(a"US:XaUR5*$[S5e[U5(a1[R "XR 5nURU5$[$)NrzAsubtracting a sparse array from a nonzero scalar is not supported) r rrrrrirrerjr$s r__rsub___spbase.__rsub__Isi   z |#%'HI I U^^OOE::6E##E* *! !rcURup#UR[RLaURU4:XaUR U5$URUS4:XaRUR UR 55nURS:XaURS5$URUS5$URS:Xa$URSU:XaURU5$[U5(aURU5$Sn[U5(aDX1RS:wa![USUSURSS35eURU5$[R"U5nURS:Xa$UR [R":Xa[$$UR URS:Xd#URS:XaURSS:XaURSU:wa![USUSURSS35eUR [R "U55n[)U[R*5(aUR-U5nURS:XaHURSS:Xa5URS:XaURS5nU$URS S5nU$URS:XaURSU:wa![USUSURSS35eUR[R."U55n[)U[R*5(aUR-U5nU$[S 5e![&a UnGNf=f) znp.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?)rYzcould not interpret dimensions)r[rrndarrayr_matmul_vectorravelrVr_matmul_multivectorr r"rr_matmul_sparse asanyarrayrobject_rjrrr rr)rUr%MNresult err_prefixother_as r_matmul_dispatch_spbase._matmul_dispatchUs   ??bjj ({{qd"**511A&,,U[[];99>!>>!,,~~a++qU[[^q%8//66   ##E* *@ E??KKN" !l&5Q0@ K&&u- ---& <<1 "**!<" !  KK ::?ejjAo%++a.A2E{{1~" !l&5Q0@ M((%9F%++**62zzQ5;;q>Q#699>#^^A.FM$^^B2FM ZZ1_{{1~" !l&5Q0@ K--bjj.?@F%++**62M=> >S E s( M00 N?Nc$URU5$rQr#r$s r__mul___spbase.__mul__}}U##rc$URU5$rQrr$s r__rmul___spbase.__rmul__rrc@UR5RU5$rQ)rr"r$s rr"_spbase._mul_scalarrXrc@UR5RU5$rQ)rrxr$s rrx_spbase._matmul_vectorzz|**511rc@UR5RU5$rQ)rrzr$s rrz_spbase._matmul_multivectorszz|//66rc@UR5RU5$rQ)rr{r$s rr{_spbase._matmul_sparserrcJ[U5(aURU5$UR5nUR5R U5nU[La[$UR5$![a' [R "U5R5nNnf=frQ)r r"rrrrrrj)rUr%trrets r_rmatmul_dispatch_spbase._rmatmul_dispatchs   ##E* * 3__&.."33B7Cn$%%==? " " 3ZZ&002 3sA11.B"!B"cZ[U5(a [S5eURU5$Nz0Scalar operands are not allowed, use '*' instead)r rrr$s r __matmul___spbase.__matmul__s0   /0 0$$U++rcZ[U5(a [S5eURU5$r)r rrr$s r __rmatmul___spbase.__rmatmul__s0   /0 0%%e,,rc[U5(GaqU(aOU(a$[R"XR55$[R"XR55$U(ae[R "UR [R5(a1UR[R5RSU- 5$URSU- 5n[R"U5R n[R"UR [R5(aE[R"U[R5(aURUR 5$U$[U5(aU(dGU(a[R"SU5nO[R"SU5nURU5$U(a$[R"XR55$[R"XR55$[U5(aU(aUR!XSS9$UR#5nU(ab[R "UR [R5(a.UR[R5R%U5$UR%U5$[&$)N?F)rdivide)r r true_divideradividecan_castrfloat64rr"r issubdtypeintegerrr#r_divider_divide_sparserj)rUr%rrr scalar_dtyperecipself_csrs rr_spbase._divides   >>%@@99ULLN;;r{{4::rzzBB{{2::.::2e8DD$$RX.!zz%066 MM$**bjj99 lBJJ??88DJJ//H U^^NN2u5EIIb%0E}}U++>>%@@99ULLN;; e__}}T}FFzz|Hr{{4::rzzBBrzz2AA%HH..u55! !rc"URUSS9$NT)rrr$s r __truediv___spbase.__truediv__s||Et|44rc"URUSS9$rrr$s r__div___spbase.__div__s||Et|44rc[$rQrjr$s r __rtruediv___spbase.__rtruediv__rc[$rQrr$s r__rdiv___spbase.__rdiv__rrc$UR5*$rQ)rrTs r__neg___spbase.__neg__#s }rc[$rQrr$s r__iadd___spbase.__iadd__&rc[$rQrr$s r__isub___spbase.__isub__)rrc[$rQrr$s r__imul___spbase.__imul__,rrc$URU5$rQ) __itruediv__r$s r__idiv___spbase.__idiv__/s  ''rc[$rQrr$s rr_spbase.__itruediv__2rrc&UR"U0UD6$rQ)r3)rUrrs r__pow___spbase.__pow__5szz4*6**rc<URUS9RUSS9$)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)rUrrs rr_spbase.transpose8s%:zztz$..Du.EErc[R"UR[R5(aUR US9R SS9$U(aUR 5$U$)aGElement-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)rrrcomplexfloatingr conjugaterrUrs rr_spbase.conjugateWsR ==R%7%7 8 8::4:(222> > 99; Krc URUS9$)Nr)rrs rconj _spbase.conjns~~4~((rc>UR5R5$rQ)rrrTs rr _spbase._realszz|!!##rc>UR5R5$rQ)rrrTs rr _spbase._imagvrrc^UR5nURS:gm[U4SjUR55$)aSNonzero 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,># UH oTv M g7frQr)rrnz_masks rr"_spbase.nonzero..s6Xc\Xr )rrrr)rUrrs @rnonzero_spbase.nonzeroys2 JJL&&A+6QXX666rcURS:Xa [S5eURSnUS:aX- nUS:dX:a [S5eUR S/U/S//4US4UR S9nX-nU$)zUReturns 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]rYrindex out of boundsrr)rVrr IndexErrorrkr)rUjr col_selectorrs r_getcol_spbase._getcols 99>ST T JJrN q5 FA q5AF23 3**QC1#s+<23Qtzz+K $ rcURS:Xa [S5eURSnUS:aX- nUS:dX:a [S5eUR S/S/U//4SU4UR S9nX0-$)zNReturns 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)rVrrrrpr)rUir~ row_selectors r_getrow_spbase._getrows 99>CD D JJqM q5 FA q5AF23 3**QC1#s+<23Qtzz+K ""rc>URURXS95$)a~ 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)rtoarrayrUrrs rra_spbase.todenses 8  E!CDDrc:URSS9RXS9$)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 rr_spbase.toarrays#<zzuz%--E-CCrc:URUS9RSS9$)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 rr _spbase.tocsr# zztz$***66rc:URUS9RSS9$)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 rr _spbase.todokrrc:URSS9RUS9$)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 rr _spbase.tocoo# zzuz%+++66rc:URSS9RUS9$)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 rr  _spbase.tolilr rc:URUS9RSS9$)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 rr _spbase.todia'rrc:URSS9RXS9$)aConvert 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)rUrrs rr _spbase.tobsr/s#zzuz%++i+KKrc:URUS9RSS9$)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 rr _spbase.tocsc:rrc"URUSS9$)zzReturns a copy of this array/matrix. No data/indices will be shared between the returned value and current array/matrix. Tr)rrTs rr _spbase.copyBs ~~d~..rcX[U5 [UR5nURS:XaBUS;a [ S5eU[ R "URUS9-nURX#S9$URupgUc5XR[ R "US4US95-RX#S9$US:aUS- nUS:Xa*UR[ R "SU4US95U-nO(XR[ R "US4US95-nURXUS9$) 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 rNrYraxis must be None, -1 or 0r2rrrr'rrr) r rrrVrronesrsumr) rUrrr res_dtyperesr~rrs rr _spbase.sumJs.L T"$**- 99>=( !=>>9==C7770 0 zz <((!Qy)IJJcc' ( !8 AID 19##Ai0C **Ai0CwwD3w77rcj[U5 URRn[R"UR[R 5=(d/ [R"UR[R 5nUcU(a[RnO [R"U5RnU(a[ROUnURU5nURS:Xa1US;a [S5eXpRS- nURXCS9$Uc.XpRSURS-- RXCS9$US:aUS- nUS:Xa#USURS- -RSXCS 9$USURS- -RSXCS 9$) 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 rrrrYrrr'rr) r rrrrrbool_rrrVrrr) rUrrrr integral inter_dtype inter_selfr!s rmean _spbase.meansJ TJJOO MM$**bjj98MM$**bhh7  =JJ ,,I%-bjj) [[- 99>=( !=>>zz"~-C7774 4 <**Q-$**Q-"?@9. / !8 AID 19# 1 "56;;i<2 2# 1 "56;;i<2 2rc<UR5RUS9$)aReturns 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)rUr,s rr-_spbase.diagonals0zz|$$q$))rc<URUS9R5$)zReturns 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+)r-r)rUoffsets rtrace _spbase.traces}}v}&**,,rcURup4US:aX$:d US:aU*U:a [S5eUR[R"U5U5 g)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)rr_setdiagrr)rUvaluesr,r~rs rsetdiag_spbase.setdiagsK(zz Eaf!a%QB!G9: : bjj(!,rc URup4US:axURS:Xa)[X2-U5n[U5H nXXb- U4'M g[X2-U[ U55nUS::ag[ USU5H upgXpXb- U4'M gURS:Xa)[X4U- 5n[U5H nXXfU-4'M g[X4U- [ U55nUS::ag[ USU5H upgXpXfU-4'M g)zJThis part of the implementation gets overridden by the different formats. rN)rrVminrrR enumerate)rUr5r,r~r max_indexrvs rr4_spbase._setdiag!s zz q5{{aQK y)A%+N* QF 4 >%fZi&89DA%&N:{{aQ3K y)A%+EN* Q3F 4 >%fZi&89DA%&EN:rcUbTUb [S5eURUR:wdURUR:wa [S5eSUS'U$[R"URURUS9$)Nz,order cannot be specified if out is not Nonez6out array must be same dtype and shape as sparse arrayg.)rr)rrrrzerosrs r_process_toarray_args_spbase._process_toarray_args?sy ?  "/00yyDJJ&#))tzz*A "011CHJ88DJJdjjF FrcZSSKJn U"UUU=(a [U[5(+5$)aQ 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)_sputilsrCrr)rUarraysmaxvalcheck_contentsrCs r_get_index_dtype_spbase._get_index_dtypeLs/" .v% . Pz$7P3PS Sr)rSr)unsafeTrQ)F)r)FF)NF)T)NN)NNN)rNF)urrrr__doc____array_priority__r _allow_ndpropertyintrVr[r`rfrkrprurzrrrrrr classmethodrrrrrrrrrstrrrrrrrr __nonzero__rrr#r(r,r/r3r7r:r>rArDrGrJrNrSrVrZr]rbrerkrnrqrtrrrr"rxrzr{rrrrrrrrrrrrrrrrrrrrrrrrarrrrr rrrrrr(r-r1r6r4r@rHrrrrrMrM=swGI  c  00*. C)MV@6>)) ''  8St LSc   4N K ((N, ++ $2; ******!4/./&&""#" "\?|$$/272 #$, -*"X55(+F>.)$$DL$$7(&#LE<DF77777 L7/K8ZI2V*4 --2'< GSrrMc\rSrSrSrSrg)riez3A namespace class to separate sparray from spmatrixrN)rrrrrKrrrrrres=rrc"[U[5$)akIs `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 )rrMxs rrrls> a !!rc"[U[5$)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 )rr rUs rrrs4 a ""r).rKnumpyrrDrrrrrr r r r _matrixr __all__Warningrr rr frozensetsintanarcsinarctansinhtanharcsinharctanhrintsignexpm1log1pdeg2radrad2degfloorceiltruncsqrt _ufuncs_with_fixed_point_at_zerorrMrrrrrrrpsR$777 7 G  -  m  EA12  A./  A+,  A'  A34   A12   A|$   A'(  A<=  Az?  B*+  B89  B-.  B;<  B+,  B./  B)*! "45,- $' 0$-  299bggrww  BGGRWWbhh"** BHHbggrxx.:$; eSeSP)>>//"D#r