o װiZ@szdZddlZddlmZddlmZddlmZddlmZddlmZddl Z zddl Z dZ Wn e y;d Z Ynwee je jfZee jfZed d d d ZeddddZddZddZeddddZddZddZddZejd d!d"d#dd$Zejd%d&d'd(dd$Z d@d)d*Z ed+d,d-d.Z!Gd/d0d0e"Z#d1d2Z$d3d4Z%d5d6Z&d7d8Z'dAd:d;Z(dd?Z*dS)Bz*Indexing mixin for sparse matrix classes. N)_core) isspmatrix)spmatrix)device)runtimeTFzT d, S ind, int32 minorz raw T answerz+if (ind == minor) atomicAdd(&answer[0], d);#cupyx_scipy_sparse_compress_getitemz"T real, T imag, S ind, int32 minorz$raw T answer_real, raw T answer_imagzo if (ind == minor) { atomicAdd(&answer_real[0], real); atomicAdd(&answer_imag[0], imag); } +cupyx_scipy_sparse_compress_getitem_complexc CsT|||d}t|dt|d}}||}|||}|||} | ||fS)aEReturn a submatrix of the input sparse matrix by slicing major axis. Args: Ax (cupy.ndarray): data array from input sparse matrix Aj (cupy.ndarray): indices array from input sparse matrix Ap (cupy.ndarray): indptr array from input sparse matrix start (int): starting index of major axis stop (int): ending index of major axis Returns: Bx (cupy.ndarray): data array of output sparse matrix Bj (cupy.ndarray): indices array of output sparse matrix Bp (cupy.ndarray): indptr array of output sparse matrix r)int) AxAjApstartstop start_offset stop_offsetBpBjBxrM/home/ubuntu/.local/lib/python3.10/site-packages/cupyx/scipy/sparse/_index.py_get_csr_submatrix_major_axis+s    rc Csn||k||k@}tj|jd|jd}d|d<||dd<tj||d||}|||}||} | ||fS)aEReturn a submatrix of the input sparse matrix by slicing minor axis. Args: Ax (cupy.ndarray): data array from input sparse matrix Aj (cupy.ndarray): indices array from input sparse matrix Ap (cupy.ndarray): indptr array from input sparse matrix start (int): starting index of minor axis stop (int): ending index of minor axis Returns: Bx (cupy.ndarray): data array of output sparse matrix Bj (cupy.ndarray): indices array of output sparse matrix Bp (cupy.ndarray): indptr array of output sparse matrix r dtyperNout)cupyemptysizercumsum) r r rrrmaskmask_sumrrrrrr_get_csr_submatrix_minor_axisDs   r#zNint32 out_rows, raw I rows, raw int32 Ap, raw int32 Aj, raw T Ax, raw int32 Bpzint32 Bj, T BxaD const I row = rows[out_rows]; // Look up starting offset const I starting_output_offset = Bp[out_rows]; const I output_offset = i - starting_output_offset; const I starting_input_offset = Ap[row]; Bj = Aj[starting_input_offset + output_offset]; Bx = Ax[starting_input_offset + output_offset]; $cupyx_scipy_sparse_csr_row_index_kerc Csxt|}tj|jd|jd}d|d<tj|||dddt|d}t||}t||||||\}} | ||fS)aPopulate indices and data arrays from the given row index Args: Ax (cupy.ndarray): data array from input sparse matrix Aj (cupy.ndarray): indices array from input sparse matrix Ap (cupy.ndarray): indptr array from input sparse matrix rows (cupy.ndarray): index array of rows to populate Returns: Bx (cupy.ndarray): data array of output sparse matrix Bj (cupy.ndarray): indices array of output sparse matrix Bp (cupy.ndarray): indptr array for output sparse matrix r rrNrr ) rdiffrrrr r _csr_indptr_to_coo_rows_csr_row_index_ker) r r rrowsrow_nnzrnnzout_rowsrrrrr_csr_row_indexqs    r,cCsbddlm}tj|tjd}t}tj r|dkrt d| ||j j ||jd|j j |j|S)Nr)cusparserz@hipSPARSE currently cannot handle sparse matrices with null ptrsr )cupy_backends.cuda.libsr-rrnumpyint32rget_cusparse_handleris_hip ValueErrorxcsr2coodataptrrCUSPARSE_INDEX_BASE_ZERO)r*rr-r+handlerrrr&s r&c Cstj||d}tj||d}t||g}t||}||}||}||}tj|jdd} t|||| |jdd|| || || fS)z;Find the unique indices for each row and keep only the lastrboolr r)rasarraystacklexsortastypeonesr_unique_mask_kern) ijx idx_dtypestackedorderindptr_insertsindices_inserts data_insertsr!rrr_select_last_indicess rJzqraw I insert_indices, raw T insert_values, raw I insertion_indptr, raw I Ap, raw I Aj, raw T Ax, raw I Bpzraw I Bj, raw T Bxa const I input_row_start = Ap[i]; const I input_row_end = Ap[i+1]; const I input_count = input_row_end - input_row_start; const I insert_row_start = insertion_indptr[i]; const I insert_row_end = insertion_indptr[i+1]; const I insert_count = insert_row_end - insert_row_start; I input_offset = 0; I insert_offset = 0; I output_n = Bp[i]; I cur_existing_index = -1; T cur_existing_value = -1; I cur_insert_index = -1; T cur_insert_value = -1; if(input_offset < input_count) { cur_existing_index = Aj[input_row_start+input_offset]; cur_existing_value = Ax[input_row_start+input_offset]; } if(insert_offset < insert_count) { cur_insert_index = insert_indices[insert_row_start+insert_offset]; cur_insert_value = insert_values[insert_row_start+insert_offset]; } for(I jj = 0; jj < input_count + insert_count; jj++) { // if we have both available, use the lowest one. if(input_offset < input_count && insert_offset < insert_count) { if(cur_existing_index < cur_insert_index) { Bj[output_n] = cur_existing_index; Bx[output_n] = cur_existing_value; ++input_offset; if(input_offset < input_count) { cur_existing_index = Aj[input_row_start+input_offset]; cur_existing_value = Ax[input_row_start+input_offset]; } } else { Bj[output_n] = cur_insert_index; Bx[output_n] = cur_insert_value; ++insert_offset; if(insert_offset < insert_count) { cur_insert_index = insert_indices[insert_row_start+insert_offset]; cur_insert_value = insert_values[insert_row_start+insert_offset]; } } } else if(input_offset < input_count) { Bj[output_n] = cur_existing_index; Bx[output_n] = cur_existing_value; ++input_offset; if(input_offset < input_count) { cur_existing_index = Aj[input_row_start+input_offset]; cur_existing_value = Ax[input_row_start+input_offset]; } } else { Bj[output_n] = cur_insert_index; Bx[output_n] = cur_insert_value; ++insert_offset; if(insert_offset < insert_count) { cur_insert_index = insert_indices[insert_row_start+insert_offset]; cur_insert_value = insert_values[insert_row_start+insert_offset]; } } output_n++; } 1cupyx_scipy_sparse_csr_copy_existing_indices_kern) no_returnz#raw I rows, raw I cols, raw I orderz raw bool maskaT I cur_row = rows[i]; I next_row = rows[i+1]; I cur_col = cols[i]; I next_col = cols[i+1]; I cur_order = order[i]; I next_order = order[i+1]; if(cur_row == next_row && cur_col == next_col) { if(cur_order < next_order) mask[i] = false; else mask[i+1] = false; } #cupyx_scipy_sparse_unique_mask_kernc CsD||dk|7<||dk|7<t|||||||||jd S)aPopulate data array for a set of rows and columns Args n_row : total number of rows in input array n_col : total number of columns in input array Ap : indptr array for input sparse matrix Aj : indices array for input sparse matrix Ax : data array for input sparse matrix Bi : array of rows to extract from input sparse matrix Bj : array of columns to extract from input sparse matrix Returns Bx : data array for output sparse matrix rr:)_csr_sample_values_kernr)n_rown_colrr r Bir not_found_valrrr_csr_sample_values'srSzWI n_row, I n_col, raw I Ap, raw I Aj, raw T Ax, raw I Bi, raw I Bj, I not_found_valzraw T Bxat const I j = Bi[i]; // sample row const I k = Bj[i]; // sample column const I row_start = Ap[j]; const I row_end = Ap[j+1]; T x = 0; bool val_found = false; for(I jj = row_start; jj < row_end; jj++) { if (Aj[jj] == k) { x += Ax[jj]; val_found = true; } } Bx[i] = val_found ? x : not_found_val; )cupyx_scipy_sparse_csr_sample_values_kernc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*S)+ IndexMixinzS This class provides common dispatching and validation logic for indexing. cCstrtjtjdkrtd||\}}t|t r@t|t r&| ||St|t r1| ||S|j dkr<|||Stdt|t rxt|t rP|||St|t ri|t dkrc||krc|S|||S|j dkrt|||Std|j dkrt|t r|||St|t r|||Sn5t|t r|||St|t rtd|jddkr|j dks|jddkr||dddf|St||\}}|j|jkrtd|jdkr|jt|j|jdS|||S)Nz1.4.0z,Sparse __getitem__() requires Scipy >= 1.4.0r zindex results in >2 dimensionsr'number of row and column indices differr) scipy_availabler/lib NumpyVersionscipy __version__NotImplementedError_parse_indices isinstance_int_scalar_types _get_intXintslice_get_intXslicendim_get_intXarray IndexError_get_sliceXintcopy_get_sliceXslice_get_sliceXarray_get_arrayXint_get_arrayXsliceshape_get_columnXarrayravelrbroadcast_arraysr __class__ atleast_2dr_get_arrayXarray)selfkeyrowcolrrr __getitem__ZsZ                       &   zIndexMixin.__getitem__c Cs||\}}t|tr.t|tr.tj||jd}|jdkr"td||||j ddSt|t rEtj | |j ddddf}nt|}t|t rntj | |j ddddf}|jdkrm|dddf}nt|}t||\}}|j |j krtdt|r|jdkr|d}|d}|j ddko|j ddk}|j ddko|j ddk}|s|j d|j dkr|s|j d|j dkstd|jdkrdS|jdd}|||||dStj||jd}t||\}} |jdkrdS||j }||||dS) Nrr z&Trying to assign a sequence to an itemrrVzshape mismatch in assignmentT)rg)r]r^r_rr;rrr3 _set_intXintflatraarangeindicesrl atleast_1drcrorertocoosum_duplicates_set_arrayXarray_sparsereshape_set_arrayXarray) rsrtrCrurvrArB broadcast_row broadcast_col_rrr __setitem__sV   $  "        zIndexMixin.__setitem__cCs.t|tjtjfr|jdkr|jdkrdSdS)Nrr TF)r^rndarrayr/rcr)rsindexrrr _is_scalarszIndexMixin._is_scalarcCs|j\}}t|\}}||r|}||r|}t|tr)t||d}n t|ts4|||}t|trCt||d}||fSt|tsN|||}||fS)Nrucolumn) rl _unpack_indexritemr^r__normalize_indexra _asindices)rsrtMNrurvrrrr]s          zIndexMixin._parse_indicesc CsNz tj||jjd}Wntttfytdw|jdvr#td||S)aConvert `idx` to a valid index for an axis with a given length. Subclasses that need special validation can override this method. idx is assumed to be at least a 1-dimensional array-like, but can have no more than 2 dimensions. rz invalid index)r zIndex dimension must be <= 2) rr;r{rr3 TypeError MemoryErrorrerc)rsidxlengthrCrrrrs zIndexMixin._asindicescCs&|j\}}t||d}||tdS)zReturn a copy of row i of the matrix, as a (1 x n) row vector. Args: i (integer): Row Returns: cupyx.scipy.sparse.spmatrix: Sparse matrix with single row rN)rlrrbrarsrArrrrrgetrow zIndexMixin.getrowcCs&|j\}}t||d}|td|S)zReturn a copy of column i of the matrix, as a (m x 1) column vector. Args: i (integer): Column Returns: cupyx.scipy.sparse.spmatrix: Sparse matrix with single column rN)rlrrfrarrrrgetcolrzIndexMixin.getcolcCtNr\rsrurvrrrr` zIndexMixin._get_intXintcCrrrrrrrrdrzIndexMixin._get_intXarraycCrrrrrrrrbrzIndexMixin._get_intXslicecCrrrrrrrrfrzIndexMixin._get_sliceXintcCrrrrrrrrhrzIndexMixin._get_sliceXslicecCrrrrrrrrirzIndexMixin._get_sliceXarraycCrrrrrrrrjrzIndexMixin._get_arrayXintcCrrrrrrrrk rzIndexMixin._get_arrayXslicecCrrrrrrrrm#rzIndexMixin._get_columnXarraycCrrrrrrrrr&rzIndexMixin._get_arrayXarraycCrrrrsrurvrCrrrrx)rzIndexMixin._set_intXintcCrrrrrrrr,rzIndexMixin._set_arrayXarraycCs6tj||jd}t||\}}||||dS)Nr)rr;toarrayrror)rsrurvrCrrrrr/sz"IndexMixin._set_arrayXarray_sparseN)__name__ __module__ __qualname____doc__rwrrr]rrrr`rdrbrfrhrirjrkrmrrrxrrrrrrrUUs,43   rUcCstr t|tjjSdS)NF)rWr^rZsparser)rrrr_try_is_scipy_spmatrix6srcCs&t|ttjtjfst|r|jdkr|jjdkr| St |}t|t rEt |dkr1|\}}n:t |dkrA|dt d}}n*tdt|}|durU|t d}}n|jdkrbt|t dfS|jdkrk| St|sst|rwtdt|}t|}|durt|}|durt|}||fS)a Parse index. Always return a tuple of the form (row, col). Valid type for row/col is integer, slice, or array of integers. Returns: resulting row & col indices : single integer, slice, or array of integers. If row & column indices are supplied explicitly, they are used as the major/minor indices. If only one index is supplied, the minor index is assumed to be all (e.g., [maj, :]). rbr rNzinvalid number of indiceszoIndexing with sparse matrices is not supported except boolean indexing where matrix and index are equal shapes.)r^rrrr/rrcrkindnonzero_eliminate_ellipsistuplelenrare_compatible_boolean_index_boolean_index_to_arrayr)rrurvrbool_rowbool_colrrrr<s@       rcCs |tur tdtdfSt|ts|St|D] \}}|tur#|}nq|St|dkr4tdtdfSt|dkr\|dkrT|dturLtdtdfStd|dfS|dtdfSg}||ddD] }|turq||qf|t|}tdd|}|d|tdf|t|S)z6Process indices with Ellipsis. Returns modified index.Nr rr)Ellipsisrar^r enumeraterappendmax)rrBvfirst_ellipsistailndnslicerrrrrs4      "rcCs6|| ks ||krtd|||dkr||7}|S)Nz{} ({}) out of ranger)reformat)rCdimnamerrrrs rrcCsZ|dkrdSzt|dkr|dnd}Wn tyYdSwt|tr&dSt||dS)zQReturns True if first element of the incompatible array type is boolean. r NrT)rrr^_bool_scalar_types_first_element_bool)rmax_dimfirstrrrrs  rcCs8t|dr|jjdkr |SdSt|rtj|ddSdS)ztReturns a boolean index array that can be converted to integer array. Returns None if no such array exists. rcrr9rN)hasattrrrrrr;rrrrrs  rcCs0|jdkr tdtj||jd}t|dS)Nr zinvalid index shaperr)rcrerarrayrwhererrrrrs r)r)r)+rrrcupyx.scipy.sparse._baserr cupy.cudarrr/ scipy.sparserZrW ImportErrorr integerint_r_r9bool_rElementwiseKernel_compress_getitem_kern_compress_getitem_complex_kernrr#r'r,r&rJ_insert_many_populate_arraysr@rSrNobjectrUrrrrrrrrrrrs         X_ b6$