`i]TddlZddlZddlZddlmZddlmZddlmZddZddZ ddZ dd Z dd Z dd Z dd Zdd ZejjddddZddZd dZddddZd!dZd"dZddZddZdS)#N)_routines_math)_fusion_thread_local)internalFctjrE|rtd| tj}n tj}tj|||||S|||||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 keepdimsfuncs f/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupy/_math/sumprod.pyrr s"%'' 6  G%EGG G ='DD(D#2 !$e666 6 55uc8 , ,,ctjrE|rtd| tj}n tj}tj|||||S|||||S)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_dtyperprodrs rrr+s"%'' 6  H%FHH H =)DD)D#2 !$e666 6 66$sH - --rctjr`|rtd|jjdvr t j}n| t j}n t j}tj |||||St j |||||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_nansumrs rnansumr#Ks$%'' 6  J%HJJ J 7<4  .DD ]+DD+D#2 !$e666 6 =D%h 7 77rctjrE|rtd| tj}n tj}tj|||||Stj|||||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_nanprodrs rnanprodr(ns$%'' 6  K%IKK K =,DD,D#2 !$e666 6 >!T5#x 8 88rcPtj||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 s rcumsumr.s! ?1dEM$:E3 G GGrcPtj||tjj||S)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-s rcumprodr1s! ?1dEM$;UC H HHrcLt|d|}t||||S)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-s r nancumsumr5s/ Qs###A !$e 5 5 55rcLt|d|}t||||S)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` r3r)r4r1r-s r nancumprodr8s/ Qs###A 14u# 6 6 66rz T a, T valzT outz(if (a == a) {out = a;} else {out = val;}cupy_replace_nanct||j|jkrtj|}t||||SN)r cupy empty_like_replace_nan_kernel)rvalr s rr4r4s; {ag**oa  3$$$ Jrr7c|dkr|S|dkrtdt|ztj|}|j}t j||}g}|otj|}|jdkr;t|j}d||<tj |t|}| || ||otj|}|jdkr;t|j}d||<tj |t|}| |t|dkrtj ||}tdg|z}tdg|z} tdd||<tdd| |<t|}t| } |jt jkr tjn tj} t)|D]} | |||| }|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 Nr7r@) ValueErrorreprr< asanyarrayndimr_normalize_axis_indexlistshape broadcast_totupleappendlen concatenateslicer numpybool_ not_equalsubtractrange) rnrprependrKndcombinedrHslice1slice2op_s rdiffr\s$ Avv1uu 1DGG ;== = A B  )$ 3 3DH/'** <1  MMEE$K'u>>G    OOA (( ;!  MMEE$K&vuU||<>F4Lr??F4L 6]]F 6]]F7ek11t}B 1XX%% Bqy!F) $ $ Hr)r edge_orderc tj|}|j}tj||d}t |}t |}|dkrdg|z}n[|dkr%tj|ddkr||z}n0||krt |}t|D]\} } tj| dkrtj| dkrtdt | |j || krtdtj | j tj r| tj} tj| } | | dkr| d} | || <nt%d|d krtd g} t'd g|z} t'd g|z}t'd g|z}t'd g|z}|j }tj |tjrnJtj |tj r|tj}tj}t+||D]#\}}|j ||dzkrtd tj|| }tj|dk}t'dd| |<t'd d||<t'dd||<t'd d ||<|rB|t/||t/|z d|zz |t/| <n|dd}|dd }||z}| ||zz }||z ||zz }|||zz }dg|z}d||<t/|x|_ x|_ |_ ||t/|z||t/|zz||t/|zz|t/| <|dkrd| |<d||<d||<|r|n|d}|t/||t/|z |z |t/| <d| |<d||<d||<|r|n|d}|t/||t/|z |z |t/| <nid| |<d||<d||<d ||<|rd|z }d|z }d|z }n5|d}|d}||z}d|z|z ||zz }|||zz }| ||zz }||t/|z||t/|zz||t/|zz|t/| <d| |<d||<d||<d||<|rd|z }d|z }d|z }n4|d}|d}||z}|||zz }| ||zz }d|z|z||zz }||t/|z||t/|zz||t/|zz|t/| <| |t'd | |<t'd ||<t'd ||<t'd ||<%|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?r7z&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?)r<rDrEr_normalize_axis_indicesrLrG enumeraterBrHrO issubdtyper integerastypefloat64r\all TypeErrorrNinexactzipr=rJrK)frr]varargsrEaxeslen_axesrTdxi distancesdiffxoutvalsrXrYslice3slice4otypeax_dxr uniform_spacingdx1dx2dx_sumrbcrHdx_0dx_ns rgradientr*sMT A 6D  +D$% H H HD4yyH G AAvvUX  aDIgaj))Q.. x  h ']]%bMM  LAyy##q((9%%** !IJJJ9~~a!111 @ ?? <&,,U];; Ii((Eq!&&(( !aBqEE' *5666A~~DEEE GDkk]T !FDkk]T !FDkk]T !FDkk]T !F GE u}--  E5= 1 1 (''A 4}}e#e# e 74=:> ) )C  oau---)E**a/Q||t T2t Q||t Q~~t  8"#E&MM"2QuV}}5E"Ee "Cf  "+C)C3YF#,'AssSy)AsV|$AC$JEE$K*/,, 6AG 6ag"#af &6"6"#af &6"6#7"#af &6"6#7Cf  ??F4LF4LF4L+955qD"#E&MM"2QuV}}5E"E!MCf F4LF4LF4L+:55rD"#E&MM"2QuV}}5E"E!MCf  F4LF4LF4LF4L ,5L%K5LAhAhsCi#o&#.9cCi(DC6N+"#af &6"6"#af &6"6#7"#af &6"6#7Cf F4LF4LF4LF4L 9%K5L%KBiBisSF^,GsSy)3Y_8"#af &6"6"#af &6"6#7"#af &6"6#7Cf  sT{{t T{{t T{{t T{{t 1}}qzrct|tjstd|}|j}|||dd|ddz S|d}nrt|tjstdtj||dstd |}t|}|d}nrt|tjstd tj||dstd |}t|}tt|dz d}tj ||z|z|j }|dkr||d|<|dkr ||||zd<tj |dd|dd||||z|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.ndarrayNr7r@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.rb) isinstancer<ndarrayrmravelr can_castrLmaxemptyrR)arrto_endto_begin dtype_reql_beginl_endl_diffresults rediff1drs" c4< ( (@>??? ))++C IFN122wSbS!!(DL11 IGHH H}Xy+FFF LKLL L>>##h-- ~&$,// GEFF F}VY DDD LKLL LF SAq ! !F Z(50 B B BF{{#xx qyy$*w  !M#abb'3ss8VGGf4D,D%EFFF Mrr`ct|tjstd||}nt|tjstd|jdkr@t |}dg|jz}|jd||<||}nt ||}|j}tdg|z}tdg|z}tdd||<tdd||<||t||t|zzdz } | |} n0#t$r#tj | |} YnwxYw| S) 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.ndarrayr7r)rr@rd)rr<rrmrEr\rHreshaperNrJrrBaddreduce) yxrtrdrHrVrXrYproductrets rtrapzrFsv( a & &><===y !T\** B@AA A 6Q;;QAC!&LE'!*E$K %  AAQT"""A BDkk]R FDkk]R FD>>F4Lr??F4L1U6]]#af &667#=G-kk$ ---hoogt,,- Js9E*E<;E<c\tjdtt|||||S)NzPlease use `prod` instead.)warningswarnDeprecationWarningr)rrr r rs rrrws, M.0BCCC 4X . ..rcZtjdtt||||S)NzPlease use `cumprod` instead.)rrrr1r-s r cumproductr|s* M13EFFF 1dE3 ' ''r)NNNF)NNNr;)r7r@NN)NN)Nr`r@)rrOr< cupy._corerr rrrrr#r(r.r1r5r8_core_kernelElementwiseKernelr>r4r\rrrrrrrrs ......++++++----@....@ 8 8 8 8F9999BHHHH&IIII&6666(7777(j(::'E > > > > B $SSSSSl@@@@L....b//// ((((((r