o 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_mathsum_auto_dtype_sum_keep_dtypecall_reductionsumarrr keepdimsfuncrO/home/ubuntu/veenaModal/venv/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 rcharr _nansum_complex_dtype_nansum_auto_dtype_nansum_keep_dtyper_nansumrrrrnansumKs  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_nanprodrrrrnanprodns 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_SUMrrrr 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 nancumsumr2cCr/)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` r0r)r1r.r*rrr nancumprodr3r5z T a, T valzT outz(if (a == a) {out = a;} else {out = val;}cupy_replace_nancCs.|dus |j|jkrt|}t||||SN)rcupy empty_like_replace_nan_kernel)rvalr rrrr1s  r1r4c 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 Nr4r<) ValueErrorreprr8 asanyarrayndimr_normalize_axis_indexlistshape broadcast_totupleappendlen concatenateslicernumpybool_ not_equalsubtractrange) rnrprependrFndcombinedrCslice1slice2op_rrrdiffsJ               rW)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?r4z&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?)r8r?r@r_normalize_axis_indicesrGrB enumerater=rCrJ issubdtyperintegerastypefloat64rWall TypeErrorrIinexactzipr9rErF)frrXvarargsr@axeslen_axesrOdxi distancesdiffxoutvalsrSrTslice3slice4otypeax_dxr uniform_spacingdx1dx2dx_sumrbcrCdx_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.ndarrayNr4r<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\) isinstancer8ndarrayrgravelrcan_castrGmaxemptyrM)arrto_endto_begin dtype_reql_beginl_endl_diffresultrrrediff1ds<    *rrZc 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.ndarrayr4r)rr<r^)rr8rrgr@rWrCreshaperIrErr=addreduce) yxrnrdrCrQrSrTproductretrrrtrapzFs2         rcCstdtt|||||S)NzPlease use `prod` instead.)warningswarnDeprecationWarningr)rrrr rrrrrws rcCstdtt||||S)NzPlease use `cumprod` instead.)rrrr.r*rrr cumproduct|s r)NNNF)NNNr7)r4r<NN)NN)NrZr<)rrJr8 cupy._corerr rrrrr!r%r+r.r2r5_core_kernelElementwiseKernelr:r1rWrrrrrrrrrs4     # !     A W F 1