9jT8SSKJr SSKrSSKrSSKrSSKJr SSKJr SSKJ r SSjr SSjr SSjr SS jr SS jrSS jrSS jrSS jr\R$R&R)SSSS5rSSjrSSjrSSS.SjrSSjrS SjrSSjrSSjrg)!) annotationsN)_routines_math)_fusion_thread_local)internalc[R"5(aLU(a [S5eUc[RnO[R n[R "XPXUS9$URXX45$)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.axisdtypeout)r is_fusingNotImplementedError_mathsum_auto_dtype_sum_keep_dtypecall_reductionsumar r r keepdimsfuncs L/home/wildlama/miniconda3/lib/python3.13/site-packages/cupy/_math/sumprod.pyrr sp"%%'' %EG G =''D((D#22 $6 6 55c ,,c[R"5(aLU(a [S5eUc[RnO[R n[R "XPXUS9$URXX45$)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.r)rr r r_prod_auto_dtype_prod_keep_dtyperprodrs rrr-sp"%%'' %FH H =))D))D#22 $6 6 66$s --rcT[R"5(awU(a [S5eURRS;a[ R nO$Uc[ RnO[ Rn[R"XPXUS9$[ R"XX#U5$)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.FDr) rr r r charr_nansum_complex_dtype_nansum_auto_dtype_nansum_keep_dtyper_nansumrs rnansumr$Ms$%%'' %HJ J 77<<4 ..D ]++D++D#22 $6 6 ==%h 77rc[R"5(aLU(a [S5eUc[RnO[R n[R "XPXUS9$[R"XX#U5$)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.r)rr r r_nanprod_auto_dtype_nanprod_keep_dtyper_nanprodrs rnanprodr)psr$%%'' %IK K =,,D,,D#22 $6 6 >>!5x 88rcb[R"X[RRX#5$)asReturns 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_SUMrr r r s rcumsumr/s! ??1EMM$:$:E GGrcb[R"X[RRX#5$)a|Returns 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` )rr+r, SCAN_PRODr.s rcumprodr2s! ??1EMM$;$;U HHrc,[USUS9n[XX#S9$)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 nancumsumr6s Qs#A !e 55rc,[USUS9n[XX#S9$)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` r4r)r5r2r.s r nancumprodr9s Qs#A 1u 66rz T a, T valzT outz(if (a == a) {out = a;} else {out = val;}cupy_replace_nancUbURUR:wa[R"U5n[XU5 U$N)r cupy empty_like_replace_nan_kernel)rvalr s rr5r5s3 {agg*ooa $ Jrr8cVUS:XaU$US:a[S[U5-5e[R"U5nURn[ R "X%5n/nUbp[R"U5nURS:Xa9[UR5nSXr'[R"U[U55nURU5 URU5 Ubp[R"U5nURS:Xa9[UR5nSXr'[R"U[U55nURU5 [U5S:a[R"Xb5n[S5/U-n[S5/U-n [SS5X'[SS5X'[U5n[U 5n UR[ R":Xa[R$O[R&n [)U5Hn U "XX 5nM U$)aCalculate 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 Nr8) ValueErrorreprr= asanyarrayndimr_normalize_axis_indexlistshape broadcast_totupleappendlen concatenateslicer numpybool_ not_equalsubtractrange) rnr prependrLndcombinedrIslice1slice2op_s rdiffr]s$ Av1u 1DG ;= = A B  ) )$ 3DH//'* <<1 MEEK''u>G  OOA ( ;;! MEEK&&vuU|FLr?FL 6]F 6]F77ekk1t}}B 1X qy!) $ Hr)r edge_orderc [R"U5nURn[R"XSS9n[ U5n[ U5nUS:XaS/U-nGOPUS:Xa#[R"US5S:XaX6-nGO'Xv:XGa[ U5n[U5Hup[R"U 5S:XaM![R"U 5S:wa [S5e[ U 5URXY:wa [S5e[R"U R[R5(aU R[R5n [R "U 5n XS:HR#5(aU Sn XU 'M O [%S5eUS :a [S 5e/n ['S 5/U-n ['S 5/U-n['S 5/U-n['S 5/U-nURn[R"U[R(5(aOY[R"U[R5(aUR[R5n[Rn[+XX5GHdunnURUUS-:a [S 5e[R,"UUS 9n[R"U5S:Hn['SS5X'['S S5X'['SS5X'['S S 5UU'U(a0U[/U5U[/U5- SU-- U[/U 5'OUSSnUSS nUU-nU*UU-- nUU- UU-- nUUU-- nS/U-nSUU'[/U5=Ul =Ul Ul UU[/U5-UU[/U5--UU[/U5--U[/U 5'US:XaSX'SX'SX'U(aUOUSnU[/U5U[/U5- U- U[/U 5'SX'SX'SX'U(aUOUSnU[/U5U[/U5- U- U[/U 5'GO/SX'SX'SX'S UU'U(aSU- nSU- nSU- nO/USnUSnUU-nSU-U-*UU-- nUUU-- nU*UU-- nUU[/U5-UU[/U5--UU[/U5--U[/U 5'SX'SX'SX'SUU'U(aSU- nSU- nSU- nO.USnUSnUU-nUUU-- nU*UU-- nSU-U-UU-- nUU[/U5-UU[/U5--UU[/U5--U[/U 5'U R1U5 ['S 5X'['S 5X'['S 5X'['S 5UU'GMg US:XaU S$U $)amReturn 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?r8z&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 rB@ggg?gg?)r=rErFr_normalize_axis_indicesrMrH enumeraterCrIrP issubdtyper integerastypefloat64r]all TypeErrorrOinexactzipr>rKrL)fr r^varargsrFaxeslen_axesrUdxi distancesdiffxoutvalsrYrZslice3slice4otypeax_dxr uniform_spacingdx1dx2dx_sumrbcrIdx_0dx_ns rgradientr,sQT A 66D  + +D% HD4yH G AAvUX  aDIIgaj)Q.    ']%bMLAyy#q(9%* !IJJ9~!11 @ ??&,,U]]; IIi(Eq!&&((aqE'**566A~DEE GDk]T !FDk]T !FDk]T !FDk]T !F GGE u}}--   E5== 1 1'A 4} e 774=:> )C  ooau-))E*a/Q| T2 Q| Q~t "#E&M"2QuV}5E"Ee "Cf "+C)C3YF#,'AssSy)AsV|$AC$JEE$K*/, 6AG 6ag"#af &6"6"#af &6"6#7"#af &6"6#7Cf  ?FLFLFL+5qD"#E&M"2QuV}5E"E!MCf FLFLFL+5rD"#E&M"2QuV}5E"E!MCf FLFLFLF4L5L%K5LAhAhsCi#o&#.9cCi(DC6N+"#af &6"6"#af &6"6#7"#af &6"6#7Cf FLFLFLF4L%K5L%KBiBisSF^,GsSy)3Y_8"#af &6"6"#af &6"6#7"#af &6"6#7Cf  sT{ T{ T{ T{t K%N1}qzrc\[U[R5(d [S5eUR 5nUR nUcUc USSUSS- $UcSnOj[U[R5(d [S5e[R "X#SS9(d [S 5eUR 5n[U5nUcSnOj[U[R5(d [S 5e[R "XSS9(d [S 5eUR 5n[U5n[[U5S- S5n[R"Xd-U-UR S 9nUS:aX'SU&US:aXXF-S&[R"USSUSSXtXF-5 U$) 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.ndarrayNr8rBrz)`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.rc) isinstancer=ndarrayrnravelr can_castrMmaxemptyrS)arrto_endto_begin dtype_reql_beginl_endl_diffresults rediff1drs" c4<< ( (>?? ))+C IFN12wSb!!(DLL11GH H}}X+FKL L>>#h- ~&$,,//EF F}}V DKL LF SAq !F ZZ(50 BF{#x qy$*w !MM#ab'3s8VG4D%EF Mrc[U[R5(d [S5eUcUnO[U[R5(d [S5eURS:Xa>[ U5nS/UR-nUR SXS'URU5nO [ XS9nURn[S5/U-n[S5/U-n[SS5Xs'[SS5X'X@[U5U[U5--S- n U RU5n U $![a# [RRX5n U $f=f) aL 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.ndarrayr8r)r rBre)rr=rrnrFr]rIreshaperOrKrrCaddreduce) yxrur drIrWrYrZproductrets r trapezoidrHs;( a & &<==y !T\\**@A A 66Q;QAC!&&LE''!*EK % AQ"A BDk]R FDk]R FD>FLr?FLU6]#af &667#=G-kk$ J -hhoog, J-sD..)EEcR[R"S[5 [XX#U5$)NzPlease use `prod` instead.)warningswarnDeprecationWarningr)rr r r rs rrrys! MM.0BC X ..rcP[R"S[5 [XX#5$)NzPlease use `cumprod` instead.)rrrr2r.s r cumproductr~s MM13EF 1E ''r)NNNF)NNNr<)r8rBNN)NN)NrarB) __future__rrrPr= cupy._corerrrrrrr$r)r/r2r6r9_core_kernelElementwiseKernelr?r5r]rrrrrrrrs" .+-@.@ 8F9BH&I&6(7(jj((::'E > B $Sl@L.b/ (r