9jFSSKJr SSKrSSKrSSKrSSKrSSKrSSKJr SSK J r "SS5r "SS\ 5r \ "5r "S S \ 5r\"5r\4S jrS rSS jrSSjrSSjrSSjrSSjrSSjrSSjrg)) annotationsN) from_data)joinc4\rSrSrSrSrS SjrSrSrSr g) AxisConcatenatorzTranslates slice objects to concatenation along an axis. For detailed documentation on usage, see :func:`cupy.r_`. This implementation is partially borrowed from NumPy's one. cX2- nUS:aXES-- n[[U55nUnUSUXeS-XgU-nURU5$)Nr)listrange transpose) selfobjndimndmintrans1dk2defaxesk1axess Q/home/wildlama/miniconda3/lib/python3.13/site-packages/cupy/_indexing/generate.py _output_objAxisConcatenator._output_objs^ \ Q; Av GuU|$ s|gcl* rN}}T""c4XlX@lX lX0lgN)axisrmatrixr)rrrrrs r__init__AxisConcatenator.__init__"s    rcURnURn/n/n/n[U[5(a[e[U[ 5(dU4n[ U5GH upx[U[5(a[e[U[5(aUS:wa [S5e[e[U5[R;a&[R"XS9n URU5 Oi[R"USUS9n US:a<[R"USS9Rn US:waX:aUR!XX25n URU 5 URU 5 GM [R""/UQUVs/sHoUPM snQ76n U bUHnXHR%U 5XH'M [&R("[ U5UR*S 9$s snf) Nrz+special directives must be the first entry.)rF)copyrr r")r)rr isinstancestrNotImplementedErrortuple enumerateslice ValueErrortypenumpy ScalarTyperarrayappendrr result_typeastyper concatenater) rkeyrrobjsarraysscalarsiknewobjr final_dtypes r __getitem__AxisConcatenator.__getitem__(s,,  c3  % %#u%%&CcNDA!U##))As##6$EGG))aE,,,"8q!"eD19$??159>>D"}!%!1!1&!O f% KK '#*''LL72K7aq672KL  "'..5d $))<< 3LsG cg)Nr)rs r__len__AxisConcatenator.__len__Osr)rrrrN)rFr r$) __name__ __module__ __qualname____firstlineno____doc__rrr<r@__static_attributes__r?rrrrs# %=Nrrc(^\rSrSrU4SjrSrU=r$)CClassSc$>[TU]SSSS9 g)Nr$r)rrsuperrr __class__s rrCClass.__init__Us 1a0rr?rBrCrDrErrG __classcell__rPs@rrIrISs 11rrIc(^\rSrSrU4SjrSrU=r$)RClasstc">[TU]5 grrMrOs rrRClass.__init__vs rr?rRrTs@rrVrVts rrVc[U5n[U5nSU-n[R"U4U-US9n[ U5H9upV[R "XaS9R USUU4-X5S-S-5XE'M; U$)a{Returns an array representing the indices of a grid. Computes an array where the subarrays contain index values 0,1,... varying only along the corresponding axis. Args: dimensions: The shape of the grid. dtype: Data type specifier. It is int by default. Returns: ndarray: The array of grid indices, ``grid.shape = (len(dimensions),) + tuple(dimensions)``. Examples -------- >>> grid = cupy.indices((2, 3)) >>> grid.shape (2, 2, 3) >>> grid[0] # row indices array([[0, 0, 0], [1, 1, 1]]) >>> grid[1] # column indices array([[0, 1, 2], [0, 1, 2]]) .. seealso:: :func:`numpy.indices` r dtypeNr )r(lencupyemptyr)arangereshape) dimensionsr]Nshaperesr8dims rindicesrhs<z"J JA 1HE **aTJ&e 4CJ'S.66 "1I 1uv . ( Jrc"/n[U5n[U5Hup4[R"U5nURS:wa [ S5eUR S:XaUR[R5n[R"UR[R5(aUR5unURSU-UR 4-SX#- S- --5nUR!U5 M [#U5$)aConstruct an open mesh from multiple sequences. This function takes N 1-D sequences and returns N outputs with N dimensions each, such that the shape is 1 in all but one dimension and the dimension with the non-unit shape value cycles through all N dimensions. Using `ix_` one can quickly construct index arrays that will index the cross product. ``a[cupy.ix_([1,3],[2,5])]`` returns the array ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``. Args: *args: 1-D sequences Returns: tuple of ndarrays: N arrays with N dimensions each, with N the number of input sequences. Together these arrays form an open mesh. Examples -------- >>> a = cupy.arange(10).reshape(2, 5) >>> a array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]) >>> ixgrid = cupy.ix_([0,1], [2,4]) >>> ixgrid (array([[0], [1]]), array([[2, 4]])) .. warning:: This function may synchronize the device. .. seealso:: :func:`numpy.ix_` r z!Cross index must be 1 dimensionalrr[)r^r)rasarrayrr+sizer2r-intpr_ issubdtyper]bool_nonzerorbr0r()argsoutndr9news rix_rtsN C TBD/$ 88q=@A A 88q=**UZZ(C ??399djj 1 1;;=DCkk$(chh[0426A:3FFG 3" :rc<[U5n[U5U:wa[SRU55eUHEn[U[R 5(aM$[ SR[U555e [U[5(aU4U-n[R"[RU5[R"[R5R :a [S5eSnS/U-nUcSOUR#5nUS:Xa&[%US- SS5HnXaUS--nXgU'M O3US:Xa"[%SU5HnXaUS- -nXgU'M O [S 5e[R&"U6n[R("US R*[RS 9n [-XX5GHQupZp[U [R.5(d [ S 5e[R0"U [RS 5(dB[ SRU R2[R"5R255eU R5[RSS9n U S:XaA[R6"[R8"X:U S :55(a [S5eOGU S:Xa[R:"U S US- 5n O%U S:XaX-n O[SRU 55eXU -- n GMT U $)ar Converts a tuple of index arrays into an array of flat indices, applying boundary modes to the multi-index. Args: multi_index (tuple of cupy.ndarray) : A tuple of integer arrays, one array for each dimension. dims (tuple of ints): The shape of array into which the indices from ``multi_index`` apply. mode ('raise', 'wrap' or 'clip'), optional: Specifies how out-of-bounds indices are handled. Can specify either one mode or a tuple of modes, one mode per index: - *'raise'* -- raise an error - *'wrap'* -- wrap around (default) - *'clip'* -- clip to the range In 'clip' mode, a negative index which would normally wrap will clip to 0 instead. order ('C' or 'F'), optional: Determines whether the multi-index should be viewed as indexing in row-major (C-style) or column-major (Fortran-style) order. Returns: raveled_indices (cupy.ndarray): An array of indices into the flattened version of an array of dimensions ``dims``. .. warning:: This function may synchronize the device when ``mode == 'raise'``. Notes ----- Note that the default `mode` (``'wrap'``) is different than in NumPy. This is done to avoid potential device synchronization. Examples -------- >>> cupy.ravel_multi_index(cupy.asarray([[3,6,6],[4,5,1]]), (7,6)) array([22, 41, 37]) >>> cupy.ravel_multi_index(cupy.asarray([[3,6,6],[4,5,1]]), (7,6), ... order='F') array([31, 41, 13]) >>> cupy.ravel_multi_index(cupy.asarray([[3,6,6],[4,5,1]]), (4,6), ... mode='clip') array([22, 23, 19]) >>> cupy.ravel_multi_index(cupy.asarray([[3,6,6],[4,5,1]]), (4,4), ... mode=('clip', 'wrap')) array([12, 13, 13]) >>> cupy.ravel_multi_index(cupy.asarray((3,1,4,1)), (6,7,8,9)) array(1621) .. seealso:: :func:`numpy.ravel_multi_index`, :func:`unravel_index` z5parameter multi_index must be a sequence of length {}z-{} object cannot be interpreted as an integerzQinvalid dims: array size defined by dims is larger than the maximum possible sizer CrLr$Forder not understoodrr\z+elements of multi_index must be cupy arrays same_kindzgmulti_index entries could not be cast from dtype('{}') to dtype('{}') according to the rule 'same_kind'Fr#raisez"invalid entry in coordinates arrayclipwrapzUnrecognized mode: {})r^r+formatr%numbersIntegral TypeErrorr,r& functoolsreduceoperatormulr_iinfoint64maxupperr broadcast_arrayszerosrezipndarraycan_castr]r2any logical_orr{) multi_indexdimsmodeorderrds ravel_stridesr8raveled_indicesstrideidx_modes rravel_multi_indexrsp t9D ;4 t & &!W--..?FFG  $x$ d+djj.D.H.HH:; ; AC$JM=CekkmE |taxR(AQKA ! ) #q$AQKA !  /00''5KjjQ!5!5TZZHO!$T+!L3#t||,,IJ J}}S$**k::DDJFIItzz|11E34 4jj%j0 G xx#':;; !EFF< f_))CAE*C f_'C4;;EBC CC<')"M* rcVUcSOUR5nUS:Xa [U5nOUS:XaO [S5e[R"U[R S5(dB[ SRUR[R "5R55eUS:R5(a [S5e/nUHnURX-5 X-nM US:R5(a [S5eUS:Xa [U5n[U5$)aConverts array of flat indices into a tuple of coordinate arrays. Args: indices (cupy.ndarray): An integer array whose elements are indices into the flattened version of an array of dimensions :obj:`dims`. dims (tuple of ints): The shape of the array to use for unraveling indices. order ('C' or 'F'): Determines whether the indices should be viewed as indexing in row-major (C-style) or column-major (Fortran-style) order. Returns: tuple of ndarrays: Each array in the tuple has the same shape as the indices array. Examples -------- >>> cupy.unravel_index(cupy.array([22, 41, 37]), (7, 6)) (array([3, 6, 6]), array([4, 5, 1])) >>> cupy.unravel_index(cupy.array([31, 41, 13]), (7, 6), order='F') (array([3, 6, 6]), array([4, 5, 1])) .. warning:: This function may synchronize the device. .. seealso:: :func:`numpy.unravel_index`, :func:`ravel_multi_index` rvrwrxryzlIterator operand 0 dtype could not be cast from dtype('{}') to dtype('{}') according to the rule 'same_kind'rzinvalid entry in index array) rreversedr+r_rrrr}r]rr0r()rhrrunraveled_coordsrgs r unravel_indexrls <=CekkmE |~ # /00 ==$**k : : 228& tzz|11334 4 ! 788 .. ! 788 |#$45 ! ""rcv[R"X4[RS9nU"X25R5$)a Return the indices to access (n, n) arrays, given a masking function. Assume `mask_func` is a function that, for a square array a of size ``(n, n)`` with a possible offset argument `k`, when called as ``mask_func(a, k)`` returns a new array with zeros in certain locations (functions like :func:`~cupy.triu` or :func:`~cupy.tril` do precisely this). Then this function returns the indices where the non-zero values would be located. Args: n (int): The returned indices will be valid to access arrays of shape (n, n). mask_func (callable): A function whose call signature is similar to that of :func:`~cupy.triu`, :func:`~tril`. That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. `k` is an optional argument to the function. k (scalar): An optional argument which is passed through to `mask_func`. Functions like :func:`~cupy.triu`, :func:`~cupy.tril` take a second argument that is interpreted as an offset. Returns: tuple of arrays: The `n` arrays of indices corresponding to the locations where ``mask_func(np.ones((n, n)), k)`` is True. .. warning:: This function may synchronize the device. .. seealso:: :func:`numpy.mask_indices` r\)r_onesint8ro)n mask_funcr9as r mask_indicesrs.B 1& *A Q? " " $$rc^[R"XU[S9m[U4Sj[R"TR [ S955$)a#Returns the indices of the lower triangular matrix. Here, the first group of elements contains row coordinates of all indices and the second group of elements contains column coordinates. Parameters ---------- n : int The row dimension of the arrays for which the returned indices will be valid. k : int, optional Diagonal above which to zero elements. `k = 0` (the default) is the main diagonal, `k < 0` is below it and `k > 0` is above. m : int, optional The column dimension of the arrays for which the returned arrays will be valid. By default, `m = n`. Returns ------- y : tuple of ndarrays The indices for the triangle. The returned tuple contains two arrays, each with the indices along one dimension of the array. See Also -------- numpy.tril_indices r9r]c3l># UH)n[R"UTR5Tv M+ g7frr_ broadcast_tore.0indstri_s r tril_indices../B@T""44T:@14r\r_triboolr(rhreintrr9mrs @r tril_indicesrsE@ 88AAT *D B!\\$**C@B BBrcURS:wa [S5e[URSXRSS9$)a Returns the indices for the lower-triangle of arr. Parameters ---------- arr : cupy.ndarray The indices are valid for square arrays whose dimensions are the same as arr. k : int, optional Diagonal offset. See Also -------- numpy.tril_indices_from rLinput array must be 2-dr$r9r)rr+rrearrr9s rtril_indices_fromrs8" xx1}233  " iim <# UH)n[R"UTR5Tv M+ g7frrrs rrtriu_indices..3rrr\rrs @r triu_indicesrsLB HHQQU$ / /D B!\\$**C@B BBrcURS:wa [S5e[URSXRSS9$)a`Returns indices for the upper-triangle of arr. Parameters ---------- arr : cupy.ndarray The indices are valid for square arrays. k : int, optional Diagonal offset (see 'triu_indices` for details). Returns ------- triu_indices_from : tuple of ndarrays Indices for the upper-triangle of `arr`. See Also -------- numpy.triu_indices_from rLrrr$r)rr+rrers rtriu_indices_fromr7s8* xx1}233  " iim <rs" $#@@F1 1  X4   X:"&R4nqh:#z"%V#BL=,$BN=r