+ LV-jgRRt^RIt^RIHtHtHt^RIt^RIt^RI H t ^RI H t ^RIHtHt.R.Ot]P$]P&]P(]P*]P,]P.]P0]]]P2]P4]P6]P8]P:]P<]P>]P@.t!/t"Rt#Rt$Rt%Rt&R t'R/R lt(R0R R llt)]PTR 3Rlt+R1Rlt,RRlt-RRlt.RRlt/R2RR3/RRlllt0RRlt1RRlt2RRlt3R^/R R!llt4R4RR3/R"R#lllt5R$t6R%t7R&R'lt8R/R(R)llt9R*t:R4R+lt;R,R-lt 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* f/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/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).)r r rmapr 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_scalarrEs" 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,Ls 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_nativer4`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 type, 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 rrjoinr()radefaultnewdtypeesupported_dtypes_fmts&&& rgetdtyperEps } HwwH88E?''#yy(N=M(NN?zJ::N9OqRS S O H"88G, ?@aG  Hs A$$ B/B BBc8V^8dQhR\P/#returnr ndarray)formats"r __annotate__rMs  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 rrEr)objrrOdatas&&& rgetdatarRs' 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)afSafely 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 : string, 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 FrOcooc3H<"TFqS8P4xK R#5ir8)any)r:co max_values& rr;+safely_cast_index_arrays..s=HbN''))H"Tzcoords values too large for c3H<"TFqPSRR7xK R#5i)FrUN)r$)r:rY idx_dtypes& rr;r[sI"YYyuY55r\diazoffsets 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%rLindptrr(shapeindicesrXr$coordstupleoffsets blocksizer) r2r^msgrgrerjRCrZs &f& @rsafely_cast_index_arraysros| 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 intcr!int64int32r'r&r% isinstancerKr0rrr# issubdtypeinteger)arraysr*check_contentsint32minint32maxr)r+s&&& rget_index_dtyper{s1R wwyQxxxx*../Hxx*../H &!  88O&"**%%jjo{{399bhh//88q=]]399bjj99 WWYF WWYF)f.@ 88O 88OrcXV^8dQhR\PR\P/#)rHrrI)r r)rLs"rrMrMPs"bhhrcVPR8Xd<\P!V\P4'd\P#\P!V\P4'd\P#V#)z Mimic numpy's casting for np.sumu)kindr ruintint_rs&r get_sum_dtyperPsN zzSR[[88ww {{5"''""ww Lrc$V^8dQhR\/#rGbool)rLs"rrMrMYs::t:rc\P!V4;'g#\V4;'dVP^8H#)z8Is x either a scalar, an array scalar, or a 0-dim array?)r isscalarisdensendimxs&r isscalarlikerYs, ;;q> 9 9gaj88QVVq[9rc$V^8dQhR\/#rGr)rLs"rrMrM^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_intrls& r isintliker^s  wwqzQ q  z " SVq[)I:&   HCS/ !s97B A! B!A72B6A77 BBBallow_ndc$V^8dQhR\/#rGr)rLs"rrMrMts$rc\V4pW29dR#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)rnonnegrrds&&$ risshaperts? q6D  || 6a!e  rc$V^8dQhR\/#rGr)rLs"rrMrMs;;T;rc \V\\,4;'d<\V4^8H;'gW\P !V^,4;'g2\V\P 4;'dVP^8H#)rtlistrirr rrKrrs&r issequencersi 4%< (// Vq[ : -BKK!- : : 2:: & 8 8AFFaK;rc$V^8dQhR\/#rGr)rLs"rrMrMs9949rc \V\\,4;'d1\V4^8;'d\ V^,4;'g2\V\ P 4;'dVP^8H#r)rtrrirrr rKrrs&rismatrixrsh 4%< (-- VaZ--&qt, 8 8 2:: & 6 6166Q;9rc$V^8dQhR\/#rGr)rLs"rrMrMs%%$%rc6\V\P4#r8)rtr rKrs&rrrs a $$rrcLV^8dQhR\\R3,R,/#)rHrI.Nrir)rLs"rrMrMs #!#!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(rtrir rurtypervrrappendrset)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,/#)rHrI.r)rLs"rrMrMs==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#5ir8rrr:args& rr;check_shape..sHZchnnS11Z#%c3N"TFp\P!V4xK R#5ir8rrs& rr;rs>#(..--rNzshape must have length in z. Got new_shape=c3*"TF q^8xK R#5i)rNr)r:rs& rr;rs(i1uisTFz#'shape' elements cannot be negativezcannot reshape array of size z into shape c36"TFq^8dRMTxK R#5i)rnewshapeNr)r:rs& rr;rs!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/CcVPRR4pVPRR4pV'd,\RRPVP44 24hW3#)a+Unpack keyword arguments for reshape function. This is useful because keyword arguments after star arguments are not allowed in Python 2, but star keyword arguments are. This function unpacks 'order' and 'copy' from the star keyword arguments (with defaults) and throws an error for any remaining. orderrnrOFz-reshape() got unexpected keywords arguments: r6)poprr?keys)kwargsrrOs& rcheck_reshape_kwargsrsY JJw $E ::fe $D G99V[[]3467 7 ;rc$V^8dQhR\/#rGr)rLs"rrMrM.s<rsP &&. HHbggrxx299bggHHgxbllJJ BMMLL"--A  DD 7( : < +-((kF\EP: ,$; 9 %#!q#!L=d==@B"<:59%r