o W۷iT@sddlmZddlZddlZddlZddlmZddlmZddlm Z d-ddZ d-d d Z d-d d Z d-d dZ d.ddZd.ddZd.ddZd.ddZejjddddZd/ddZd0dd Zddd!d"d#Zd1d$d%Zd2d'd(Zd-d)d*Zd.d+d,ZdS)3) annotationsN)_routines_math)_fusion_thread_local)internalFcCNtr|r td|durtj}ntj}tj|||||dS|||||S)aReturns the sum of an array along given axes. Args: a (cupy.ndarray): Array to take sum. axis (int or sequence of ints): Axes along which the sum is taken. dtype: Data type specifier. out (cupy.ndarray): Output array. keepdims (bool): If ``True``, the specified axes are remained as axes of length one. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.sum` z3cupy.sum does not support `keepdims` in fusion yet.Naxisdtypeout)r is_fusingNotImplementedError_mathsum_auto_dtype_sum_keep_dtypecall_reductionsumarr r keepdimsfuncrH/home/ubuntu/vllm_env/lib/python3.10/site-packages/cupy/_math/sumprod.pyr  rcCr)aReturns the product of an array along given axes. Args: a (cupy.ndarray): Array to take product. axis (int or sequence of ints): Axes along which the product is taken. dtype: Data type specifier. out (cupy.ndarray): Output array. keepdims (bool): If ``True``, the specified axes are remained as axes of length one. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.prod` z4cupy.prod does not support `keepdims` in fusion yet.Nr)rr r r _prod_auto_dtype_prod_keep_dtyperprodrrrrr-rrcCsdtr)|r td|jjdvrtj}n |durtj}ntj}tj |||||dSt |||||S)aReturns the sum of an array along given axes treating Not a Numbers (NaNs) as zero. Args: a (cupy.ndarray): Array to take sum. axis (int or sequence of ints): Axes along which the sum is taken. dtype: Data type specifier. out (cupy.ndarray): Output array. keepdims (bool): If ``True``, the specified axes are remained as axes of length one. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.nansum` z6cupy.nansum does not support `keepdims` in fusion yet.FDNr) rr r r charr _nansum_complex_dtype_nansum_auto_dtype_nansum_keep_dtyper_nansumrrrrnansumMs  r"cCsPtr|r td|durtj}ntj}tj|||||dSt|||||S)aReturns the product of an array along given axes treating Not a Numbers (NaNs) as zero. Args: a (cupy.ndarray): Array to take product. axis (int or sequence of ints): Axes along which the product is taken. dtype: Data type specifier. out (cupy.ndarray): Output array. keepdims (bool): If ``True``, the specified axes are remained as axes of length one. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.nanprod` z7cupy.nanprod does not support `keepdims` in fusion yet.Nr)rr r r _nanprod_auto_dtype_nanprod_keep_dtyper_nanprodrrrrnanprodps r&cCt||tjj||S)aReturns the cumulative sum of an array along a given axis. Args: a (cupy.ndarray): Input array. axis (int): Axis along which the cumulative sum is taken. If it is not specified, the input is flattened. dtype: Data type specifier. out (cupy.ndarray): Output array. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.cumsum` )r scan_corescan_opSCAN_SUMrrr r rrrcumsumr,cCr')aReturns the cumulative product of an array along a given axis. Args: a (cupy.ndarray): Input array. axis (int): Axis along which the cumulative product is taken. If it is not specified, the input is flattened. dtype: Data type specifier. out (cupy.ndarray): Output array. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.cumprod` )r r(r) SCAN_PRODr+rrrcumprodr-r/cCt|d|d}t||||dS)aReturns the cumulative sum of an array along a given axis treating Not a Numbers (NaNs) as zero. Args: a (cupy.ndarray): Input array. axis (int): Axis along which the cumulative sum is taken. If it is not specified, the input is flattened. dtype: Data type specifier. out (cupy.ndarray): Output array. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.nancumsum` rr r) _replace_nanr,r+rrr nancumsumr3cCr0)aReturns the cumulative product of an array along a given axis treating Not a Numbers (NaNs) as one. Args: a (cupy.ndarray): Input array. axis (int): Axis along which the cumulative product is taken. If it is not specified, the input is flattened. dtype: Data type specifier. out (cupy.ndarray): Output array. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.nancumprod` r1r)r2r/r+rrr nancumprodr4r6z T a, T valzT outz(if (a == a) {out = a;} else {out = val;}cupy_replace_nancCs.|dus |j|jkrt|}t||||SN)r cupy empty_like_replace_nan_kernel)rvalr rrrr2s  r2r5c Csz|dkr|S|dkrtdt|t|}|j}t||}g}|durFt|}|jdkrAt|j}d||<t |t |}| || ||durot|}|jdkrjt|j}d||<t |t |}| |t |dkr{t ||}tdg|}tdg|} tdd||<tdd| |<t |}t | } |jtjkrtjntj} t|D] } | |||| }q|S)a1Calculate the n-th discrete difference along the given axis. Args: a (cupy.ndarray): Input array. n (int): The number of times values are differenced. If zero, the input is returned as-is. axis (int): The axis along which the difference is taken, default is the last axis. prepend (int, float, cupy.ndarray): Value to prepend to ``a``. append (int, float, cupy.ndarray): Value to append to ``a``. Returns: cupy.ndarray: The result array. .. seealso:: :func:`numpy.diff` rz#order must be non-negative but got Nr5r=) ValueErrorreprr9 asanyarrayndimr_normalize_axis_indexlistshape broadcast_totupleappendlen concatenateslicer numpybool_ not_equalsubtractrange) rnrprependrGndcombinedrDslice1slice2op_rrrdiffsJ               rX)r edge_ordercGstt|}|j}tj||dd}t|}t|}|dkr"dg|}nm|dkr4t|ddkr4||}n[||krt|}t|D]I\} } t| dkrLq@t| dkrWtdt| |j || krftdt | j t j rt| t j} t| } | | dkr| d} | || <q@ntd|d krtd g} td g|} td g|}td g|}td g|}|j }t |t jrnt |t j r|t j}t j}t||D]\}}|j ||dkrtd tj||d }t|dk}tdd| |<td d||<tdd||<td d ||<|r)|t||t|d||t| <nU|dd}|dd }||}| ||}||||}|||}dg|}d||<t||_ |_ |_ ||t|||t|||t||t| <|dkrd| |<d||<d||<|r|n|d}|t||t|||t| <d| |<d||<d||<|r|n|d}|t||t|||t| <nd| |<d||<d||<d ||<|rd|}d|}d|}n$|d}|d}||}d|| ||}|||}| ||}||t|||t|||t||t| <d| |<d||<d||<d||<|rRd|}d|}d|}n#|d}|d}||}|||}| ||}d||||}||t|||t|||t||t| <| |td | |<td ||<td ||<td ||<q|dkr| dS| S)aReturn the gradient of an N-dimensional array. The gradient is computed using second order accurate central differences in the interior points and either first or second order accurate one-sides (forward or backwards) differences at the boundaries. The returned gradient hence has the same shape as the input array. Args: f (cupy.ndarray): An N-dimensional array containing samples of a scalar function. varargs (list of scalar or array, optional): Spacing between f values. Default unitary spacing for all dimensions. Spacing can be specified using: 1. single scalar to specify a sample distance for all dimensions. 2. N scalars to specify a constant sample distance for each dimension. i.e. `dx`, `dy`, `dz`, ... 3. N arrays to specify the coordinates of the values along each dimension of F. The length of the array must match the size of the corresponding dimension 4. Any combination of N scalars/arrays with the meaning of 2. and 3. If `axis` is given, the number of varargs must equal the number of axes. Default: 1. edge_order ({1, 2}, optional): The gradient is calculated using N-th order accurate differences at the boundaries. Default: 1. axis (None or int or tuple of ints, optional): The gradient is calculated only along the given axis or axes. The default (axis = None) is to calculate the gradient for all the axes of the input array. axis may be negative, in which case it counts from the last to the first axis. Returns: gradient (cupy.ndarray or list of cupy.ndarray): A set of ndarrays (or a single ndarray if there is only one dimension) corresponding to the derivatives of f with respect to each dimension. Each derivative has the same shape as f. .. seealso:: :func:`numpy.gradient` F) sort_axesr?r5z&distances must be either scalars or 1dzGwhen 1d, distances must match the length of the corresponding dimensionzinvalid number of argumentsz)'edge_order' greater than 2 not supportedNzlShape of array too small to calculate a numerical gradient, at least (edge_order + 1) elements are required.r r=@ggg?gg?)r9r@rAr_normalize_axis_indicesrHrC enumerater>rDrK issubdtyper integerastypefloat64rXall TypeErrorrJinexactzipr:rFrG)frrYvarargsrAaxeslen_axesrPdxi distancesdiffxoutvalsrTrUslice3slice4otypeax_dxr uniform_spacingdx1dx2dx_sumrbcrDdx_0dx_nrrrgradient,s *           $&          rcCsbt|tjs td|}|j}|dur%|dur%|dd|ddS|dur,d}nt|tjs6tdtj||ddsBtd |}t|}|durQd}nt|tjs[td tj||ddsgtd |}t|}tt|dd}tj ||||jd }|dkr||d|<|dkr||||d<t |dd|dd|||||S) a Calculates the difference between consecutive elements of an array. Args: arr (cupy.ndarray): Input array. to_end (cupy.ndarray, optional): Numbers to append at the end of the returned differences. to_begin (cupy.ndarray, optional): Numbers to prepend at the beginning of the returned differences. Returns: cupy.ndarray: New array consisting differences among succeeding elements. .. seealso:: :func:`numpy.ediff1d` z$`arr` should be of type cupy.ndarrayNr5r=rz)`to_begin` should be of type cupy.ndarray same_kind)castingzSdtype of `to_begin` must be compatible with input `arr` under the `same_kind` rule.z'`to_end` should be of type cupy.ndarrayzQdtype of `to_end` must be compatible with input `arr` under the `same_kind` rule.r]) isinstancer9ndarrayrhravelr can_castrHmaxemptyrN)arrto_endto_begin dtype_reql_beginl_endl_diffresultrrrediff1ds<    *rr[c Cs t|tjs td|dur|}n,t|tjstd|jdkr7t|}dg|j}|jd||<||}nt||d}|j}tdg|}tdg|}tdd||<tdd||<||t ||t |d} z| |} W| St ytj | |} Y| Sw) a Integrate along the given axis using the composite trapezoidal rule. Integrate `y` (`x`) along the given axis. Args: y (cupy.ndarray): Input array to integrate. x (cupy.ndarray): Sample points over which to integrate. If None equal spacing `dx` is assumed. dx (float): Spacing between sample points, used if `x` is None, default is 1. axis (int): The axis along which the integral is taken, default is the last axis. Returns: cupy.ndarray: Definite integral as approximated by the trapezoidal rule. .. seealso:: :func:`numpy.trapezoid` z"`y` should be of type cupy.ndarrayNz"`x` should be of type cupy.ndarrayr5r)rr=r_)rr9rrhrArXrDreshaperJrFrr>addreduce) yxrordrDrRrTrUproductretrrr trapezoidHs2         rcCstdtt|||||S)NzPlease use `prod` instead.)warningswarnDeprecationWarningr)rrr r rrrrrys rcCstdtt||||S)NzPlease use `cumprod` instead.)rrrr/r+rrr cumproduct~s r)NNNF)NNNr8)r5r=NN)NN)Nr[r=) __future__rrrKr9 cupy._corerr rrrrr"r&r,r/r3r6_core_kernelElementwiseKernelr;r2rXrrrrrrrrrs6      # !     A W F 1