_MhQdZddlZddlmZmZmZddlZddlZddl m Z ddl m Z ddlmZmZgdZejejejejejejejeeejejejejejejejej gZ!iZ"dZ#dZ$d Z%d Z&d Z'd-d Z(d.dej)fdZ*ej+dfdZ,d/dZ-dej.dej.fdZ/de0fdZ1de0fdZ2d0ddde0fdZ3de0fdZ4de0fdZ5de0fdZ6d1dZ7d2ddde8e9dffd Z:d!Z;d"Zd*Z?d2d+Z@dej)fd,ZAdS)3z, Utility functions for sparse matrix module N)AnyLiteralUnion)prod)np_longnp_ulong) upcastgetdtypegetdata isscalarlike isintlikeisshape issequenceisdenseismatrix get_sum_dtypebroadcast_shapesc tt|}||Stj|}t D]2}tj||r|tt|<|cS3td|)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) Nz#no supported conversion for types: ) _upcast_memogethashnp result_typesupported_dtypescan_cast TypeError)argstr s U/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/sparse/_sputils.pyr r s( d$$A} ^T "F  ;vq ! ! '(Ld $HHH  B$BB C CCct|}||Stttj|}|t|<|S)z9Same as `upcast` but taking dtype.char as input (faster).)rrr maprdtype)rrs r upcast_charr$;sDA}BHd##$AL Hr c@tjdg||zjS)z`Determine data type for binary operation between an array of type `dtype` and a scalar. rr#)rarrayr#)r#scalars r upcast_scalarr)Es# HaS & & & / 66r c|jjtjtjjkr|jdkr|tjS|}|}|tjtjjks'|tjtjjkrtd|tjS|S)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_indexr6Ls yBHRW--666 8q==::bg&& & BHRW%%) ) )Vbhrw6G6G6K-K-KHII Izz"'""" Jr ct|j}|jr|Stj||dS)a 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>`s= B { :arx88 9 9 99r cP|G |j}nR#t$r1}|tj|}ntd|Yd}~nd}~wwxYwtj|}|tvr?ddtD}t d|jd|d|S)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, c3$K|] }|jV dSN)__name__).0rs r zgetdtype..s$(N(N(N(N(N(N(N(Nr z$scipy.sparse does not support dtype z . The only supported types are: .)r#AttributeErrorrrrjoinr2name)r#adefaultnewdtypeesupported_dtypes_fmts rr r ps } HwHH H H H"8G,, ?@@aG H 8E??'''#yy(N(N=M(N(N(NNNR RR:NRRRSS S Os A'AAFreturnc\tj|||}t|j|S)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'r r#)objr#rQdatas rr r s1 8Cu4 0 0 0D TZ Kr c|sd}tjj|jdvr|jdkrt d|t|jkr/|jkrt d||j d}|j d}||fS|jdkrdt|jkr2tfd |j Drt d |tfd |j DS|jd kr_t|jkr/|j krt d ||j d}|S|jdkr|j \}}|jd|zkrt dt|jkr2|j|zkrt d||j d}|j d}||fStd|jd)a6 Safely 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 csccsrzindptr values too large for zindices values too large for FrQcooc3HK|]}|kVdSrB)any)rDco max_values rrEz+safely_cast_index_arrays..s3==bBN''))======r zcoords values too large for c3FK|]}|dVdS)FrZN)r.)rDr^ idx_dtypes rrEz+safely_cast_index_arrays..s3II"RYYyuY55IIIIIIr 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.)rr1r/formatindptrr2shapeindicesr]r.coordstupleoffsets blocksizer) r<ramsgrgrerjRCr_s ` @rsafely_cast_index_arraysros| #"y""##'Ix>!! 8B<) # #ACAABB B =9 $ $ I%**,, H !F!F!FGGG)""95"9977 U   =9 $ $====AH===== G !E!E!EFFFIIIIIIIIII U   =9 $ $ I%**,, H !F!F!FGGG)""95"99 U  {1 8B>> 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 Nr)rintcr+int64int32r1r0r/ isinstancendarrayr:rr#r- issubdtypeinteger)arraysr4check_contentsint32minint32maxr3r5s rget_index_dtyper~sKR wyyQxx**.//Hx**.//H &!! H  8O&"*%%  joo{39bh//  !8q==]39bj99! WWYYF WWYYF))f.@.@ 8OOO  8Or r#c|jdkr+tj|tjr tjStj|tjr tjS|S)z Mimic numpy's casting for np.sumu)kindrruintint_r&s rrrPsK zSR[88w {5"'""w Lr c^tj|pt|o |jdkS)z8Is x either a scalar, an array scalar, or a 0-dim array?r)risscalarrndimxs rr r Ys& ;q>> 9gajj8QVq[9r c4tj|dkrdS tj|ng#tt f$rS t t||k}n#tt f$rYYdSwxYw|rd}t ||cYSwxYwdS)zsIs 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)rroperatorindexrr2boolint)r loose_intrls rr r ^s  wqzzQu q z " SVVq[))II:&   555   "HCS// ! 4s31B A$#B$A:5B9A::BB))allow_ndctt|}||vrdS|D]}t|sdS|r |dkrdS dS)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 )rnonnegrrds rrrts` q66D 8u || 55  a!ee55 4r ct|ttzr-t|dkpt j|dp$t|tjo |jdkS)Nr)rvlistrirrrrwrrs rrrs\ 4%< ( (/ VVq[ -BK!-- : 2: & & 8AFaK;r ct|ttzr(t|dkrt |dp$t|t jo |jdkS)Nrr)rvrrirrrrwrrs rrrs] 4%< ( (- VVaZ-&qt,, 8 2: & & 616Q;9r c6t|tjSrB)rvrrwrs rrrs a $ $$r c@|dSt|}t|trtdt jt j|tjstd|jd|cxkrdksntddS)NzlTuples are not accepted for the 'axis' parameter. Please pass in one of the following: {-2, -1, 0, 1, None}.zaxis must be an integer, not rzaxis out of range) typervrirrrxr#ryrCr2)axis axis_types r validateaxisrs |T I $1011 1 =),,bj 9 9NL 8JLLMMM $OOOO!OOOO,--- Or .cXt|dkrtdt|dkr[ t|d}td|D}nD#t$rt j|df}YnwxYwtd|D}|Pt||vrt d|d|td |Drt d nt|}d t|D}|s+t|}||krt d |d |nt|dkr|d}t|d|||dzdz} t|| \} } | dkr.td|D} t d |d | |d|| fz||dzdz}nt dt||vrt d|d||S)a@Imitate 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'rc3>K|]}tj|VdSrBrrrDargs rrEzcheck_shape..s,HHchnS11HHHHHHr c3>K|]}tj|VdSrBrrs rrEzcheck_shape..s,>>#(.-->>>>>>r Nzshape must have length in z. Got new_shape=c3"K|] }|dkV dS)rNrp)rDrs rrEzcheck_shape..s&((q1u((((((r z#'shape' elements cannot be negativec$g|] \}}|dk |S)rrp)rDirs r zcheck_shape..s!HHH$!Q!a%%A%%%r zcannot reshape array of size z into shape c3*K|]}|dkrdn|VdS)rnewshapeNrp)rDrs rrEzcheck_shape..s.!P!PA**1!P!P!P!P!P!Pr z&can only specify one unknown dimension) rriterrirrr2r]r enumeratedivmod) r current_shaper shape_iter new_shape current_sizenegative_indexesnew_sizeskip specified unspecified remainder err_shapes r check_shapers$ 4yyA~~RSSS 4yyA~~ Id1gJHHZHHHHHII 4 4 4!Q003III 4 >>>>>>>  y>> ) )V(VV)VVWW W ((i((( ( ( DBCC C DM** IH)I*>*>HHH GIH<'' "<"<"<09"<"<===(! " "a ' '#A&DYuu- $q&''0BBCCI%+L)%D%D "KA~~!!P!Pi!P!P!PPP  "<"<"<09"<"<===!%4%(K>9Id1fgg.s1 R R RCZeT]33?cc# R R Rr )key)startrz-shapes cannot be broadcast to a single shape.)r/rrrr2)shapesbig_shpoutrrrs rrrs" r R R6 R R RF&c"""G w--C '>> c#c((333  DAqAvv!s1v++q6Q;;$%TUUUA   S77Nr c|dd}|dd}|r7tdd|||fS)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. orderrnrQFz-reshape() got unexpected keywords arguments: r@)poprrHkeys)kwargsrrQs rcheck_reshape_kwargsrst JJw $ $E ::fe $ $D 7699V[[]]336677 7 $;r cttjddd}|duot ||S)zV Check whether object is pydata/sparse matrix, avoiding importing the module. sparse SparseArrayN)getattrsysmodulesrrv)mbase_clss ris_pydata_spmatrixrs=s{x00-FFH 4  ;Jq($;$;;r r target_formatrV accept_fvz sp.spmatrixct|rq ||}n$#t$r|}YnwxYw|||}n|jdvr|}|S)z_ Convert a pydata/sparse array to scipy sparse matrix, pass through anything else. )rNrV)rto_scipy_sparserasformatrdtocsc)rrrs rconvert_pydata_sparse_to_scipyr's#  (%% %::CC ( ( (%%''CCC (  $,,}--CC Z~ - -))++C Js(A A c^tj|i|tjSrB)rr'viewmatrix)rrs rrrDs' 8T $V $ $ ) )") 4 44r ct|tjr| |j|kr|Stj||tjS)Nr&)rvrrr#r:r)rSr#s rasmatrixrHsP$ "" u9L9L :d% ( ( ( - -bi 8 88r ct|tjjr|St|tjr3t j||j |j St|tj rGt j |j |j }tj |j||S|S)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&)rvsp_data _data_matrix _deduped_data dok_arrayrfromitervaluesr#nnz lil_arrayempty _csparsetoolslil_flatten_to_arrayrStocoo)srSs r_todatarPs!RX*++!   !R\""C{188::QWAEBBBB!R\""xQW--- --afd;;; 7799 " " $ $$r )NN)NF)rpNF)F)rONrB)B__doc__rtypingrrrrnumpyrmathr scipy.sparserrscipy._lib._utilrr__all__bool_byteubyteshortushortrsuintclonglong ulonglongfloat32float64 longdouble complex64 complex128 clongdoublerrr r$r)r6r>r rwr ruror~r#rrr r rrrrrrirrrrrrrrrrpr rrs &&&&&&&&&&........   Hbgrx29bgHgxblJ BML"-A  DDDD   777( : : : <  BJ    +-(kFkFkFkF\EEEEPbh:t:::: D,$$;T;;;; 949999 %$%%%%.....=d===uS#X====@B"