9j9VSSKJr SSKrSSKrSSKrSSKJr SSKJr S%SjrS&Sjr S'S jr S(S jr S r "S S 5r \ "SS9r\ "SS9r\R "SSSSSSSSSSSS/ \"S5QSPSPSPSP7S 5r\R "S!S"S 5r\R "S!S#S$5rg))) annotationsN)_core) bf16_loopcUc&[SXU455(a[nO[nUcUnSnUcSn[[R"X- U- 55nUS::a[ R "SUS9$[R"U5R[R:XabUS:a [S5eUS:Xa'[ R"XU- /[RS9$[ R"U/[RS9$[ R "U4US9n[R"U5Rn[U"U5U"U5XSS9 U$)a1Returns an array with evenly spaced values within a given interval. Values are generated within the half-open interval [start, stop). The first three arguments are mapped like the ``range`` built-in function, i.e. start and step are optional. Args: start: Start of the interval. stop: End of the interval. step: Step width between each pair of consecutive values. dtype: Data type specifier. It is inferred from other arguments by default. Returns: cupy.ndarray: The 1-D array of range values. .. seealso:: :func:`numpy.arange` c3z# UH1n[R"[U55RS:Hv M3 g7f)fN)numpydtypetypekind).0vals O/home/wildlama/miniconda3/lib/python3.13/site-packages/cupy/_creation/ranges.py arange..!s//-3{{49%**c1-s9;r)rr zMarange() is only supported for booleans when the result has at most length 2.) anyfloatintr ceilcupyemptyr r bool_ TypeErrorarray _arange_ufunc)startstopstepr sizerettyps raranger% s,( } / -/ / /EE | | uzz4<4/0 1D qyzz$e,, {{5%++- !88  19::udl35;;G G::ugU[[9 9 **dWE *C ++e  ! !C#e*c$i: JTFc*[R"X[U55nUcUn[R"U4US9nU(aUS- OUnUS::a#US:aUR U5 [S5n OH[X- 5U- n [U5nU S:Xa[ XU- X5 O [ X U5 U(aXS'[R"U[R5(a[R"XwS9 URUSS 9nU(aXy4$U$) aReturns an array with evenly-spaced values within a given interval. Instead of specifying the step width like :func:`cupy.arange`, this function requires the total number of elements specified. Args: start: Start of the interval. stop: End of the interval. num: Number of elements. endpoint (bool): If ``True``, the stop value is included as the last element. Otherwise, the stop value is omitted. retstep (bool): If ``True``, this function returns (array, step). Otherwise, it returns only the array. dtype: Data type specifier. It is inferred from the start and stop arguments by default. Returns: cupy.ndarray: The 1-D array of ranged values. rrrnanoutFcopy) r result_typerrfill_linspace_ufunc_underflow_linspace_ufunc issubdtypeintegerfloorastype) rr numendpointretstepr dtr#divr!s r_linspace_scalarr<Cs,   %uSz 2B } **cV2 &C37SC ax 7 HHUOU|T\"S(T{ 3; %eE\3 D E - G udll++ 3 **U* 'Cy r&cUS:a [S5eU(aUS- OUn[R"U5n[R"U5n U(aU (a [XX#XE5$U(dR[ U[R 5(aUR RS:Xd[R"U5S-nU (dR[ U[R 5(aUR RS:Xd[R"U5S-n[R"X[U55n UcU nX- n [R"U4U S9n [SSXS9 U RSS U R--5n US:a0X- n [R"U S:H5(a X-n X-n OX-n O[S 5n X-n X- n U(a US:aXS 'US:wa[R "U SU5n [R""U[R$5(a[R&"XS 9 U R)US S9n U(aX4$U $)a.Returns an array with evenly-spaced values within a given interval. Instead of specifying the step width like :func:`cupy.arange`, this function requires the total number of elements specified. Args: start (scalar or array_like): Starting value(s) of the sequence. stop (scalar or array_like): Ending value(s) of the sequence, unless ``endpoint`` is set to ``False``. In that case, the sequence consists of all but the last of ``num + 1`` evenly spaced samples, so that ``stop`` is excluded. Note that the step size changes when ``endpoint`` is ``False``. num: Number of elements. endpoint (bool): If ``True``, the stop value is included as the last element. Otherwise, the stop value is omitted. retstep (bool): If ``True``, this function returns (array, step). Otherwise, it returns only the array. dtype: Data type specifier. It is inferred from the start and stop arguments by default. axis (int): The axis in the result to store the samples. Relevant only if start or stop are array-like. By default ``0``, the samples will be along a new axis inserted at the beginning. Use ``-1`` to get an axis at the end. Returns: cupy.ndarray: The 1-D array of ranged values. .. seealso:: :func:`numpy.linspace` rz$linspace with num<0 is not supportedrr?rr))r*)rr(r*r+Fr-) ValueErrorrisscalarr< isinstancendarrayr r asarrayr/rrrreshapendimrmoveaxisr3r4r5r6)rr r7r8r9r axisr; scalar_start scalar_stopr:deltar#r!s rlinspacerK}s@ Qw?@@37SC=='L--%K SGKK 5$,,//EKK4D4D4KLL'#-E 4..4::??c3I<<%+D  %uSz 2B } LE **cV2 &C#sC* ++edUZZ// 0C  Qw{ 88DAI   JC+C*CU|kLCC!GB qymmCD) udll++ 3 **U* 'Cy r&c[XX#US9nUc[R"XG5$[R"U5R S;aUR [R5n[R"XG5R U5$)aReturns an array with evenly-spaced values on a log-scale. Instead of specifying the step width like :func:`cupy.arange`, this function requires the total number of elements specified. Args: start: Start of the interval. stop: End of the interval. num: Number of elements. endpoint (bool): If ``True``, the stop value is included as the last element. Otherwise, the stop value is omitted. base (float): Base of the log space. The step sizes between the elements on a log-scale are the same as ``base``. dtype: Data type specifier. It is inferred from the start and stop arguments by default. axis (int): The axis in the result to store the samples. Relevant only if start or stop are array-like. By default ``0``, the samples will be along a new axis inserted at the beginning. Use ``-1`` to get an axis at the end. Returns: cupy.ndarray: The 1-D array of ranged values. .. seealso:: :func:`numpy.logspace` )r7r8rGiu)rKrpowerrr r r6float64)rr r7r8baser rGys rlogspacerRsk6 #tDA }{{4## zz%% HHT\\ " ;;t  & &u --r&cURSS5n[URSS55n[URSS55nU(a&[SR[ U5S55eUS ;a [ S 5eUHHnUR S :wa [ S 5e[U[R5(aM?[ S 5e [U5S ::a [U5$/n[U5H_upuUS:Xa US:XaS nOUS:Xa US :XaSnOUnSU-[S54-S[U5US -- --n URXY5 Ma U(aUn O[ [R"U65n U(a/[![U 55HnXR#5X'M [U 5$)aReturn coordinate matrices from coordinate vectors. Given one-dimensional coordinate arrays ``x1, x2, ... , xn`` this function makes N-D grids. For one-dimensional arrays ``x1, x2, ... , xn`` with lengths ``Ni = len(xi)``, this function returns ``(N1, N2, N3, ..., Nn)`` shaped arrays if indexing='ij' or ``(N2, N1, N3, ..., Nn)`` shaped arrays if indexing='xy'. Unlike NumPy, CuPy currently only supports 1-D arrays as inputs. Args: xi (tuple of ndarrays): 1-D arrays representing the coordinates of a grid. indexing ({'xy', 'ij'}, optional): Cartesian ('xy', default) or matrix ('ij') indexing of output. sparse (bool, optional): If ``True``, a sparse grid is returned in order to conserve memory. Default is ``False``. copy (bool, optional): If ``False``, a view into the original arrays are returned. Default is ``True``. Returns: tuple of cupy.ndarray .. seealso:: :func:`numpy.meshgrid` indexingxyr.TsparseFz2meshgrid() got an unexpected keyword argument '{}'r)rUijz.Valid values for `indexing` are 'xy' and 'ij'.rzinput has to be 1dzinput has to be cupy.ndarrayNN)popboolrformatlistr?rErArrBlentuple enumeratesliceappendbroadcast_arraysranger.) xikwargsrTr.rVxmeshesi left_none expand_slices meshes_brs rmeshgridrls:zz*d+H  64( )D &**Xu- .F  B I IV Q !" "|#MNN  66Q;12 2!T\\**;< <   2w!|Ry F"  t QI  !q&II 9,+( CGy1}$=>?   a&' ..78  s9~&A$<,,.IL'  r&c.\rSrSrSrSSjrSrSrSrg) nd_gridiLa^Construct a multi-dimensional "meshgrid". ``grid = nd_grid()`` creates an instance which will return a mesh-grid when indexed. The dimension and number of the output arrays are equal to the number of indexing dimensions. If the step length is not a complex number, then the stop is not inclusive. However, if the step length is a **complex number** (e.g. 5j), then the integer part of its magnitude is interpreted as specifying the number of points to create between the start and stop values, where the stop value **is inclusive**. If instantiated with an argument of ``sparse=True``, the mesh-grid is open (or not fleshed out) so that only one-dimension of each returned argument is greater than 1. Args: sparse (bool, optional): Whether the grid is sparse or not. Default is False. .. seealso:: :data:`numpy.mgrid` and :data:`numpy.ogrid` cXlgrXrV)selfrVs r__init__nd_grid.__init__es r&c [U[5(aURnURnURnUcSn[U[ 5(al[ U5n[U5nUS:waURU- [US- 5- nURU-n[R"SUS[5U-U-$[R"XCU5$/n[n[[U55HnXRnXRnUcSnUcSn[U[ 5(a*UR[[ U555 [nOCUR[[R"XRU- US-- 555 [U[5(d8[U[5(d#[XR[5(dM[nGM UR (a?[#Xg4[U5-5V V s/sHup[R"XS9PM n n n O[R$"Xg5n [[U55HnXRnXRnUcSnUcSn[U[ 5(a:[[ U55nUS:wa XRU- [US- 5- nXU-U-X'M UR (aj[R&/[U5-n [[U55H5n[SS5X'X[)U 5X'[R&X'M7 U $s sn n f)Nrrr>r)rAr`r!r rcomplexabsrrrr%rcr]ramathrrVzipindicesnewaxisr^) rqkeyr!r rlengthr"r$k_x_tnnslobjs r __getitem__nd_grid.__getitem__hs c5 ! !88D88DIIE}$((4yT19HHu,dQh?Dxx${{1fa7$>FF{{555s3xA6;;DFLLE}|$(( CD N+  36;;#64#:"FGHJ4''ue,,sv{{E22!!" ;; #D&3t9*< =? =fb++b+ = ?Bd(Bs4y!A6;;DFLLE}|$((3t9~19FKK%/5?BDUT\E)BE" ;;\\NSY.E3t9% t,eEl+<<& -?s" M5cg)Nr)rqs r__len__nd_grid.__len__sr&rpN)F) __name__ __module__ __qualname____firstlineno____doc__rrrr__static_attributes__rr&rrnrnLs0;zr&rnrp cupy_arangezbb->bzBB->Bzhh->hzHH->Hzii->izII->Izll->lzLL->Lzqq->qzQQ->Qzee->erzff->fdd->d)zFF->Fzout0 = in0 + float(i) * in1)zDD->Dzout0 = in0 + double(i) * in1zout0 = in0 + i * in1 cupy_linspace)r)zddd->dzout0 = in0 + i * in1 / in2)NrN)2TFN)rTFNr)rTg$@Nr) __future__rrwr rr cupy._utilrr%r<rKrRrlrnmgridogrid create_ufuncrr2r1rr&rrs"  4nBG7tGK^BCG#.LEPZZz ut"" gw'7G gw0!*10/608?0-0/0  $$ ".. "r&