CpjOSrSSKrSSKJrJr SSKrSSKrSSKJ r SSK J r /SQr \R\R\R \R"\R$\R&\R(\R*\R,\R.\R0\R2\R4\R6\R8\R:\R</r0r Sr!Sr"Sr#S r$S r%S-S jr&S.S \RN4S jjr(\RRS4Sjr*S/Sjr+S\RXS \RX\-\R\-4Sjr/S \04Sjr1S \04Sjr2S0SSS.S \04Sjjjr3S \04Sjr4S \04Sjr5S \04Sjr6SS.S \7\8S4S-4Sjjr9S1SS .S \7\8S44S!jjjr:S"r;S \04S#jr<S-S$\S%S\S&-S'\S S(4S)jjr=S*r>S1S+jr?S \RN4S,jr@g)2z+Utility functions for sparse matrix module N)AnyLiteral)prod) upcastgetdtypegetdata isscalarlike isintlikeisshape issequenceisdenseismatrix get_sum_dtypebroadcast_shapesc[R[U55nUbU$[R"U6n[ H4n[R "X!5(dM U[[U5'Us $ [SU<35e)aReturns the nearest supported sparse dtype for the combination of one or more types. upcast(t0, t1, ..., tn) -> T where T is a supported dtype Examples -------- >>> from scipy.sparse._sputils import upcast >>> upcast('int32') >>> upcast('bool') >>> upcast('int32','float32') >>> upcast('bool',complex,float) z#no supported conversion for types: ) _upcast_memogethashnp result_typesupported_dtypescan_cast TypeError)argstrs Q/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/scipy/sparse/_sputils.pyrrsq( d$A} ^^T "F  ;;v ! !'(Ld $H 9$B CCc[RU5nUbU$[[[R U56nU[U'U$)z9Same as `upcast` but taking dtype.char as input (faster).)rrrmaprdtype)rrs r upcast_charr!:s@A}BHHd#$AL HrcH[R"S/US9U-R$)zXDetermine data type for binary operation between an array of type `dtype` and a scalar. rr )rarrayr )r scalars r upcast_scalarr&Ds" HHaS & / 6 66rcLURR[R"[R5R:aURS:XaUR [R5$UR 5nUR5nU[R"[R5R :d2U[R"[R5R:a [S5eUR [R5$U$)z Down-cast index array to np.intp dtype if it is of a larger dtype. Raise an error if the array contains a value that is too large for intp. rzzCannot deal with arrays with indices larger than the machine maximum address size (e.g. 64-bit indices on 32-bit machine).) r itemsizerintpsizeastypemaxminiinfo ValueError)arrmaxvalminvals rdowncast_intp_indexr3Ks yyBHHRWW-666 88q=::bgg& & BHHRWW%)) )Vbhhrww6G6K6K-KHI Izz"''"" JrcURnUR(aU$[R"XR S5S9$)z Ensure that the data type of the NumPy array `A` has native byte order. `A` must be a NumPy array. If the data type of `A` does not have native byte order, a copy of `A` with a native byte order is returned. Otherwise `A` is returned. nativer#)r isnativerasarray newbyteorder)Adts r to_nativer;_s3 B {{ ::ax8 99rc<UcURnO[R"U5nU[;a.SR S[55n[ SUSUS35eU$![a/nUb[R"U5nSnANb[S5UeSnAff=f)aForm a supported numpy dtype based on input arguments. Returns a valid ``numpy.dtype`` from `dtype` if not None, or else ``a.dtype`` if possible, or else the given `default` if not None, or else raise a ``TypeError``. The resulting ``dtype`` must be in ``supported_dtypes``: bool_, int8, uint8, int16, uint16, int32, uint32, int64, uint64, longlong, ulonglong, float32, float64, longdouble, complex64, complex128, clongdouble Nzcould not interpret data typez, c38# UHoRv M g7fN)__name__).0rs r getdtype..s(N=M=Msz$scipy.sparse does not support dtype z . The only supported types are: .)r AttributeErrorrrrjoinr/)r adefaultnewdtypeesupported_dtypes_fmts rrros } HwwH88E?''#yy(N=M(NN?zJ::N9OqRS S O H"88G, ?@aG  Hs A"" B,B BBreturncZ[R"XUS9n[UR5 U$)z} This is a wrapper of `np.array(obj, dtype=dtype, copy=copy)` that will generate a warning if the result is an object array. )r copy)rr$rr )objr rMdatas rrrs' 88C4 0D TZZ Krc<^^U(dST3n[R"T5RmURS;aURST:a[ SU35e[UR 6T:a0URT:R5(a[ SU35eURRTSS9nURRTSS9nX44$URS:Xag[UR 6T:a2[U4S jUR55(a[ S U35e[U4S jUR55$URS :Xab[UR 6T:a0URT:R5(a[ S U35eURRTSS9nU$URS:XaURupgURSU-T:a [ S5e[UR 6T:a3URU-T:R5(a[ SU35eURRTSS9nURRTSS9nX44$[SURS35e)acSafely cast sparse array indices to `idx_dtype`. Check the shape of `A` to determine if it is safe to cast its index arrays to dtype `idx_dtype`. If any dimension in shape is larger than fits in the dtype, casting is unsafe so raise ``ValueError``. If safe, cast the index arrays to `idx_dtype` and return the result without changing the input `A`. The caller can assign results to `A` attributes if desired or use the recast index arrays directly. Unless downcasting is needed, the original index arrays are returned. You can test e.g. ``A.indptr is new_indptr`` to see if downcasting occurred. .. versionadded:: 1.15.0 Parameters ---------- A : sparse array or matrix The array for which index arrays should be downcast. idx_dtype : dtype Desired dtype. Should be an integer dtype (default: ``np.int32``). Most of scipy.sparse uses either int64 or int32. msg : str, optional A string to be added to the end of the ValueError message if the array shape is too big to fit in `idx_dtype`. The error message is ``f" values too large for {msg}"`` It should indicate why the downcasting is needed, e.g. "SuperLU", and defaults to f"dtype {idx_dtype}". Returns ------- idx_arrays : ndarray or tuple of ndarrays Based on ``A.format``, index arrays are returned after casting to `idx_dtype`. For CSC/CSR, returns ``(indices, indptr)``. For COO, returns ``coords``. For DIA, returns ``offsets``. For BSR, returns ``(indices, indptr)``. Raises ------ ValueError If the array has shape that would not fit in the new dtype, or if the sparse format does not use index arrays. Examples -------- >>> import numpy as np >>> from scipy import sparse >>> data = [3] >>> coords = (np.array([3]), np.array([1])) # Note: int64 arrays >>> A = sparse.coo_array((data, coords)) >>> A.coords[0].dtype dtype('int64') >>> # rescast after construction, raising exception if shape too big >>> coords = sparse.safely_cast_index_arrays(A, np.int32) >>> A.coords[0] is coords[0] # False if casting is needed False >>> A.coords = coords # set the index dtype of A >>> A.coords[0].dtype dtype('int32') zdtype csccsrzindptr values too large for zindices values too large for FrMcooc3H># UHoT:R5v M g7fr>)any)r@co max_values rrA+safely_cast_index_arrays..s=HbN''))Hs"zcoords values too large for c3B># UHoRTSS9v M g7f)FrVN)r+)r@rZ idx_dtypes rrAr\sI"YYyuY5sdiazoffsets values too large for bsrz!indptr values too large for {msg}zFormat zP is not associated with index arrays. DOK and LIL have dict and list, not array.)rr.r,formatindptrr/shapeindicesrYr+coordstupleoffsets blocksizer) r9r^msgrdrbrgRCr[s ` @rsafely_cast_index_arraysrls_| yk"#''Ixx>! 88B<) #;C5AB B =9 $ I%**,, #@!FGG))""95"97 U  =9 $=AHH=== #?u!EFFIIII U  =9 $ I%**,, #@!FGG))""95"9 U {{ 88B>> import numpy as np >>> from scipy import sparse >>> # select index dtype based on shape >>> shape = (3, 3) >>> idx_dtype = sparse.get_index_dtype(maxval=max(shape)) >>> data = [1.1, 3.0, 1.5] >>> indices = np.array([0, 1, 0], dtype=idx_dtype) >>> indptr = np.array([0, 2, 3, 3], dtype=idx_dtype) >>> A = sparse.csr_array((data, indices, indptr), shape=shape) >>> A.indptr.dtype dtype('int32') >>> # select based on larger of existing arrays and shape >>> shape = (3, 3) >>> idx_dtype = sparse.get_index_dtype(A.indptr, maxval=max(shape)) >>> idx_dtype r)rintcr(int64int32r.r-r, isinstancendarrayr7rr r* issubdtypeinteger)arraysr1check_contentsint32minint32maxr0r2s rget_index_dtyperzs1R wwyQxxxx*../Hxx*../H &!  88O&"**%%jjo{{399bhh//88q=]]399bjj99 WWYF WWYF)f.@ 88O 88Orr cURS:Xa:[R"U[R5(a[R$[R"U[R5(a[R$U$)z Mimic numpy's casting for np.sumu)kindrruintint_r#s rrrOsN zzSR[[88ww {{5"''""ww Lrc~[R"U5=(d! [U5=(a URS:H$)z8Is x either a scalar, an array scalar, or a 0-dim array?r)risscalarr ndimxs rr r Xs& ;;q> 9gaj8QVVq[9rc [R"U5S:wag[R"U5 g![[ 4aI [ [U5U:H5nO![[ 4a gf=fU(a Sn[ U5eUs$f=f)zkIs x appropriate as an index into a sparse matrix? Returns True if it can be cast safely to a machine int. rFz4Inexact indices into sparse matrices are not allowedT)rroperatorindexrr/boolint)r loose_intris rr r ]s  wwqzQ q  z " SVq[)I:&   HCS/ !s34B AB A1-B 0A11B  B )T)allow_ndcheck_ndc[U5nU(aXB;agUH&n[U5(d gU(dMUS:dM& g g)zIs x a valid tuple of dimensions? If nonneg, also checks that the dimensions are non-negative. Shapes of length in the tuple allow_nd are allowed. FrT)lenr )rnonnegrrrds rr r ssA q6DD( || 6a!e  rc[U[[-5=(a. [U5S:H=(d [R "US5=(d0 [U[R 5=(a URS:H$)Nr)rrlistrfrrrrsrrs rr r sW 4%< (/ Vq[ -BKK!- : 2:: & 8AFFaK;rc[U[[-5=(a# [U5S:=(a [ US5=(d0 [U[ R 5=(a URS:H$)Nrr)rrrrfrr rrsrrs rrrsV 4%< (- VaZ-&qt, 8 2:: & 6166Q;9rc6[U[R5$r>)rrrrsrs rr r s a $$rr)r.clUcgUS:Xa [S5e[U[5(da[R"[R "[ U55[R5(d[S[ U535eU4n/nUHSn[U5(d[SUS35eUS:aX1- nUS:dX1:a [S5eURU5 MU [U5nU[[U55:wa [S5eXA:a [S 5eXA:Xag[U5$) NzWsparse does not accept 0D axis (). Either use toarray (for dense) or copy (for sparse).z+axis must be an integer/tuple of ints, not z axis must be an integer. (given )rzaxis out of range for ndimzduplicate value in axisz axis tuple has too many elements) r/rrrfrrtr typerurr appendrset)axisr canon_axisaxlen_axiss r validateaxisrs! | rz $  dE " "}}RXXd4j12::>>I$t*VW WwJ}}>rd!DE E 6 JB 6RZ9: :":H3s:''233 ;<<  Z  r)rc[U5S:Xa [S5e[U5S:Xa"[US5n[SU55nO[SU55nUcD[U5U;a[ SUSU<35e[S U55(a [ S 5eO[U5n[U5VVs/sHupgUS:dM UPM nnnU(d"[U5n X:wa[ S US U35eO}[U5S:XacUSn [USU XJS-S-5n [X[5upU S:wa#[S U55n[ S US U35eUSU U 4-XJS-S-nO [ S5e[U5U;a[ SUSU<35eU$![a [R "US54nGNif=fs snnf)aImitate numpy.matrix handling of shape arguments Parameters ---------- args : array_like Data structures providing information about the shape of the sparse array. current_shape : tuple, optional The current shape of the sparse array or matrix. If None (default), the current shape will be inferred from args. allow_nd : tuple of ints, optional default: (2,) If shape does not have a length in the tuple allow_nd an error is raised. Returns ------- new_shape: tuple The new shape after validation. rz8function missing 1 required positional argument: 'shape'rc3N# UHn[R"U5v M g7fr>rrr@args rrAcheck_shape..sHZchnnS11Z#%c3N# UHn[R"U5v M g7fr>rrs rrArs>#(..--rNzshape must have length in z. Got new_shape=c3*# UH oS:v M g7f)rNr)r@rs rrArs(i1uisz#'shape' elements cannot be negativezcannot reshape array of size z into shape c34# UHoS:aSOUv M g7f)rnewshapeNr)r@rs rrArs!PiA*1">>  y> )9(CT)VW W (i( ( (BC C )M* +4I*>H*>$!!a%A*>HIH' #@#/ {"<==(! "a '#A&DYu- q&'0BBCI%+L%D "KA~!!Pi!PP  #@#/ {"<==!%4(K>9I1fg G G  $GGcdU(dgUVs/sH$n[U[[-5(aUOU4PM& nn[U[S9n[U5nUHOnXLaM [ U[ U5*S9H.upEUS:wdM XSU:wdMX4S:wa [ S5eXSU'M0 MQ /UQ7$s snf)aCheck if shapes can be broadcast and return resulting shape This is similar to the NumPy ``broadcast_shapes`` function but does not check memory consequences of the resulting dense matrix. Parameters ---------- *shapes : tuple of shape tuples The tuple of shapes to be considered for broadcasting. Shapes should be tuples of non-negative integers. Returns ------- new_shape : tuple of integers The shape that results from broadcasting th input shapes. r)key)startrz-shapes cannot be broadcast to a single shape.)rrrfrr,rrr/)shapesshpbig_shpoutrrs rrrs" JP Q&3ZUT\22c>&F Q&c"G w-C > c#c(3DAAv!1v+6Q;$%TUUA 4 S7NRs+B-c[[RRS5SS5nUSL=(a [ X5$)zN Check whether object is pydata/sparse matrix, avoiding importing the module. sparse SparseArrayN)getattrsysmodulesrrr)mbase_clss ris_pydata_spmatrixrs4s{{x0-FH 4  ;Jq$;;rr target_formatrR accept_fvzsp.spmatrix | Anyc[U5(aFURUS9nUbURU5nU$URS;aUR 5nU$![a UR5nNTf=f)zS Convert a pydata/sparse array to scipy sparse matrix, pass through anything else. )rrR)rto_scipy_sparserasformatratocsc)rrrs rconvert_pydata_sparse_to_scipyr$s# (%% %:C  $,,}-C JZZ~ -))+C J  (%%'C (sAA65A6ch[R"U0UD6R[R5$r>)rr$viewmatrix)rkwargss rrrAs% 88T $V $ ) )")) 44rc[U[R5(aUbURU:XaU$[R"XS9R [R5$)Nr#)rrrrr r7r)rOr s rasmatrixrEsE$ "" u9L ::d ( - -bii 88rcF[U[RR5(aUR 5$[U[R 5(a8[ R"UR5URURS9$[U[R5(aU[ R"URURS9n[RRURU5 U$UR!5R 5$)zAccess nonzero values, possibly after summing duplicates. Parameters ---------- s : sparse array Input sparse array. Returns ------- data: ndarray Nonzero values of the array, with shape (s.nnz,) )r countr#)rrsp_data _data_matrix _deduped_data dok_arrayrfromitervaluesr nnz lil_arrayempty _csparsetoolslil_flatten_to_arrayrOtocoo)srOs r_todatarMs!RXX**++  !R\\""{{188:QWWAEEBB!R\\""xxQWW- --affd; 779 " " $$r)NN)NF)rNF)Fr>)A__doc__rtypingrrrnumpyrmathr scipy.sparserr__all__bool_byteubyteshortushortrouintclongulonglonglong ulonglongfloat32float64 longdouble complex64 complex128 clongdoublerrrr!r&r3r;rrsrrqrlrzr rgenericrrr r r r rr rfrrrrrrrrrrrrrs  HHbggrxx299bggHHbggrxxbllJJ BMMLL"--A  DD 7( : < BJJ +-((kF\EPbhhbjj1A&A:t: D,$;T; 949 %$% !#!U38_t%;#!L=d=uS#X=@B