o 0 i]T@sddlZddlZddlZddlmZddlmZddlmZd,ddZd,dd Z d,d d Z d,d d Z d-ddZ d-ddZ d-ddZd-ddZejjddddZd.ddZd/ddZddd d!d"Zd0d#d$Zd1d&d'Zd,d(d)Zd-d*d+ZdS)2N)_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_mathZsum_auto_dtypeZ_sum_keep_dtypecall_reductionsumarrr keepdimsfuncr^/home/app/PaddleOCR-VL-test/.venv_paddleocr/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 Z_prod_auto_dtypeZ_prod_keep_dtyper prodrrrrr+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.ZFDNr) rr r rcharr Z_nansum_complex_dtypeZ_nansum_auto_dtypeZ_nansum_keep_dtyper Z_nansumrrrrnansumKs  rcCsPtr|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 Z_nanprod_auto_dtypeZ_nanprod_keep_dtyper Z_nanprodrrrrnanprodns rcCt||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_opZSCAN_SUMrrrr rrrcumsumrcCr)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 rrZ SCAN_PRODrrrrcumprodrr 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_nanrrrrr nancumsumr$cCr!)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` r"r)r#r rrrr nancumprodr%r'z T a, T valzT outz(if (a == a) {out = a;} else {out = val;}Zcupy_replace_nancCs.|dus |j|jkrt|}t||||SN)rcupy empty_like_replace_nan_kernel)rvalr rrrr#s  r#r&c 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 Nr&r-) ValueErrorreprr) asanyarrayndimrZ_normalize_axis_indexlistshapeZ broadcast_totupleappendlenZ concatenateslicernumpyZbool_ not_equalsubtractrange) rnrprependr5ndcombinedr3slice1slice2op_rrrdiffsJ               rD)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)Z sort_axesr?r&z&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.rr-@ggg?gg?)r)r0r1rZ_normalize_axis_indicesr6r2 enumerater.r3r8Z issubdtyperintegerZastypeZfloat64rDall TypeErrorr7Zinexactzipr*r4r5)frrEvarargsr1ZaxesZlen_axesr<dxiZ distancesZdiffxZoutvalsr@rAZslice3Zslice4ZotypeZax_dxr Zuniform_spacingZdx1Zdx2Zdx_sumrbcr3Zdx_0Zdx_nrrrgradient*s *           $&          rWcCsbt|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.ndarrayNr&r-rz)`to_begin` should be of type cupy.ndarrayZ same_kind)ZcastingzSdtype 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.rH) isinstancer)ndarrayrOZravelrZcan_castr6maxemptyr:)ZarrZto_endZto_beginZ dtype_reqZl_beginZl_endZl_diffresultrrrediff1ds<    *r]rFc 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.trapz` z"`y` should be of type cupy.ndarrayNz"`x` should be of type cupy.ndarrayr&r)rr-rJ)rXr)rYrOr1rDr3Zreshaper7r4rr.addreduce) yxrSrdr3r>r@rAproductretrrrtrapzFs2         recCstdtt|||||S)NzPlease use `prod` instead.)warningswarnDeprecationWarningr)rrrr rrrrrcws rccCstdtt||||S)NzPlease use `cumprod` instead.)rfrgrhr rrrr cumproduct|s ri)NNNF)NNNr()r&r-NN)NN)NrFr-)rfr8r)Z cupy._corerr rrrrrrrr r$r'Z_coreZ_kernelZElementwiseKernelr+r#rDrWr]rercrirrrrs4     # !     A W F 1