Kh:SSKrSSKrSSKJs Jr SSKJrJrJrJ r J r SSK J r J r SSKJr SSKJr SSKJr SSKJrJr SSKJr SS KJr SS KJr SS KJr SS KJr /S Qr\R@"\RBSS9r!Sr"Sr#\!"\#5S5r$Sr%\!"\%5S5r&Sr'\!"\'5S5r(Sr)\!"\)5S5r*Sr+\!"\+5S5r,\"S5SSS.Sj5r-\R\\-l.Sr/\!"\/5S5r0S r1\!"\15S!5r2S"r3S0S#jr4\!"\45S1S$j5r5S0S%jr6\!"\65S1S&j5r7S'r8\!"\85S(5r9\!"\85S)5r:\!"\85S*5r;S+rS.r?\!"\?5S/5r@g)2N)asarrayzeros zeros_likearray asanyarray)reshape transpose)normalize_axis_index)_array_converter) overrides)vstack atleast_3d)normalize_axis_tuple) set_module_arrays_for_stack_dispatcher)ndindex)matrix) column_stack row_stackdstack array_splitsplithsplitvsplitdsplitapply_over_axes expand_dimsapply_along_axiskrontiletake_along_axisput_along_axisnumpy)modulecR[R"UR[R5(d [ S5e[ U5UR :wa [S5eSUR -n[[U55S/-[[US-UR 55-n/n[X@5H_upgUcURU5 MUSUS-X6S-S-nUR[R"U5RU55 Ma [U5$)Nz"`indices` must be an integer arrayz;`indices` and `arr` must have the same number of dimensionsr())_nx issubdtypedtypeinteger IndexErrorlenndim ValueErrorlistrangezipappendarangertuple) arr_shapeindicesaxis shape_ones dest_dims fancy_indexdimn ind_shapes L/var/www/html/env/lib/python3.13/site-packages/numpy/lib/_shape_base_impl.py_make_along_axis_idxrBs >>'-- 5 5=>> 9~% IK K $JU4[!TF*T%Q 2M-NNIKi+ ;   w '"4C(50:!ef3EEI   szz!}44Y? @ ,  cX4$N)arrr9r:s rA_take_along_axis_dispatcherrH5s >rCcUc6URS:wa [S5eURn[U54nSnO![ X R5nUR nU[ X1U5$)a* Take values from the input array by matching 1d index and data slices. This iterates over matching 1d slices oriented along the specified axis in the index and data arrays, and uses the former to look up values in the latter. These slices can be different lengths. Functions returning an index along an axis, like `argsort` and `argpartition`, produce suitable indices for this function. Parameters ---------- arr : ndarray (Ni..., M, Nk...) Source array indices : ndarray (Ni..., J, Nk...) Indices to take along each 1d slice of `arr`. This must match the dimension of arr, but dimensions Ni and Nj only need to broadcast against `arr`. axis : int The axis to take 1d slices along. If axis is None, the input array is treated as if it had first been flattened to 1d, for consistency with `sort` and `argsort`. Returns ------- out: ndarray (Ni..., J, Nk...) The indexed result. Notes ----- This is equivalent to (but faster than) the following use of `ndindex` and `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] J = indices.shape[axis] # Need not equal M out = np.empty(Ni + (J,) + Nk) for ii in ndindex(Ni): for kk in ndindex(Nk): a_1d = a [ii + s_[:,] + kk] indices_1d = indices[ii + s_[:,] + kk] out_1d = out [ii + s_[:,] + kk] for j in range(J): out_1d[j] = a_1d[indices_1d[j]] Equivalently, eliminating the inner loop, the last two lines would be:: out_1d[:] = a_1d[indices_1d] See Also -------- take : Take along an axis, using the same indices for every 1d slice put_along_axis : Put values into the destination array by matching 1d index and data slices Examples -------- >>> import numpy as np For this sample array >>> a = np.array([[10, 30, 20], [60, 40, 50]]) We can sort either by using sort directly, or argsort and this function >>> np.sort(a, axis=1) array([[10, 20, 30], [40, 50, 60]]) >>> ai = np.argsort(a, axis=1) >>> ai array([[0, 2, 1], [1, 2, 0]]) >>> np.take_along_axis(a, ai, axis=1) array([[10, 20, 30], [40, 50, 60]]) The same works for max and min, if you maintain the trivial dimension with ``keepdims``: >>> np.max(a, axis=1, keepdims=True) array([[30], [60]]) >>> ai = np.argmax(a, axis=1, keepdims=True) >>> ai array([[1], [0]]) >>> np.take_along_axis(a, ai, axis=1) array([[30], [60]]) If we want to get the max and min at the same time, we can stack the indices first >>> ai_min = np.argmin(a, axis=1, keepdims=True) >>> ai_max = np.argmax(a, axis=1, keepdims=True) >>> ai = np.concatenate([ai_min, ai_max], axis=1) >>> ai array([[0, 1], [1, 0]]) >>> np.take_along_axis(a, ai, axis=1) array([[10, 30], [40, 60]]) r(7when axis=None, `indices` must have a single dimension.rr0r1flatr/r shaperB)rGr9r:r8s rAr"r"9smT | <<1 IK KhhXK #D((3II  #I= >>rCc XU4$rErF)rGr9valuesr:s rA_put_along_axis_dispatcherrPs & !!rCcUc6URS:wa [S5eURnSn[U54nO![ X0R5nUR nX [ XAU5'g)a$ Put values into the destination array by matching 1d index and data slices. This iterates over matching 1d slices oriented along the specified axis in the index and data arrays, and uses the former to place values into the latter. These slices can be different lengths. Functions returning an index along an axis, like `argsort` and `argpartition`, produce suitable indices for this function. Parameters ---------- arr : ndarray (Ni..., M, Nk...) Destination array. indices : ndarray (Ni..., J, Nk...) Indices to change along each 1d slice of `arr`. This must match the dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast against `arr`. values : array_like (Ni..., J, Nk...) values to insert at those indices. Its shape and dimension are broadcast to match that of `indices`. axis : int The axis to take 1d slices along. If axis is None, the destination array is treated as if a flattened 1d view had been created of it. Notes ----- This is equivalent to (but faster than) the following use of `ndindex` and `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] J = indices.shape[axis] # Need not equal M for ii in ndindex(Ni): for kk in ndindex(Nk): a_1d = a [ii + s_[:,] + kk] indices_1d = indices[ii + s_[:,] + kk] values_1d = values [ii + s_[:,] + kk] for j in range(J): a_1d[indices_1d[j]] = values_1d[j] Equivalently, eliminating the inner loop, the last two lines would be:: a_1d[indices_1d] = values_1d See Also -------- take_along_axis : Take values from the input array by matching 1d index and data slices Examples -------- >>> import numpy as np For this sample array >>> a = np.array([[10, 30, 20], [60, 40, 50]]) We can replace the maximum values with: >>> ai = np.argmax(a, axis=1, keepdims=True) >>> ai array([[1], [0]]) >>> np.put_along_axis(a, ai, 99, axis=1) >>> a array([[10, 99, 20], [99, 40, 50]]) Nr(rJrrK)rGr9rOr:r8s rAr#r#skR | <<1 IK KhhXK #D((3II ;AY67rCcU4$rErF)func1dr:rGargskwargss rA_apply_along_axis_dispatcherrVs 6MrCc[U5nUSnURn[X5n[[ U55n[ X'SUXqS-S-U/-5n[ URSS5n SU 5n [U 5n [U"X/UQ70UD65n [U [5(d$[XRSSU R-S9n O.[URSSU R-U R S9n [[ U R55n U SUXRU R- U R-XU RU R- -nXU 'U Hn[U"X/UQ70UD65X'M [ X5n UR#U 5$![a [S5Sef=f) a* Apply a function to 1-D slices along the given axis. Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays and `a` is a 1-D slice of `arr` along `axis`. This is equivalent to (but faster than) the following use of `ndindex` and `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices:: Ni, Nk = a.shape[:axis], a.shape[axis+1:] for ii in ndindex(Ni): for kk in ndindex(Nk): f = func1d(arr[ii + s_[:,] + kk]) Nj = f.shape for jj in ndindex(Nj): out[ii + jj + kk] = f[jj] Equivalently, eliminating the inner loop, this can be expressed as:: Ni, Nk = a.shape[:axis], a.shape[axis+1:] for ii in ndindex(Ni): for kk in ndindex(Nk): out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk]) Parameters ---------- func1d : function (M,) -> (Nj...) This function should accept 1-D arrays. It is applied to 1-D slices of `arr` along the specified axis. axis : integer Axis along which `arr` is sliced. arr : ndarray (Ni..., M, Nk...) Input array. args : any Additional arguments to `func1d`. kwargs : any Additional named arguments to `func1d`. Returns ------- out : ndarray (Ni..., Nj..., Nk...) The output array. The shape of `out` is identical to the shape of `arr`, except along the `axis` dimension. This axis is removed, and replaced with new dimensions equal to the shape of the return value of `func1d`. So if `func1d` returns a scalar `out` will have one fewer dimensions than `arr`. See Also -------- apply_over_axes : Apply a function repeatedly over multiple axes. Examples -------- >>> import numpy as np >>> def my_func(a): ... """Average first and last element of a 1-D array""" ... return (a[0] + a[-1]) * 0.5 >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) >>> np.apply_along_axis(my_func, 0, b) array([4., 5., 6.]) >>> np.apply_along_axis(my_func, 1, b) array([2., 5., 8.]) For a function that returns a 1D array, the number of dimensions in `outarr` is the same as `arr`. >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]]) >>> np.apply_along_axis(sorted, 1, b) array([[1, 7, 8], [3, 4, 9], [2, 5, 6]]) For a function that returns a higher dimensional array, those dimensions are inserted in place of the `axis` dimension. >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) >>> np.apply_along_axis(np.diag, -1, b) array([[[1, 0, 0], [0, 2, 0], [0, 0, 3]], [[4, 0, 0], [0, 5, 0], [0, 0, 6]], [[7, 0, 0], [0, 8, 0], [0, 0, 9]]]) rNr(r)c34# UHo[4-v M g7frE)Ellipsis).0inds rA #apply_along_axis..ys .#8+ sz;Cannot apply_along_axis when any iteration dimensions are 0)rMr,)r r0r r2r3r rrMnext StopIterationr1r isinstancerrrr,wrap)rSr:rGrTrUconvndin_dims inarr_viewindsind0resbuff buff_dims buff_permuter[s rArrst C D q'C B  )D59oG3a1A ATF JKJ :##CR( )D . .DDz VJ,>t>v> ?C c6 " "#%5%5cr%:SYY%FGZ%%cr*SYY6ciiHU499%&I!d))CHH$tyy1 2388+, -JvjoGGGH  D 'C 99S>=  I  s 8 F((F?cU4$rErF)funcaaxess rA_apply_over_axes_dispatcherrq 4KrCcB[U5nURn[U5RS:XaU4nUHenUS:aXE-nX54nU"U6nURUR:XaUnM3[Xu5nURUR:XaUnM\[ S5e U$)a Apply a function repeatedly over multiple axes. `func` is called as `res = func(a, axis)`, where `axis` is the first element of `axes`. The result `res` of the function call must have either the same dimensions as `a` or one less dimension. If `res` has one less dimension than `a`, a dimension is inserted before `axis`. The call to `func` is then repeated for each axis in `axes`, with `res` as the first argument. Parameters ---------- func : function This function must take two arguments, `func(a, axis)`. a : array_like Input array. axes : array_like Axes over which `func` is applied; the elements must be integers. Returns ------- apply_over_axis : ndarray The output array. The number of dimensions is the same as `a`, but the shape can be different. This depends on whether `func` changes the shape of its output with respect to its input. See Also -------- apply_along_axis : Apply a function to 1-D slices of an array along the given axis. Notes ----- This function is equivalent to tuple axis arguments to reorderable ufuncs with keepdims=True. Tuple axis arguments to ufuncs have been available since version 1.7.0. Examples -------- >>> import numpy as np >>> a = np.arange(24).reshape(2,3,4) >>> a array([[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]]) Sum over axes 0 and 2. The result has same number of dimensions as the original array: >>> np.apply_over_axes(np.sum, a, [0,2]) array([[[ 60], [ 92], [124]]]) Tuple axis arguments to ufuncs are equivalent: >>> np.sum(a, axis=(0,2), keepdims=True) array([[[ 60], [ 92], [124]]]) rz7function is not returning an array of the correct shape)rr0rrr1)rnrorpvalNr:rTris rArrsF !*C A T{1w !88D{Dk 88sxx Cc(Cxx388# "ABB JrCcU4$rErF)ror:s rA_expand_dims_dispatcherrwrrrCc[U[5(a [U5nO [U5n[ U5[ [ 4;aU4n[U5UR-n[X5n[UR5n[U5Vs/sHoDU;aSO [U5PM nnURU5$s snf)a Expand the shape of an array. Insert a new axis that will appear at the `axis` position in the expanded array shape. Parameters ---------- a : array_like Input array. axis : int or tuple of ints Position in the expanded axes where the new axis (or axes) is placed. .. deprecated:: 1.13.0 Passing an axis where ``axis > a.ndim`` will be treated as ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will be treated as ``axis == 0``. This behavior is deprecated. Returns ------- result : ndarray View of `a` with the number of dimensions increased. See Also -------- squeeze : The inverse operation, removing singleton dimensions reshape : Insert, remove, and combine dimensions, and resize existing ones atleast_1d, atleast_2d, atleast_3d Examples -------- >>> import numpy as np >>> x = np.array([1, 2]) >>> x.shape (2,) The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``: >>> y = np.expand_dims(x, axis=0) >>> y array([[1, 2]]) >>> y.shape (1, 2) The following is equivalent to ``x[:, np.newaxis]``: >>> y = np.expand_dims(x, axis=1) >>> y array([[1], [2]]) >>> y.shape (2, 1) ``axis`` may also be a tuple: >>> y = np.expand_dims(x, axis=(0, 1)) >>> y array([[[1, 2]]]) >>> y = np.expand_dims(x, axis=(2, 0)) >>> y array([[[1], [2]]]) Note that some examples may use ``None`` instead of ``np.newaxis``. These are the same objects: >>> np.newaxis is None True r()rarrrtyper7r2r/r0riterrMr3r_r)ror:out_ndimshape_itaxrMs rArrsR!V AJ qM Dz%&w4y166!H  /DAGG}H;@? K?R*Q$x. 0?E K 99U  LsB= same_kindr,castingcJ[R"S[SS9 [XUS9$)Nz:`row_stack` alias is deprecated. Use `np.vstack` directly. stacklevelr)warningswarnDeprecationWarningr )tupr,rs rArrZs* MM $  #G 44rCc[U5$rErrs rA_column_stack_dispatcherri ' ,,rCc/nUHEn[U5nURS:a[USSSS9RnUR U5 MG [ R "US5$)a Stack 1-D arrays as columns into a 2-D array. Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with `hstack`. 1-D arrays are turned into 2-D columns first. Parameters ---------- tup : sequence of 1-D or 2-D arrays. Arrays to stack. All of them must have the same first dimension. Returns ------- stacked : 2-D array The array formed by stacking the given arrays. See Also -------- stack, hstack, vstack, concatenate Examples -------- >>> import numpy as np >>> a = np.array((1,2,3)) >>> b = np.array((2,3,4)) >>> np.column_stack((a,b)) array([[1, 2], [2, 3], [3, 4]]) rNTcopysubokndminr()rr0rTr5r* concatenate)rarraysvrGs rArrms]FF m 88a<$d!<>>C c  ??61 %%rCc[U5$rErrs rA_dstack_dispatcherrrrCcp[U6n[U[5(dU4n[R"US5$)a Stack arrays in sequence depth wise (along third axis). This is equivalent to concatenation along the third axis after 2-D arrays of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by `dsplit`. This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions `concatenate`, `stack` and `block` provide more general stacking and concatenation operations. Parameters ---------- tup : sequence of arrays The arrays must have the same shape along all but the third axis. 1-D or 2-D arrays must have the same shape. Returns ------- stacked : ndarray The array formed by stacking the given arrays, will be at least 3-D. See Also -------- concatenate : Join a sequence of arrays along an existing axis. stack : Join a sequence of arrays along a new axis. block : Assemble an nd-array from nested lists of blocks. vstack : Stack arrays in sequence vertically (row wise). hstack : Stack arrays in sequence horizontally (column wise). column_stack : Stack 1-D arrays as columns into a 2-D array. dsplit : Split array along third axis. Examples -------- >>> import numpy as np >>> a = np.array((1,2,3)) >>> b = np.array((2,3,4)) >>> np.dstack((a,b)) array([[[1, 2], [2, 3], [3, 4]]]) >>> a = np.array([[1],[2],[3]]) >>> b = np.array([[2],[3],[4]]) >>> np.dstack((a,b)) array([[[1, 2]], [[2, 3]], [[3, 4]]]) r)rrar7r*r)rarrss rArrs4l s D dE " "w ??4 ##rCc [[U55Hn[R"X5S:Xa%[R"SXR S9X'MD[R "[R"[R"X5S55(dM[R"SXR S9X'M U$)Nrr^) r3r/r*r0emptyr,sometrueequalrM)sub_arysis rA_replace_zero_by_x_arraysrs 3x= ! 88HK A %))AX[->->?HK \\#))CIIhk$:A> ? ?))AX[->->?HK " OrCcX4$rErFaryindices_or_sectionsr:s rA_array_split_dispatcherr  %%rCc^URUn[U5S-nS/[U5-U/-n/n [R"XS5n [U5H7n X[n X[S-n U R[R"XU US55 M9 U $![a [U5nNf=f![as [ U5nUS::a [ S5Se[X45upgS/XvS-/--XG- U/--n[R"U[RS9R5nNf=f)a Split an array into multiple sub-arrays. Please refer to the ``split`` documentation. The only difference between these functions is that ``array_split`` allows `indices_or_sections` to be an integer that does *not* equally divide the axis. For an array of length l that should be split into n sections, it returns l % n sub-arrays of size l//n + 1 and the rest of size l//n. See Also -------- split : Split array into multiple sub-arrays of equal size. Examples -------- >>> import numpy as np >>> x = np.arange(8.0) >>> np.array_split(x, 3) [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])] >>> x = np.arange(9) >>> np.array_split(x, 4) [array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])] r(rz&number sections must be larger than 0.Nr^)rMAttributeErrorr/r2 TypeErrorintr1divmodr*rintpcumsumswapaxesr3r5)rrr:Ntotal Nsections div_points Neach_sectionextras section_sizesrsaryrstends rArrsC84 G+,q0 S4 344x? H <<1 %D 9  ]Q TS\4;< O1 S  G+, >EFD P &v 9 ?"334#*}o=> YY}CHH=DDF  Gs#B!B/B,+B,/A:D,+D,cX4$rErFrs rA_split_dispatcherrrrCc[U5 [ XU5$![a) UnURUnXC-(a [S5SeN>f=f)a Split an array into multiple sub-arrays as views into `ary`. Parameters ---------- ary : ndarray Array to be divided into sub-arrays. indices_or_sections : int or 1-D array If `indices_or_sections` is an integer, N, the array will be divided into N equal arrays along `axis`. If such a split is not possible, an error is raised. If `indices_or_sections` is a 1-D array of sorted integers, the entries indicate where along `axis` the array is split. For example, ``[2, 3]`` would, for ``axis=0``, result in - ary[:2] - ary[2:3] - ary[3:] If an index exceeds the dimension of the array along `axis`, an empty sub-array is returned correspondingly. axis : int, optional The axis along which to split, default is 0. Returns ------- sub-arrays : list of ndarrays A list of sub-arrays as views into `ary`. Raises ------ ValueError If `indices_or_sections` is given as an integer, but a split does not result in equal division. See Also -------- array_split : Split an array into multiple sub-arrays of equal or near-equal size. Does not raise an exception if an equal division cannot be made. hsplit : Split array into multiple sub-arrays horizontally (column-wise). vsplit : Split array into multiple sub-arrays vertically (row wise). dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). concatenate : Join a sequence of arrays along an existing axis. stack : Join a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise). vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third dimension). Examples -------- >>> import numpy as np >>> x = np.arange(9.0) >>> np.split(x, 3) [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])] >>> x = np.arange(8.0) >>> np.split(x, [3, 5, 6, 10]) [array([0., 1., 2.]), array([3., 4.]), array([5.]), array([6., 7.]), array([], dtype=float64)] z0array split does not result in an equal divisionN)r/rrMr1r)rrr:sectionsrus rArr#seHN   s 66 N& IIdO <BDIM N Ns 0A  A cX4$rErFrrs rA_hvdsplit_dispatcherrrrrCc[R"U5S:Xa [S5eURS:a [XS5$[XS5$)a Split an array into multiple sub-arrays horizontally (column-wise). Please refer to the `split` documentation. `hsplit` is equivalent to `split` with ``axis=1``, the array is always split along the second axis except for 1-D arrays, where it is split at ``axis=0``. See Also -------- split : Split an array into multiple sub-arrays of equal size. Examples -------- >>> import numpy as np >>> x = np.arange(16.0).reshape(4, 4) >>> x array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.], [12., 13., 14., 15.]]) >>> np.hsplit(x, 2) [array([[ 0., 1.], [ 4., 5.], [ 8., 9.], [12., 13.]]), array([[ 2., 3.], [ 6., 7.], [10., 11.], [14., 15.]])] >>> np.hsplit(x, np.array([3, 6])) [array([[ 0., 1., 2.], [ 4., 5., 6.], [ 8., 9., 10.], [12., 13., 14.]]), array([[ 3.], [ 7.], [11.], [15.]]), array([], shape=(4, 0), dtype=float64)] With a higher dimensional array the split is still along the second axis. >>> x = np.arange(8.0).reshape(2, 2, 2) >>> x array([[[0., 1.], [2., 3.]], [[4., 5.], [6., 7.]]]) >>> np.hsplit(x, 2) [array([[[0., 1.]], [[4., 5.]]]), array([[[2., 3.]], [[6., 7.]]])] With a 1-D array, the split is along axis 0. >>> x = np.array([0, 1, 2, 3, 4, 5]) >>> np.hsplit(x, 2) [array([0, 1, 2]), array([3, 4, 5])] rz3hsplit only works on arrays of 1 or more dimensionsr(r*r0r1rrs rArrvsF~ xx}NOO xx!|Sq11Sq11rCcd[R"U5S:a [S5e[XS5$)a Split an array into multiple sub-arrays vertically (row-wise). Please refer to the ``split`` documentation. ``vsplit`` is equivalent to ``split`` with `axis=0` (default), the array is always split along the first axis regardless of the array dimension. See Also -------- split : Split an array into multiple sub-arrays of equal size. Examples -------- >>> import numpy as np >>> x = np.arange(16.0).reshape(4, 4) >>> x array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.], [12., 13., 14., 15.]]) >>> np.vsplit(x, 2) [array([[0., 1., 2., 3.], [4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.], [12., 13., 14., 15.]])] >>> np.vsplit(x, np.array([3, 6])) [array([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)] With a higher dimensional array the split is still along the first axis. >>> x = np.arange(8.0).reshape(2, 2, 2) >>> x array([[[0., 1.], [2., 3.]], [[4., 5.], [6., 7.]]]) >>> np.vsplit(x, 2) [array([[[0., 1.], [2., 3.]]]), array([[[4., 5.], [6., 7.]]])] rz3vsplit only works on arrays of 2 or more dimensionsrrrs rArrs.b xx}qNOO 1 --rCcd[R"U5S:a [S5e[XS5$)a Split array into multiple sub-arrays along the 3rd axis (depth). Please refer to the `split` documentation. `dsplit` is equivalent to `split` with ``axis=2``, the array is always split along the third axis provided the array dimension is greater than or equal to 3. See Also -------- split : Split an array into multiple sub-arrays of equal size. Examples -------- >>> import numpy as np >>> x = np.arange(16.0).reshape(2, 2, 4) >>> x array([[[ 0., 1., 2., 3.], [ 4., 5., 6., 7.]], [[ 8., 9., 10., 11.], [12., 13., 14., 15.]]]) >>> np.dsplit(x, 2) [array([[[ 0., 1.], [ 4., 5.]], [[ 8., 9.], [12., 13.]]]), array([[[ 2., 3.], [ 6., 7.]], [[10., 11.], [14., 15.]]])] >>> np.dsplit(x, np.array([3, 6])) [array([[[ 0., 1., 2.], [ 4., 5., 6.]], [[ 8., 9., 10.], [12., 13., 14.]]]), array([[[ 3.], [ 7.]], [[11.], [15.]]]), array([], shape=(2, 2, 0), dtype=float64)] z3dsplit only works on arrays of 3 or more dimensionsrrrs rArrs.R xx}qNOO 1 --rCc[R"S[SS9 [S[ U555nU(aUSS$g)zFind the wrapper for the array with the highest priority. In case of ties, leftmost wins. If no wrapper is found, return None. .. deprecated:: 2.0 z9`get_array_wrap` is deprecated. (deprecated in NumPy 2.0)rrc3# UH5up[US5(dM[USS5U*UR4v M7 g7f)__array_wrap____array_priority__rN)hasattrgetattrr)rZrxs rAr\!get_array_wrap..1sCD/>tq&-a1A&B#wq"6:QB!!#/>s?"?r)N)rrrsorted enumerate)rTwrapperss rAget_array_wrapr!sR MM $ D/8DDH|B rCcX4$rErF)robs rA_kron_dispatcherr9s 6MrCc [U5n[USSURS9n[U[5=(d [U[5nURURpC[ X45nUS:XdUS:Xa[ R"X5$URnURnURR(d [X5nURR(d [X5nS[ SX4- 5-U-nS[ SXC- 5-U-n[U[[X4- 55S9n[U[[XC- 55S9n [U[[SUS-S55S9n[U [[SUS-S55S9n [ R"XU(+S 9n U R[ R"Xg55n U(dU $[ U S S 9$) aM Kronecker product of two arrays. Computes the Kronecker product, a composite array made of blocks of the second array scaled by the first. Parameters ---------- a, b : array_like Returns ------- out : ndarray See Also -------- outer : The outer product Notes ----- The function assumes that the number of dimensions of `a` and `b` are the same, if necessary prepending the smallest with ones. If ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``, the Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``. The elements are products of elements from `a` and `b`, organized explicitly by:: kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN] where:: kt = it * st + jt, t = 0,...,N In the common 2-D case (N=1), the block structure can be visualized:: [[ a[0,0]*b, a[0,1]*b, ... , a[0,-1]*b ], [ ... ... ], [ a[-1,0]*b, a[-1,1]*b, ... , a[-1,-1]*b ]] Examples -------- >>> import numpy as np >>> np.kron([1,10,100], [5,6,7]) array([ 5, 6, 7, ..., 500, 600, 700]) >>> np.kron([5,6,7], [1,10,100]) array([ 5, 50, 500, ..., 7, 70, 700]) >>> np.kron(np.eye(2), np.ones((2,2))) array([[1., 1., 0., 0.], [1., 1., 0., 0.], [0., 0., 1., 1.], [0., 0., 1., 1.]]) >>> a = np.arange(100).reshape((2,5,2,5)) >>> b = np.arange(24).reshape((2,3,4)) >>> c = np.kron(a,b) >>> c.shape (2, 10, 6, 20) >>> I = (1,3,0,2) >>> J = (0,2,1) >>> J1 = (0,) + J # extend to ndim=4 >>> S1 = (1,) + b.shape >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1)) >>> c[K] == a[I]*b[J] True NTrrr')r:r(r)rF)r)rrr0rarmaxr*multiplyrMflags contiguousrrr7r3) ror is_any_matndbndardas_bsa_arrb_arrresults rAr r =s^ 1 A ad$aff5AAv&?*Q*?Jvvqvv SB qC1H||A!! ''C B 77   AO 77   AN s1cg  $C c!SWo  "B eCGn 5 6E eCGn 5 6E E%2a4*;$< =E E%2a4*;$< =E \\%:~ ?F^^CLL1 2F#6CU)CCrCcX4$rErF)Arepss rA_tile_dispatcherrs 9rCc[U5n[U5n[SU55(a6[ U[ R 5(a[ R"USSUS9$[ R"USSUS9nX4R:aSURU- -U-n[S[URU555nURnUS:aK[URU5H1upxUS:wa"URS U5RUS5nXg-nM3 URU5$![a U4nGN7f=f) aX Construct an array by repeating A the number of times given by reps. If `reps` has length ``d``, the result will have dimension of ``max(d, A.ndim)``. If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, or shape (1, 1, 3) for 3-D replication. If this is not the desired behavior, promote `A` to d-dimensions manually before calling this function. If ``A.ndim > d``, `reps` is promoted to `A`.ndim by prepending 1's to it. Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as (1, 1, 2, 2). Note : Although tile may be used for broadcasting, it is strongly recommended to use numpy's broadcasting operations and functions. Parameters ---------- A : array_like The input array. reps : array_like The number of repetitions of `A` along each axis. Returns ------- c : ndarray The tiled output array. See Also -------- repeat : Repeat elements of an array. broadcast_to : Broadcast an array to a new shape Examples -------- >>> import numpy as np >>> a = np.array([0, 1, 2]) >>> np.tile(a, 2) array([0, 1, 2, 0, 1, 2]) >>> np.tile(a, (2, 2)) array([[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]]) >>> np.tile(a, (2, 1, 2)) array([[[0, 1, 2, 0, 1, 2]], [[0, 1, 2, 0, 1, 2]]]) >>> b = np.array([[1, 2], [3, 4]]) >>> np.tile(b, 2) array([[1, 2, 1, 2], [3, 4, 3, 4]]) >>> np.tile(b, (2, 1)) array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> c = np.array([1,2,3,4]) >>> np.tile(c,(4,1)) array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]) c3*# UH oS:Hv M g7f)r(NrF)rZrs rAr\tile..s 3a63sTrNr'c3.# UH upX-v M g7frErF)rZsts rAr\rs8&7daac&7srr(r))r7rr/allrar*ndarrayrr0r4rMsizerrepeat) rrrdc shape_outr?dim_innreps rAr!r!sHDk CA 3 Jq#++$>$>yyT;; IIad$a 8 FF AFF1Ho#8c!''3&788I A1u-LFqyIIb!$++D!4 LA. 99Y ) gs D44 EErE)r)A functoolsrnumpy._core.numeric_corenumericr*rrrrrnumpy._core.fromnumericrr numpy._core.multiarrayr numpy._core._multiarray_umathr numpy._corer r rrnumpy._core.overridesrnumpy._core.shape_basernumpy.lib._index_tricks_implrnumpy.matrixlib.defmatrixr__all__partialarray_function_dispatchrBrHr"rPr#rVrrqrrwrr__doc__rrrrrrrrrrrrrrrr rr!rFrCrArs`!!MM67:!*4,?0, $++ %%g7.45u?6u?p"34TA5TAn56I7IX45T6Tn01V2Vt G +55NN -12(&3(&V-+,8$-8$v&01525p&*+K7,K7\&-.C2/C2L-.2./2.j-.*./*.Z0)*oD+oDd)*Y +Y rC