`i8nddlZddlmZddlmZddlmZddlmZddlmZd&dZ d&d Z d&d Z d&d Z d Z d ZejdddZd'dZdZdZdZdZejddedeezZdZejdddezdzdeezZejdd d!ezdzd"eezZd(d$Zd%ZdS))N)_core)fusion)_util)_routines_indexing)_routines_statisticsFc4|||||S)aReturns the indices of the maximum along an axis. Args: a (cupy.ndarray): Array to take argmax. axis (int): Along which axis to find the maximum. ``a`` is flattened by default. dtype: Data type specifier. out (cupy.ndarray): Output array. keepdims (bool): If ``True``, the axis ``axis`` is preserved as an axis of length one. Returns: cupy.ndarray: The indices of the maximum of ``a`` along an axis. .. note:: ``dtype`` and ``keepdim`` arguments are specific to CuPy. They are not in NumPy. .. note:: ``axis`` argument accepts a tuple of ints, but this is specific to CuPy. NumPy does not support it. .. seealso:: :func:`numpy.argmax` axisdtypeoutkeepdims)argmaxar r r r s h/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupy/_sorting/search.pyrr 6 88Uh8 G GGcv|jjdvrt|||||Stj|||||S)aReturn the indices of the maximum values in the specified axis ignoring NaNs. For all-NaN slice ``-1`` is returned. Subclass cannot be passed yet, subok=True still unsupported Args: a (cupy.ndarray): Array to take nanargmax. axis (int): Along which axis to find the maximum. ``a`` is flattened by default. Returns: cupy.ndarray: The indices of the maximum of ``a`` along an axis ignoring NaN values. .. note:: For performance reasons, ``cupy.nanargmax`` returns ``out of range values`` for all-NaN slice whereas ``numpy.nanargmax`` raises ``ValueError`` .. seealso:: :func:`numpy.nanargmax` biur )r kindr _statistics _nanargmaxrs r nanargmaxr(E& w|uad%S8LLLL  !!T3x @ @@rc4|||||S)aReturns the indices of the minimum along an axis. Args: a (cupy.ndarray): Array to take argmin. axis (int): Along which axis to find the minimum. ``a`` is flattened by default. dtype: Data type specifier. out (cupy.ndarray): Output array. keepdims (bool): If ``True``, the axis ``axis`` is preserved as an axis of length one. Returns: cupy.ndarray: The indices of the minimum of ``a`` along an axis. .. note:: ``dtype`` and ``keepdim`` arguments are specific to CuPy. They are not in NumPy. .. note:: ``axis`` argument accepts a tuple of ints, but this is specific to CuPy. NumPy does not support it. .. seealso:: :func:`numpy.argmin` r )argminrs rrrArrcv|jjdvrt|||||Stj|||||S)aReturn the indices of the minimum values in the specified axis ignoring NaNs. For all-NaN slice ``-1`` is returned. Subclass cannot be passed yet, subok=True still unsupported Args: a (cupy.ndarray): Array to take nanargmin. axis (int): Along which axis to find the minimum. ``a`` is flattened by default. Returns: cupy.ndarray: The indices of the minimum of ``a`` along an axis ignoring NaN values. .. note:: For performance reasons, ``cupy.nanargmin`` returns ``out of range values`` for all-NaN slice whereas ``numpy.nanargmin`` raises ``ValueError`` .. seealso:: :func:`numpy.nanargmin` rr )r rrr _nanargminrs r nanargminr_rrcVtj|d|S)aReturn the indices of the elements that are non-zero. Returns a tuple of arrays, one for each dimension of a, containing the indices of the non-zero elements in that dimension. Args: a (cupy.ndarray): array Returns: tuple of arrays: Indices of elements that are non-zero. .. warning:: This function may synchronize the device. .. seealso:: :func:`numpy.nonzero` rarg_name)r check_arraynonzerors rr$r$xs(& a#&&&& 99;;rctj|d|dS)aReturn indices that are non-zero in the flattened version of a. This is equivalent to a.ravel().nonzero()[0]. Args: a (cupy.ndarray): input array Returns: cupy.ndarray: Output array, containing the indices of the elements of a.ravel() that are non-zero. .. warning:: This function may synchronize the device. .. seealso:: :func:`numpy.flatnonzero` rr!r)rr#ravelr$r%s r flatnonzeror(s9$ a#&&&& 7799    q !!r cupy_where)z???->?z?bb->bz?BB->Bz?hh->hz?HH->Hz?ii->iz?II->Iz?ll->lz?LL->Lz?qq->qz?QQ->Qz?ee->ez?ff->fz?hd->dz?Hd->dz?dd->dz?FF->Fz?DD->Dzout0 = in0 ? in1 : in2c2|du|dufd}|dkrtd|dkrt|Stjrtjt |||St |d||S)aReturn elements, either from x or y, depending on condition. If only condition is given, return ``condition.nonzero()``. Args: condition (cupy.ndarray): When True, take x, otherwise take y. x (cupy.ndarray): Values from which to choose on ``True``. y (cupy.ndarray): Values from which to choose on ``False``. Returns: cupy.ndarray: Each element of output contains elements of ``x`` when ``condition`` is ``True``, otherwise elements of ``y``. If only ``condition`` is given, return the tuple ``condition.nonzero()``, the indices where ``condition`` is True. .. warning:: This function may synchronize the device if both ``x`` and ``y`` are omitted. .. seealso:: :func:`numpy.where` NTz)Must provide both 'x' and 'y' or neither.?)count ValueErrorr$r _is_fusing _call_ufunc _where_ufuncastype) conditionxymissings rwherer8s2Dy!t)$**400G!||HIII!||y!!! A!, 1a@@@  ((--q! 4 44rcVtj|dtj|S)aReturn the indices of the elements that are non-zero. Returns a (N, ndim) dimantional array containing the indices of the non-zero elements. Where `N` is number of non-zero elements and `ndim` is dimension of the given array. Args: a (cupy.ndarray): array Returns: cupy.ndarray: Indices of elements that are non-zero. .. seealso:: :func:`numpy.argwhere` rr!)rr# _indexing_ndarray_argwherer%s rargwherer<s+  a#&&&&  &q ) ))rzO template __device__ bool _isnan(T val) { return val != val; } a #ifdef __HIP_DEVICE_COMPILE__ #define no_thread_divergence(do_work, to_return) \ if (!is_done) { \ do_work; \ is_done = true; \ } #else #define no_thread_divergence(do_work, to_return) \ do_work; \ if (to_return) { return; } #endif a #ifdef __HIP_DEVICE_COMPILE__ bool is_done = false; #endif // Array is assumed to be monotonically // increasing unless a check is requested with the // `assume_increasing = False` parameter. // `digitize` allows increasing and decreasing arrays. bool inc = true; if (!assume_increasing && n_bins >= 2) { // In the case all the bins are nan the array is considered // to be decreasing in numpy inc = (bins[0] <= bins[n_bins-1]) || (!_isnan(bins[0]) && _isnan(bins[n_bins-1])); } if (_isnan(x)) { long long pos = (inc ? n_bins : 0); if (!side_is_right) { if (inc) { while (pos > 0 && _isnan(bins[pos-1])) { --pos; } } else { while (pos < n_bins && _isnan(bins[pos])) { ++pos; } } } no_thread_divergence( y = pos , true ) } bool greater = false; if (side_is_right) { greater = inc && x >= bins[n_bins-1]; } else { greater = (inc ? x > bins[n_bins-1] : x <= bins[n_bins-1]); } if (greater) { no_thread_divergence( y = n_bins , true ) } long long left = 0; // In the case the bins is all NaNs, digitize // needs to place all the valid values to the right if (!inc) { while (_isnan(bins[left]) && left < n_bins) { ++left; } if (left == n_bins) { no_thread_divergence( y = n_bins , true ) } if (side_is_right && !_isnan(bins[n_bins-1]) && !_isnan(x) && bins[n_bins-1] > x) { no_thread_divergence( y = n_bins , true ) } } long long right = n_bins-1; while (left < right) { long long m = left + (right - left) / 2; bool look_right = true; if (side_is_right) { look_right = (inc ? bins[m] <= x : bins[m] > x); } else { look_right = (inc ? bins[m] < x : bins[m] >= x); } if (look_right) { left = m + 1; } else { right = m; } } no_thread_divergence( y = right , false ) zIS x, raw T bins, int64 n_bins, bool side_is_right, bool assume_increasingzint64 ycupy_searchsorted_kernel)namepreambleaJ #ifdef __HIP_DEVICE_COMPILE__ #define no_thread_divergence(do_work, to_return) \ if (!is_done) { \ do_work; \ is_done = true; \ } #else #define no_thread_divergence(do_work, to_return) \ do_work; \ if (to_return) { \ out = (y == n_bins ? false : bins[y] == x); \ if (invert) out = !out; \ return; \ } #endif z*S x, raw T bins, int64 n_bins, bool invertzbool outze const bool assume_increasing = true; const bool side_is_right = false; long long y; zQ out = (y == n_bins ? false : bins[y] == x); if (invert) out = !out; cupy_exists_kernelzbool out, int64 yzT const bool assume_increasing = true; const bool side_is_right = false; #cupy_exists_and_searchsorted_kernelleftc(t||||dS)aFinds indices where elements should be inserted to maintain order. Find the indices into a sorted array ``a`` such that, if the corresponding elements in ``v`` were inserted before the indices, the order of ``a`` would be preserved. Args: a (cupy.ndarray): Input array. If ``sorter`` is ``None``, then it must be sorted in ascending order, otherwise ``sorter`` must be an array of indices that sort it. v (cupy.ndarray): Values to insert into ``a``. side : {'left', 'right'} If ``left``, return the index of the first suitable location found If ``right``, return the last such index. If there is no suitable index, return either 0 or length of ``a``. sorter : 1-D array_like Optional array of integer indices that sort array ``a`` into ascending order. They are typically the result of :func:`~cupy.argsort`. Returns: cupy.ndarray: Array of insertion points with the same shape as ``v``. .. note:: When a is not in ascending order, behavior is undefined. .. seealso:: :func:`numpy.searchsorted` T) _searchsorted)rvsidesorters r searchsortedrHs: AtVT 2 22rcVt|tjstdt|tjstd|jdkrt d|jdkrt d|jdkr%tj|jtj S|j j dk}|j j dk}|r|s| |j }n|r|s| |j }|Q|j j d vrtd |j|jkrt d ||}tj|jtj }t|||j|d k|||S)z`assume_increasing` is used in the kernel to skip monotonically increasing or decreasing verification inside the cuda kernel. z'Only int or ndarray are supported for az'Only int or ndarray are supported for vr+z!object too deep for desired arrayz+object of too small depth for desired arrayr)r cN)iuzsorter must be of integer typezsorter.size must equal a.sizeright) isinstancecupyndarrayNotImplementedErrorndimr/sizezerosshapeint64r rr3 TypeErrortake_searchsorted_kernel)rrErFrGassume_increasing a_iscomplex v_iscomplexr6s rrDrDs a & &M!"KLLL a & &M!"KLLLvzz<===vzzFGGGv{{z!'4444',#%K',#%K; HHQW   [ HHQW   < J . .<== = ;!& <== = FF6NN 17$*---AAqvtw8I1MMM Hr)NNNF)NN)rBN)rOr cupy._corerrrr:rrrrrrr$r( create_ufuncr2r8r< _preamble _hip_preamble_searchsorted_codeElementwiseKernelrY_exists_kernel_exists_and_searchsorted_kernelrHrDrrrfs? 666666::::::HHHH<AAAA2HHHH<AAAA2.""","u!#   "5"5"5"5J***,    L^/u.  #i .E GGG &)(0    #Y}-D F F F#:%"90  4 } $ #& #& #&3333@& & & & & r