+ nDjORt^RIt^RIHtHt^RIt^RIt^RIH t ^RI H t .R.Ot ]P]P]P ]P"]P$]P&]P(]P*]P,]P.]P0]P2]P4]P6]P8]P:]P<.t/t Rt!Rt"Rt#Rt$Rt%R/R lt&R0R R llt']PPR 3R lt)R1Rlt*RRlt+RRlt,RRlt-R2RR3RR/RRlllt.RRlt/RRlt0RRlt1R ^/R!R"llt2R4RR3/R#R$lllt3R%t4R&R'lt5R/R(R)llt6R*t7R4R+lt8R,R-lt9R#)5z+Utility functions for sparse matrix module NAnyLiteral)prodc\P\V44pVeV#\P!V!p\ F5p\P !W!4'gK!V\\V4&Vu# \RV: 24h)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)argstupcasts* O/data/cameron/venvs/s3viz/lib/python3.14/site-packages/scipy/sparse/_sputils.pyrrsq( d$A} ^^T "F  ;;v ! !'(Ld $H 9$B CCc\PV4pVeV#\\\P V4!pV\V&V#)z9Same as `upcast` but taking dtype.char as input (faster).)rrrmapr dtype)rrs* r upcast_charr:s@A}BHHd#$AL HrcV\P!^.VR7V,P#)zXDetermine data type for binary operation between an array of type `dtype` and a scalar. r)r arrayr)rscalars&&r upcast_scalarrDs" HHaS & / 6 66rcTVPP\P!\P4P8dVP^8Xd VP \P4#VP 4pVP4pV\P!\P4P 8g4V\P!\P4P8d \R4hVP \P4#V#)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. zzCannot deal with arrays with indices larger than the machine maximum address size (e.g. 64-bit indices on 32-bit machine).) ritemsizer intpsizeastypemaxminiinfo ValueError)arrmaxvalminvals& rdowncast_intp_indexr)Ks yyBHHRWW-666 88q=::bgg& & BHHRWW%)) )Vbhhrww6G6K6K-KHI Izz"''"" JrcVPpVP'dV#\P!WP R4R7#)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)risnativer asarray newbyteorder)Adts& r to_nativer1_s5 B {{{ ::ax8 99rcDVfVPpM\P!V4pV\9d/RP R\44p\ RV RV R24hV# \d1pTe\P!T4pRp?Le\R4ThRp?ii;i)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"TFqPxK R#5iN)__name__).0rs& r getdtype..s(N=M=Msz$scipy.sparse does not support dtype z . The only supported types are: .)rAttributeErrorr rr joinr%)radefaultnewdtypeesupported_dtypes_fmts&&& rgetdtyperAos } HwwH88E?''#yy(N=M(NN?zJ::N9OqRS S O H"88G, ?@aG  Hs A$$ B/B BBc8V^8dQhR\P/#returnr ndarray)formats"r __annotate__rIs  BJJ rc`\P!WVR7p\VP4V#)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. )rcopy)r rrAr)objrrKdatas&&& rgetdatarNs' 88C4 0D TZZ KrcLaaV'gRS 2p\P!S4PoVPR9dVPR,S8d\ RV 24h\VP !S8d2VPS8P4'd\ RV 24hVPPSRR7pVPPSRR7pW43#VPR8Xd\VP !S8dc\;QJd)V3RlVP4F 'gK RM RM!V3RlVP44'd\ R V 24h\;QJd!.V3R lVP4FNK 5#!V3R lVP44#VPR 8Xdi\VP !S8d2VPS8P4'd\ R V 24hVPPSRR7pV#VPR 8XdVPwrgVPR,V,S8d \ R4h\VP !S8d9VPV,S8P4'd\ RV 24hVPPSRR7pVPPSRR7pW43#\RVP R24h)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 zindptr values too large for zindices values too large for FrKcooc3H<"TFqS8P4xK R#5ir4)any)r6co max_values& rr7+safely_cast_index_arrays..s=HbN''))H"Tzcoords values too large for c3H<"TFqPSRR7xK R#5i)FrQN)r!)r6rU idx_dtypes& rr7rWsI"YYyuY55rXdiazoffsets 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.csccsr)r r$r"rHindptrr%shapeindicesrTr!coordstupleoffsets blocksizer) r/rZmsgrcrarfRCrVs &f& @rsafely_cast_index_arraysrks| yk"#''Ixx>! 88B<) #;C5AB B =9 $ I%**,, #@!FGG))""95"97 U  =9 $s=AHH=sss=AHH=== #?u!EFFuIIuIuIIII 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 intcrint64int32r$r#r" isinstancerGr-r rr issubdtypeinteger)arraysr'check_contentsint32minint32maxr&r(s&&& rget_index_dtyperws1R wwyQxxxx*../Hxx*../H &!  88O&"**%%jjo{{399bhh//88q=]]399bjj99 WWYF WWYF)f.@ 88O 88OrcV^8dQhR\PR\P\\P,,/#)rDrrE)r rtypegeneric)rHs"rrIrIOs0bhhbjj1A&ArcVPR8Xd<\P!V\P4'd\P#\P!V\P4'd\P#V#)z Mimic numpy's casting for np.sumu)kindr r uintint_rs&r get_sum_dtyperOsN zzSR[[88ww {{5"''""ww Lrc$V^8dQhR\/#rCbool)rHs"rrIrIXs::t:rc\P!V4;'g#\V4;'dVP^8H#)z8Is x either a scalar, an array scalar, or a 0-dim array?)r isscalarisdensendimxs&r isscalarlikerXs, ;;q> 9 9gaj88QVVq[9rc$V^8dQhR\/#rCr)rHs"rrIrI]sDrc.\P!V4^8wdR#\P!V4R# \\ 3dM\ \T4T8H4pM \\ 3dR#i;iT'dRp\ T4hTu#i;i)zkIs x appropriate as an index into a sparse matrix? Returns True if it can be cast safely to a machine int. Fz4Inexact indices into sparse matrices are not allowedT)r roperatorindexrr%rint)r loose_intrhs& r isintliker]s  wwqzQ q  z " SVq[)I:&   HCS/ !s97B A! B!A72B6A77 BBBallow_ndcheck_ndTc$V^8dQhR\/#rCr)rHs"rrIrIssrc\V4pV'd WB9dR#VF+p\V4'gR#V'gK!V^8gK*R# R#)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. FT)lenr)rnonnegrrrds&&$$ risshaperssA q6DD( || 6a!e  rc$V^8dQhR\/#rCr)rHs"rrIrIs;;T;rc \V\\,4;'d<\V4^8H;'gW\P !V^,4;'g2\V\P 4;'dVP^8H#)rplistrerr rrGrrs&r issequencersi 4%< (// Vq[ : -BKK!- : : 2:: & 8 8AFFaK;rc$V^8dQhR\/#rCr)rHs"rrIrIs9949rc \V\\,4;'d1\V4^8;'d\ V^,4;'g2\V\ P 4;'dVP^8H#r)rprrerrr rGrrs&rismatrixrsh 4%< (-- VaZ--&qt, 8 8 2:: & 6 6166Q;9rc$V^8dQhR\/#rCr)rHs"rrIrIs%%$%rc6\V\P4#r4)rpr rGrs&rrrs a $$rrcLV^8dQhR\\R3,R,/#)rDrE.Nrer)rHs"rrIrIs #!#!U38_t%;#!rcVfR#VR8Xd \R4h\V\4'gc\P!\P !\ V44\P4'g\R\ V4 24hV3p.pVF[p\V4'g\RV R24hV^8d W1, pV^8gW18d \R4hVPV4K] \V4pV\\V448wd \R4hWA8d \R4hWA8XdR#\V4#) 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 )zaxis out of range for ndimzduplicate value in axisz axis tuple has too many elements) r%rprer rqrryrrrrappendrset)axisr canon_axisaxlen_axiss&$ r validateaxisrs! | rz $  dE " "}}RXXd4j12::>>I$t*VW WwJ}}>rd!DE E 6 JB 6RZ9: :":H3s:''233 ;<<  Z  rc>V^8dQhR\\R3,/#)rDrE.r)rHs"rrIrIs==uS#X=rc\V4^8Xd \R4h\V4^8XdA\V^,4p\;QJd.RV4FNK 5M !RV44pM,\;QJd.RV4FNK 5M !RV44pVfj\V4V9d\ RV RV: 24h\;QJdRV4F 'gK RM R M !RV44'd \ R 4hEM\V4p\V4UUu.uFwrgV^8gKVNK pppV'g$\V4p W8wd\ R V R V 24hM\V4^8XdV^,p \VRV WJ^,R,4p \W[4wrV ^8wd>\;QJd.R V4FNK 5M !R V44p\ R V R V 24hVRV V 3,WJ^,R,pM \ R4h\V4V9d\ RV RV: 24hV# \d#\P !T^,43pELi;iuuppi)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. z8function missing 1 required positional argument: 'shape'c3N"TFp\P!V4xK R#5ir4rrr6args& rr7check_shape..sHZchnnS11Z#%c3N"TFp\P!V4xK R#5ir4rrs& rr7rs>#(..--rNzshape must have length in z. Got new_shape=c3*"TF q^8xK R#5i)rNr)r6rs& rr7rs(i1uisTFz#'shape' elements cannot be negativezcannot reshape array of size z into shape c36"TFq^8dRMTxK R#5i)rnewshapeNr)r6rs& rr7rs!PiA*1">EE>>>  y> )9(CT)VW W 3(i(333(i( ( (BC C )M* +4I*>H*>$!!a%AA*>HIH' #@#/ {"<==(! "a '#A&DYu- q&'0BBCI%+L%D "KA~!E!Pi!PEE!Pi!PP  #@#/ {"<==!%4(K>9I1fg&F Q&c"G w-C > c#c(3DAAv!1v+6Q;$%TUUA 4 S7NRs/Cc$V^8dQhR\/#rCr)rHs"rrIrIs<rsT  HHbggrxx299bggHHbggrxxbllJJ BMMLL"--A  DD 7( : < +-((kF\EP: ,$; 9 %#!q#!L=d==@B<:59%r