3
���hܕ � @ s@ d dl Z d dljjZd dlmZmZmZmZm Z m
Z
d dl m Z m
Z
d dlmZ d dlmZ d dlmZmZ d dlmZ d dlmZ d d lmZ d d
lmZ d d d
dddddddddddddgZe j ej dd �Z d d � Z d d � Z e e �d!d� �Z d"d#� Z!e e!�d$d� �Z"d%d&� Z#e e#�d'd� �Z$d(d)� Z%e e%�d*d� �Z&d+d,� Z'e e'�d-d� �Z(eZ)d.d/� Z*e e*�d0d � �Z+d1d2� Z,e e,�d3d
� �Z-d4d5� Z.dJd6d7�Z/e e/�dKd8d��Z0dLd9d:�Z1e e1�dMd;d��Z2d<d=� Z3e e3�d>d� �Z4e e3�d?d� �Z5e e3�d@d� �Z6dAdB� Z7dCd� Z8dDdE� Z9e e9�dFd� �Z:dGdH� Z;e e;�dId� �Z<dS )N� N)�asarray�zeros�outer� concatenate�array�
asanyarray)�reshape� transpose)�normalize_axis_index)� overrides)�vstack�
atleast_3d)�normalize_axis_tuple)� _arrays_for_stack_dispatcher)�ndindex)�matrix� column_stack� row_stack�dstack� array_split�split�hsplit�vsplit�dsplit�apply_over_axes� expand_dims�apply_along_axis�kron�tile�get_array_wrap�take_along_axis�put_along_axisZnumpy)�modulec C s� t j|jt j�std��t| �|jkr.td��d|j }tt |��d g tt |d |j�� }g }x`t
|| �D ]R\}}|d kr�|j |� qn|d |� d ||d d � }|j t j |�j
|�� qnW t|�S )Nz"`indices` must be an integer arrayz;`indices` and `arr` must have the same number of dimensions� )r# ���)r$ )�_nxZ
issubdtype�dtype�integer�
IndexError�len�ndim�
ValueError�list�range�zip�appendZaranger �tuple) � arr_shape�indices�axisZ
shape_onesZ dest_dimsZ fancy_indexZdim�nZ ind_shape� r5 �5/tmp/pip-build-5_djhm0z/numpy/numpy/lib/shape_base.py�_make_along_axis_idx s
& r7 c C s | |fS )Nr5 )�arrr2 r3 r5 r5 r6 �_take_along_axis_dispatcher4 s r9 c C s@ |dkr | j } t| �f}d}nt|| j�}| j}| t|||� S )at
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.
.. versionadded:: 1.15.0
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
--------
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 expand the dimensions:
>>> np.expand_dims(np.max(a, axis=1), axis=1)
array([[30],
[60]])
>>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
>>> 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.expand_dims(np.argmin(a, axis=1), axis=1)
>>> ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1)
>>> 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]])
Nr )�flatr) r
r* �shaper7 )r8 r2 r3 r1 r5 r5 r6 r 8 s i
c C s
| ||fS )Nr5 )r8 r2 �valuesr3 r5 r5 r6 �_put_along_axis_dispatcher� s r= c C sD |dkr | j } d}t| �f}nt|| j�}| j}|| t|||�< dS )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.
.. versionadded:: 1.15.0
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
--------
For this sample array
>>> a = np.array([[10, 30, 20], [60, 40, 50]])
We can replace the maximum values with:
>>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
>>> ai
array([[1],
[0]])
>>> np.put_along_axis(a, ai, 99, axis=1)
>>> a
array([[10, 99, 20],
[99, 40, 50]])
Nr )r: r) r
r* r; r7 )r8 r2 r< r3 r1 r5 r5 r6 r! � s J c O s |fS )Nr5 )�func1dr3 r8 �args�kwargsr5 r5 r6 � _apply_along_axis_dispatcher s rA c O s� t |�}|j}t||�}tt|��}t||d|� ||d d� |g �}t|jdd� �}dd� |D �}y t|�} W n, t k
r� }
zt
d�d�W Y dd}
~
X nX t | || f|�|��} t |jdd� | j | j �} tt| j��}
|
d|� |
| j| j | j� |
|| j| j � }t
| t��s4| j| �} | | | < x*|D ]"}t | || f|�|��| |< �qBW t
| t��s�| j| �} t| |�S t| |�}| j|�S dS ) aU
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`.
.. versionadded:: 1.9.0
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
--------
>>> 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]]])
Nr# c s s | ]}|t f V qd S )N)�Ellipsis)�.0�indr5 r5 r6 � <genexpr>r s z#apply_along_axis.<locals>.<genexpr>z;Cannot apply_along_axis when any iteration dimensions are 0r r$ r$ )r r* r
r, r- r r r; �next�
StopIterationr+ r r& �
isinstancer �__array_prepare__�__array_wrap__)r> r3 r8 r? r@ �ndZin_dimsZ
inarr_viewZindsZind0�e�resZbuffZ buff_dimsZ buff_permuterD Zout_arrr5 r5 r6 r s8 \
(
"
c C s |fS )Nr5 )�func�a�axesr5 r5 r6 �_apply_over_axes_dispatcher� s rQ c C s� t |�}|j}t|�jdkr"|f}xb|D ]Z}|dk r<|| }||f}| |� }|j|jkr^|}q(t||�}|j|jkrz|}q(td��q(W |S )az
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
--------
>>> 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]]])
r z7function is not returning an array of the correct shape)r r* r r r+ )rN rO rP �val�Nr3 r? rM r5 r5 r6 r � s B
c C s | fS )Nr5 )rO r3 r5 r5 r6 �_expand_dims_dispatcher� s rT c sv t | t�rt| �} nt| �} t� �ttfkr2� f� t� �| j }t � |�� t
| j ��� �fdd�t |�D �}| j
|�S )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.
.. versionchanged:: 1.18.0
A tuple of axes is now supported. Out of range axes as
described above are now forbidden and raise an `AxisError`.
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
doc.indexing, atleast_1d, atleast_2d, atleast_3d
Examples
--------
>>> 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
c s g | ]}|� krd nt ���qS )r# )rF )rC Zax)r3 �shape_itr5 r6 �
<listcomp>X s z expand_dims.<locals>.<listcomp>)rH r r r �typer0 r, r) r* r �iterr; r- r )rO r3 Zout_ndimr; r5 )r3 rU r6 r s L
c C s t | �S )N)r )�tupr5 r5 r6 �_column_stack_dispatcher` s rZ c C sd t jst| dd� g }x@| D ]8}t|ddd�}|jdk rJt|dddd�j}|j|� q W tj|d�S )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
--------
>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],
[2, 3],
[3, 4]])
� )�
stacklevelFT)�copy�subok)r] r^ �ndminr# ) r �ARRAY_FUNCTION_ENABLEDr r r* �Tr/ r% r )rY Zarrays�vr8 r5 r5 r6 r d s "
c C s t | �S )N)r )rY r5 r5 r6 �_dstack_dispatcher� s rc c C s6 t jst| dd� t| � }t|t�s*|g}tj|d�S )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
--------
>>> 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[ )r\ )r r` r r
rH r, r% r )rY Zarrsr5 r5 r6 r � s 5
c C sz xtt t| ��D ]d}tj| | �dkr>tjd| | jd�| |< qtjtjtj| | �d��rtjd| | jd�| |< qW | S )Nr )r& ) r- r) r% r* �emptyr& Zsometrue�equalr; )�sub_arys�ir5 r5 r6 �_replace_zero_by_x_arrays� s rh c C s | |fS )Nr5 )�ary�indices_or_sectionsr3 r5 r5 r6 �_array_split_dispatcher� s rk c C s y| j | }W n tk
r* t| �}Y nX y$t|�d }dgt|� |g }W np tk
r� t|�}|dkrxtd��t||�\}}dg||d g || |g }tj |tj
d�j � }Y nX g } tj | |d�}
x@t
|�D ]4} || } || d }
| jtj |
| |
� |d�� q�W | S )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
--------
>>> x = np.arange(8.0)
>>> np.array_split(x, 3)
[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])]
>>> x = np.arange(7.0)
>>> np.array_split(x, 3)
[array([0., 1., 2.]), array([3., 4.]), array([5., 6.])]
r# r z&number sections must be larger than 0.)r& )r; �AttributeErrorr) r, � TypeError�intr+ �divmodr% r ZintpZcumsumZswapaxesr- r/ )ri rj r3 ZNtotalZ NsectionsZ
div_pointsZ
Neach_section�extrasZ
section_sizesrf Zsaryrg �st�endr5 r5 r6 r � s, c C s | |fS )Nr5 )ri rj r3 r5 r5 r6 �_split_dispatcher s rs c C sL y t |� W n2 tk
r> |}| j| }|| r:td��Y nX t| ||�S )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
--------
>>> 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 division)r) rm r; r+ r )ri rj r3 �sectionsrS r5 r5 r6 r s C
c C s | |fS )Nr5 )ri rj r5 r5 r6 �_hvdsplit_dispatcherm s ru c C s< t j| �dkrtd��| jdkr,t| |d�S t| |d�S dS )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 regardless of the array dimension.
See Also
--------
split : Split an array into multiple sub-arrays of equal size.
Examples
--------
>>> 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.]]])]
r z3hsplit only works on arrays of 1 or more dimensionsr# N)r% r* r+ r )ri rj r5 r5 r6 r q s
8
c C s" t j| �dk rtd��t| |d�S )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
--------
>>> 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.]]])]
r[ z3vsplit only works on arrays of 2 or more dimensionsr )r% r* r+ r )ri rj r5 r5 r6 r � s ,c C s" t j| �dk rtd��t| |d�S )am
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
--------
>>> 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 dimensionsr[ )r% r* r+ r )ri rj r5 r5 r6 r � s (c G s* t dd� t| �D ��}|r&|d d S dS )z�Find the wrapper for the array with the highest priority.
In case of ties, leftmost wins. If no wrapper is found, return None
c s s2 | ]*\}}t |d �rt|dd�| |jfV qdS )rI �__array_priority__r N)�hasattr�getattrrI )rC rg �xr5 r5 r6 rE s z$get_array_prepare.<locals>.<genexpr>r# Nr$ r$ )�sorted� enumerate)r? �wrappersr5 r5 r6 �get_array_prepare s
r~ c G s* t dd� t| �D ��}|r&|d d S dS )z�Find the wrapper for the array with the highest priority.
In case of ties, leftmost wins. If no wrapper is found, return None
c s s2 | ]*\}}t |d �rt|dd�| |jfV qdS )rJ rw r N)rx ry rJ )rC rg rz r5 r5 r6 rE s z!get_array_wrap.<locals>.<genexpr>r# Nr$ r$ )r{ r| )r? r} r5 r5 r6 r s
c C s | |fS )Nr5 )rO �br5 r5 r6 �_kron_dispatcher' s r� c C s$ t |�}t| dd|jd�} |j| j }}|dks8|dkrDtj| |�S | j}|j}| jjsbt| |�} |jjstt||�}|}||kr�||kr�d|| | }nd || | }|}t | |�j|| �}|d }x t
|�D ]} t ||d�}q�W t | |�}
|
dk �r|
|�}t
| |�}
|
dk �r |
|�}|S )
a�
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
--------
>>> 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
FT)r] r^ r_ r r# )r3 N)r# )r# )r r r* r% �multiplyr; �flags�
contiguousr r r- r r~ r ) rO r ZndbZndaZas_�bsrK �resultr3 �_�wrapperr5 r5 r6 r + s8 E
c C s | |fS )Nr5 )�A�repsr5 r5 r6 �_tile_dispatcher� s r� c C s� y t |�}W n tk
r& |f}Y nX t|�}tdd� |D ��r`t| tj�r`tj| dd|d�S tj| dd|d�}||jk r�d |j| | }t dd� t |j
|�D ��}|j }|dkr�x<t |j
|�D ],\}}|dkr�|j d
|�j
|d�}|| }q�W |j |�S ) a
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 pre-pending 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
--------
>>> 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]])
c s s | ]}|d kV qdS )r# Nr5 )rC rz r5 r5 r6 rE � s ztile.<locals>.<genexpr>T)r] r^ r_ Fr# c s s | ]\}}|| V qd S )Nr5 )rC �s�tr5 r5 r6 rE � s r )r# r$ )r0 rm r) �allrH r% Zndarrayr r* r. r; �sizer �repeat) r� r� rY �d�cZ shape_outr4 Zdim_inZnrepr5 r5 r6 r � s$ C
)N)r )N)r )=� functoolsZnumpy.core.numeric�core�numericr% r r r r r r Znumpy.core.fromnumericr r Znumpy.core.multiarrayr
Z
numpy.corer r r
r Znumpy.core.shape_baser Znumpy.lib.index_tricksr Znumpy.matrixlib.defmatrixr �__all__�partialZarray_function_dispatchr7 r9 r r= r! rA r rQ r rT r r rZ r rc r rh rk r rs r ru r r r r~ r r� r r� r r5 r5 r5 r6 �<module> sd
uV W]/?
7
M@1,
d |