U
|
O ±dÁz ã @ sÜ d ddddddgZ ddlZddlZddlZddlZd d
|
lmZ d d lmZ d d l m
|
Z
|
m Z m Z d d lm Z ejejddZdd Zeedd Zdd Zeedd Zdd Zeedd Zd=ddZddd d d Zeedd d d dZeedd d d!dZd>ddd d"d#Zeed?dd d d$dZ e ej d%ej Z e ej d%ej Z!e ej"d%ej"Z#d&d' Z$g fd(d)Z%d*d+ Z&d,d- Z'd.d/ Z(d@d0d1Z)dAd2d3Z*d4d5 Z+ee+d6d Z,d7d8 Z-d9d: Z.d;d< Z/dS )BÚ
|
atleast_1dÚ
|
atleast_2dÚ
|
atleast_3dÚblockÚhstackÚstackÚvstacké Né )Únumeric)Ú overrides)ÚarrayÚ
|
asanyarrayÚnormalize_axis_index)Ú fromnumericÚnumpy)Úmodulec G s | S ©N© ©Úarysr r úLd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/core/shape_base.pyÚ_atleast_1d_dispatcher s r c G sV g }| D ]0}t |}|jdkr*| d¡}n|}| |¡ qt|dkrN|d S |S dS )a
|
Convert inputs to arrays with at least one dimension.
|
|
Scalar inputs are converted to 1-dimensional arrays, whilst
|
higher-dimensional inputs are preserved.
|
|
Parameters
|
----------
|
arys1, arys2, ... : array_like
|
One or more input arrays.
|
|
Returns
|
-------
|
ret : ndarray
|
An array, or list of arrays, each with ``a.ndim >= 1``.
|
Copies are made only if necessary.
|
|
See Also
|
--------
|
atleast_2d, atleast_3d
|
|
Examples
|
--------
|
>>> np.atleast_1d(1.0)
|
array([1.])
|
|
>>> x = np.arange(9.0).reshape(3,3)
|
>>> np.atleast_1d(x)
|
array([[0., 1., 2.],
|
[3., 4., 5.],
|
[6., 7., 8.]])
|
>>> np.atleast_1d(x) is x
|
True
|
|
>>> np.atleast_1d(1, [3, 4])
|
[array([1]), array([3, 4])]
|
|
r r N)r ÚndimÚreshapeÚappendÚlen©r ÚresZaryÚresultr r r r s (
|
c G s | S r r r r r r Ú_atleast_2d_dispatcherM s r c G sv g }| D ]P}t |}|jdkr,| dd¡}n"|jdkrJ|tjdd
f }n|}| |¡ qt|dkrn|d S |S dS )a\
|
View inputs as arrays with at least two dimensions.
|
|
Parameters
|
----------
|
arys1, arys2, ... : array_like
|
One or more array-like sequences. Non-array inputs are converted
|
to arrays. Arrays that already have two or more dimensions are
|
preserved.
|
|
Returns
|
-------
|
res, res2, ... : ndarray
|
An array, or list of arrays, each with ``a.ndim >= 2``.
|
Copies are avoided where possible, and views with two or more
|
dimensions are returned.
|
|
See Also
|
--------
|
atleast_1d, atleast_3d
|
|
Examples
|
--------
|
>>> np.atleast_2d(3.0)
|
array([[3.]])
|
|
>>> x = np.arange(3.0)
|
>>> np.atleast_2d(x)
|
array([[0., 1., 2.]])
|
>>> np.atleast_2d(x).base is x
|
True
|
|
>>> np.atleast_2d(1, [1, 2], [[1, 2]])
|
[array([[1]]), array([[1, 2]]), array([[1, 2]])]
|
|
r r N©r r r Ú_nxÚnewaxisr r r r r r r Q s &
|
|
c G s | S r r r r r r Ú_atleast_3d_dispatcher s r# c G s g }| D ]z}t |}|jdkr.| ddd¡}nJ|jdkrP|tjdd
tjf }n(|jdkrt|dd
dd
tjf }n|}| |¡ qt|dkr|d S |S dS )a
|
View inputs as arrays with at least three dimensions.
|
|
Parameters
|
----------
|
arys1, arys2, ... : array_like
|
One or more array-like sequences. Non-array inputs are converted to
|
arrays. Arrays that already have three or more dimensions are
|
preserved.
|
|
Returns
|
-------
|
res1, res2, ... : ndarray
|
An array, or list of arrays, each with ``a.ndim >= 3``. Copies are
|
avoided where possible, and views with three or more dimensions are
|
returned. For example, a 1-D array of shape ``(N,)`` becomes a view
|
of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
|
view of shape ``(M, N, 1)``.
|
|
See Also
|
--------
|
atleast_1d, atleast_2d
|
|
Examples
|
--------
|
>>> np.atleast_3d(3.0)
|
array([[[3.]]])
|
|
>>> x = np.arange(3.0)
|
>>> np.atleast_3d(x).shape
|
(1, 3, 1)
|
|
>>> x = np.arange(12.0).reshape(4,3)
|
>>> np.atleast_3d(x).shape
|
(4, 3, 1)
|
>>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself
|
True
|
|
>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
|
... print(arr, arr.shape) # doctest: +SKIP
|
...
|
[[[1]
|
[2]]] (1, 2, 1)
|
[[[1]
|
[2]]] (1, 2, 1)
|
[[[1 2]]] (1, 1, 2)
|
|
r r Né r r r r r r s 2
|
|
|
é c C s, t | ds(t | dr(tjdt|d dS | S )NÚ __getitem__Ú__iter__zÆarrays to stack must be passed as a "sequence" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.©Ú
|
stacklevelr )ÚhasattrÚwarningsÚwarnÚ FutureWarning)Úarraysr) r r r Ú _arrays_for_stack_dispatcherÏ s ür/ ©ÚdtypeÚcastingc C s t | S r )r/ )Útupr1 r2 r r r Ú_vhstack_dispatcherÚ s r4 Z same_kindc C s< t jst| dd t| }t|ts*|g}tj|d||dS )a>
|
Stack arrays in sequence vertically (row wise).
|
|
This is equivalent to concatenation along the first axis after 1-D arrays
|
of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
|
`vsplit`.
|
|
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.
|
|
``np.row_stack`` is an alias for `vstack`. They are the same function.
|
|
Parameters
|
----------
|
tup : sequence of ndarrays
|
The arrays must have the same shape along all but the first axis.
|
1-D arrays must have the same length.
|
|
dtype : str or dtype
|
If provided, the destination array will have this dtype. Cannot be
|
provided together with `out`.
|
|
.. versionadded:: 1.24
|
|
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
|
Controls what kind of data casting may occur. Defaults to 'same_kind'.
|
|
.. versionadded:: 1.24
|
|
Returns
|
-------
|
stacked : ndarray
|
The array formed by stacking the given arrays, will be at least 2-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.
|
hstack : Stack arrays in sequence horizontally (column wise).
|
dstack : Stack arrays in sequence depth wise (along third axis).
|
column_stack : Stack 1-D arrays as columns into a 2-D array.
|
vsplit : Split an array into multiple sub-arrays vertically (row-wise).
|
|
Examples
|
--------
|
>>> a = np.array([1, 2, 3])
|
>>> b = np.array([4, 5, 6])
|
>>> np.vstack((a,b))
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
|
>>> a = np.array([[1], [2], [3]])
|
>>> b = np.array([[4], [5], [6]])
|
>>> np.vstack((a,b))
|
array([[1],
|
[2],
|
[3],
|
[4],
|
[5],
|
[6]])
|
|
r$ r( r r0 )r ÚARRAY_FUNCTION_ENABLEDr/ r Ú
|
isinstanceÚlistr! Ú concatenate©r3 r1 r2 Úarrsr r r r ß s C
|
c C sd t jst| dd t| }t|ts*|g}|rN|d jdkrNtj|d||dS tj|d||dS dS )a¬
|
Stack arrays in sequence horizontally (column wise).
|
|
This is equivalent to concatenation along the second axis, except for 1-D
|
arrays where it concatenates along the first axis. Rebuilds arrays divided
|
by `hsplit`.
|
|
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 ndarrays
|
The arrays must have the same shape along all but the second axis,
|
except 1-D arrays which can be any length.
|
|
dtype : str or dtype
|
If provided, the destination array will have this dtype. Cannot be
|
provided together with `out`.
|
|
.. versionadded:: 1.24
|
|
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
|
Controls what kind of data casting may occur. Defaults to 'same_kind'.
|
|
.. versionadded:: 1.24
|
|
Returns
|
-------
|
stacked : ndarray
|
The array formed by stacking the given arrays.
|
|
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).
|
dstack : Stack arrays in sequence depth wise (along third axis).
|
column_stack : Stack 1-D arrays as columns into a 2-D array.
|
hsplit : Split an array into multiple sub-arrays horizontally (column-wise).
|
|
Examples
|
--------
|
>>> a = np.array((1,2,3))
|
>>> b = np.array((4,5,6))
|
>>> np.hstack((a,b))
|
array([1, 2, 3, 4, 5, 6])
|
>>> a = np.array([[1],[2],[3]])
|
>>> b = np.array([[4],[5],[6]])
|
>>> np.hstack((a,b))
|
array([[1, 4],
|
[2, 5],
|
[3, 6]])
|
|
r$ r( r r r0 N) r r5 r/ r r6 r7 r r! r8 r9 r r r r + s <
|
c C s* t | dd} |d k r&t| } | |¡ | S )Né r( )r/ r7 r )r. ÚaxisÚoutr1 r2 r r r Ú_stack_dispatcheru s
|
|
r> c s¢ t jst| dd dd | D } | s,tddd | D }t|dkrNtd | d
|
jd }t||}td f| tj f fd d| D }tj
|
|||||d S )aw
|
Join a sequence of arrays along a new axis.
|
|
The ``axis`` parameter specifies the index of the new axis in the
|
dimensions of the result. For example, if ``axis=0`` it will be the first
|
dimension and if ``axis=-1`` it will be the last dimension.
|
|
.. versionadded:: 1.10.0
|
|
Parameters
|
----------
|
arrays : sequence of array_like
|
Each array must have the same shape.
|
|
axis : int, optional
|
The axis in the result array along which the input arrays are stacked.
|
|
out : ndarray, optional
|
If provided, the destination to place the result. The shape must be
|
correct, matching that of what stack would have returned if no
|
out argument were specified.
|
|
dtype : str or dtype
|
If provided, the destination array will have this dtype. Cannot be
|
provided together with `out`.
|
|
.. versionadded:: 1.24
|
|
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
|
Controls what kind of data casting may occur. Defaults to 'same_kind'.
|
|
.. versionadded:: 1.24
|
|
|
Returns
|
-------
|
stacked : ndarray
|
The stacked array has one more dimension than the input arrays.
|
|
See Also
|
--------
|
concatenate : Join a sequence of arrays along an existing axis.
|
block : Assemble an nd-array from nested lists of blocks.
|
split : Split array into a list of multiple sub-arrays of equal size.
|
|
Examples
|
--------
|
>>> arrays = [np.random.randn(3, 4) for _ in range(10)]
|
>>> np.stack(arrays, axis=0).shape
|
(10, 3, 4)
|
|
>>> np.stack(arrays, axis=1).shape
|
(3, 10, 4)
|
|
>>> np.stack(arrays, axis=2).shape
|
(3, 4, 10)
|
|
>>> a = np.array([1, 2, 3])
|
>>> b = np.array([4, 5, 6])
|
>>> np.stack((a, b))
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
|
>>> np.stack((a, b), axis=-1)
|
array([[1, 4],
|
[2, 5],
|
[3, 6]])
|
|
r$ r( c S s g | ] }t |qS r )r ©Ú.0Úarrr r r Ú
|
<listcomp>Ê s zstack.<locals>.<listcomp>z need at least one array to stackc S s h | ]
|
}|j qS r )Úshaper? r r r Ú <setcomp>Î s zstack.<locals>.<setcomp>r z)all input arrays must have the same shaper Nc s g | ] }| qS r r r? ©Úslr r rB Ö s )r< r= r1 r2 ) r r5 r/ Ú
|
ValueErrorr r r Úslicer! r" r8 )r. r< r= r1 r2 ÚshapesÚ result_ndimZexpanded_arraysr rE r r s G
|
|
ÿÚ __wrapped__c C s d dd | D ¡}d| S )zM
|
Convert a list of indices ``[0, 1, 2]`` into ``"arrays[0][1][2]"``.
|
Ú c s s | ]}|d k rd |¡V qd S )Nz[{}])Úformat)r@ Úir r r Ú <genexpr>è s z&_block_format_index.<locals>.<genexpr>r. )Újoin)ÚindexZidx_strr r r Ú_block_format_indexä s rR c s
|
t | tkr td t ¡næt | tkrÈt| dkrÈ fddt| D }t|\}}}|D ]\\}}}||7 }||kr~|}t|t|kr¬t d t|t|t|¡|d dkr`|}q`|||fS t | tkrðt| dkrð dg ddfS t
|
| } t | |fS dS )a
|
Recursive function checking that the depths of nested lists in `arrays`
|
all match. Mismatch raises a ValueError as described in the block
|
docstring below.
|
|
The entire index (rather than just the depth) needs to be calculated
|
for each innermost list, in case an error needs to be raised, so that
|
the index of the offending list can be printed as part of the error.
|
|
Parameters
|
----------
|
arrays : nested list of arrays
|
The arrays to check
|
parent_index : list of int
|
The full index of `arrays` within the nested lists passed to
|
`_block_check_depths_match` at the top of the recursion.
|
|
Returns
|
-------
|
first_index : list of int
|
The full index of an element from the bottom of the nesting in
|
`arrays`. If any element at the bottom is an empty list, this will
|
refer to it, and the last index along the empty axis will be None.
|
max_arr_ndim : int
|
The maximum of the ndims of the arrays nested in `arrays`.
|
final_size: int
|
The number of elements in the final array. This is used the motivate
|
the choice of algorithm used using benchmarking wisdom.
|
|
z{} is a tuple. Only lists can be used to arrange blocks, and np.block does not allow implicit conversion from tuple to ndarray.r c 3 s" | ]\}}t | |g V qd S r )Ú_block_check_depths_match)r@ rN rA ©Ú parent_indexr r rO s ÿz,_block_check_depths_match.<locals>.<genexpr>zcList depths are mismatched. First element was at depth {}, but there is an element at depth {} ({})éÿÿÿÿN) ÚtypeÚtupleÚ TypeErrorrM rR r7 r Ú enumerateÚnextrG Ú_sizeÚ_ndim) r. rU Z
|
idxs_ndimsZ first_indexZ max_arr_ndimÚ
|
final_sizerQ r Úsizer rT r rS ì s< ýÿ
|
ÿüÿ
|
rS c C s t | |dddS )NFT)ZndminÚcopyZsubok)r )Úar r r r Ú _atleast_nd8 s rb c C s t t | ¡S r )r7 Ú itertoolsÚ
|
accumulate)Úvaluesr r r Ú _accumulate> s rf c s¦ fdd| D }| d }|d
| d d
t fdd| D r^td ¡t|f | d d
}t|}d d tdg| |D }||fS )
|
aë Given array shapes, return the resulting shape and slices prefixes.
|
|
These help in nested concatenation.
|
|
Returns
|
-------
|
shape: tuple of int
|
This tuple satisfies::
|
|
shape, _ = _concatenate_shapes([arr.shape for shape in arrs], axis)
|
shape == concatenate(arrs, axis).shape
|
|
slice_prefixes: tuple of (slice(start, end), )
|
For a list of arrays being concatenated, this returns the slice
|
in the larger array at axis that needs to be sliced into.
|
|
For example, the following holds::
|
|
ret = concatenate([a, b, c], axis)
|
_, (sl_a, sl_b, sl_c) = concatenate_slices([a, b, c], axis)
|
|
ret[(slice(None),) * axis + sl_a] == a
|
ret[(slice(None),) * axis + sl_b] == b
|
ret[(slice(None),) * axis + sl_c] == c
|
|
These are called slice prefixes since they are used in the recursive
|
blocking algorithm to compute the left-most slices during the
|
recursion. Therefore, they must be prepended to rest of the slice
|
that was computed deeper in the recursion.
|
|
These are returned as tuples to ensure that they can quickly be added
|
to existing slice tuple without creating a new tuple every time.
|
|
c s g | ] }| qS r r ©r@ rC ©r< r r rB f s z'_concatenate_shapes.<locals>.<listcomp>r Nr c 3 s2 | ]*}|d
kp(| d d
kV qd S )Nr r rg ©r< Zfirst_shape_postZfirst_shape_prer r rO m s ÿz&_concatenate_shapes.<locals>.<genexpr>z/Mismatched array shapes in block along axis {}.c S s g | ]\}}t ||fqS r )rH )r@ ÚstartÚendr r r rB u s ÿ)ÚanyrG rM Úsumrf Úzip)rI r< Z shape_at_axisZ first_shaperC Zoffsets_at_axisÚslice_prefixesr ri r Ú_concatenate_shapesB s$ $ ÿÿ
|
ÿÿrp c
|
s k rnt fdd| D \}}} }t||\}}dd t ||D }t tj| ¡} ||| fS t| } | jdg| gfS dS )a
|
Returns the shape of the final array, along with a list
|
of slices and a list of arrays that can be used for assignment inside the
|
new array
|
|
Parameters
|
----------
|
arrays : nested list of arrays
|
The arrays to check
|
max_depth : list of int
|
The number of nested lists
|
result_ndim : int
|
The number of dimensions in thefinal array.
|
|
Returns
|
-------
|
shape : tuple of int
|
The shape that the final array will take on.
|
slices: list of tuple of slices
|
The slices into the full array required for assignment. These are
|
required to be prepended with ``(Ellipsis, )`` to obtain to correct
|
final index.
|
arrays: list of ndarray
|
The data to assign to each slice of the full array
|
|
c s g | ]}t | d qS ©r )Ú_block_info_recursionr? ©ÚdepthÚ max_depthrJ r r rB s ÿz)_block_info_recursion.<locals>.<listcomp>c S s" g | ]\}}|D ] }|| qqS r r )r@ Z slice_prefixZ inner_slicesÚ the_slicer r r rB s þr N)rn rp Ú functoolsÚreduceÚoperatorÚaddrb rC )
|
r. ru rJ rt rI Úslicesr< rC ro rA r rs r rr { s ÿÿ
|
ÿ
|
|
rr c s> k r0 fdd| D }t | dS t| S dS )aZ
|
Internal implementation of block based on repeated concatenation.
|
`arrays` is the argument passed to
|
block. `max_depth` is the depth of nested lists within `arrays` and
|
`result_ndim` is the greatest of the dimensions of the arrays in
|
`arrays` and the depth of the lists in `arrays` (see block docstring
|
for details).
|
c s g | ]}t | d qS rq )Ú_blockr? rs r r rB º s ÿz_block.<locals>.<listcomp>rh N)Ú _concatenaterb )r. ru rJ rt r: r rs r r| ° s ÿr| c c s0 t | tkr&| D ]}t|E d H qn| V d S r )rW r7 Ú_block_dispatcher)r. Z subarraysr r r r~ Ã s r~ c C s8 t | \} }}}|| dkr(t| ||S t| ||S dS )ap
|
Assemble an nd-array from nested lists of blocks.
|
|
Blocks in the innermost lists are concatenated (see `concatenate`) along
|
the last dimension (-1), then these are concatenated along the
|
second-last dimension (-2), and so on until the outermost list is reached.
|
|
Blocks can be of any dimension, but will not be broadcasted using the normal
|
rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim``
|
the same for all blocks. This is primarily useful for working with scalars,
|
and means that code like ``np.block([v, 1])`` is valid, where
|
``v.ndim == 1``.
|
|
When the nested list is two levels deep, this allows block matrices to be
|
constructed from their components.
|
|
.. versionadded:: 1.13.0
|
|
Parameters
|
----------
|
arrays : nested list of array_like or scalars (but not tuples)
|
If passed a single ndarray or scalar (a nested list of depth 0), this
|
is returned unmodified (and not copied).
|
|
Elements shapes must match along the appropriate axes (without
|
broadcasting), but leading 1s will be prepended to the shape as
|
necessary to make the dimensions match.
|
|
Returns
|
-------
|
block_array : ndarray
|
The array assembled from the given blocks.
|
|
The dimensionality of the output is equal to the greatest of:
|
* the dimensionality of all the inputs
|
* the depth to which the input list is nested
|
|
Raises
|
------
|
ValueError
|
* If list depths are mismatched - for instance, ``[[a, b], c]`` is
|
illegal, and should be spelt ``[[a, b], [c]]``
|
* If lists are empty - for instance, ``[[a, b], []]``
|
|
See Also
|
--------
|
concatenate : Join a sequence of arrays along an existing axis.
|
stack : Join a sequence of arrays along a new axis.
|
vstack : Stack arrays in sequence vertically (row wise).
|
hstack : Stack arrays in sequence horizontally (column wise).
|
dstack : Stack arrays in sequence depth wise (along third axis).
|
column_stack : Stack 1-D arrays as columns into a 2-D array.
|
vsplit : Split an array into multiple sub-arrays vertically (row-wise).
|
|
Notes
|
-----
|
|
When called with only scalars, ``np.block`` is equivalent to an ndarray
|
call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to
|
``np.array([[1, 2], [3, 4]])``.
|
|
This function does not enforce that the blocks lie on a fixed grid.
|
``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form::
|
|
AAAbb
|
AAAbb
|
cccDD
|
|
But is also allowed to produce, for some ``a, b, c, d``::
|
|
AAAbb
|
AAAbb
|
cDDDD
|
|
Since concatenation happens along the last axis first, `block` is _not_
|
capable of producing the following directly::
|
|
AAAbb
|
cccbb
|
cccDD
|
|
Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is
|
equivalent to ``np.block([[A, B, ...], [p, q, ...]])``.
|
|
Examples
|
--------
|
The most common use of this function is to build a block matrix
|
|
>>> A = np.eye(2) * 2
|
>>> B = np.eye(3) * 3
|
>>> np.block([
|
... [A, np.zeros((2, 3))],
|
... [np.ones((3, 2)), B ]
|
... ])
|
array([[2., 0., 0., 0., 0.],
|
[0., 2., 0., 0., 0.],
|
[1., 1., 3., 0., 0.],
|
[1., 1., 0., 3., 0.],
|
[1., 1., 0., 0., 3.]])
|
|
With a list of depth 1, `block` can be used as `hstack`
|
|
>>> np.block([1, 2, 3]) # hstack([1, 2, 3])
|
array([1, 2, 3])
|
|
>>> a = np.array([1, 2, 3])
|
>>> b = np.array([4, 5, 6])
|
>>> np.block([a, b, 10]) # hstack([a, b, 10])
|
array([ 1, 2, 3, 4, 5, 6, 10])
|
|
>>> A = np.ones((2, 2), int)
|
>>> B = 2 * A
|
>>> np.block([A, B]) # hstack([A, B])
|
array([[1, 1, 2, 2],
|
[1, 1, 2, 2]])
|
|
With a list of depth 2, `block` can be used in place of `vstack`:
|
|
>>> a = np.array([1, 2, 3])
|
>>> b = np.array([4, 5, 6])
|
>>> np.block([[a], [b]]) # vstack([a, b])
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
|
>>> A = np.ones((2, 2), int)
|
>>> B = 2 * A
|
>>> np.block([[A], [B]]) # vstack([A, B])
|
array([[1, 1],
|
[1, 1],
|
[2, 2],
|
[2, 2]])
|
|
It can also be used in places of `atleast_1d` and `atleast_2d`
|
|
>>> a = np.array(0)
|
>>> b = np.array([1])
|
>>> np.block([a]) # atleast_1d(a)
|
array([0])
|
>>> np.block([b]) # atleast_1d(b)
|
array([1])
|
|
>>> np.block([[a]]) # atleast_2d(a)
|
array([[0]])
|
>>> np.block([[b]]) # atleast_2d(b)
|
array([[1]])
|
|
|
i N)Ú _block_setupÚ_block_slicingÚ_block_concatenate)r. Ú list_ndimrJ r^ r r r r Î s
|
c C sN t | \}}}t|}|r8|d dkr8td t|¡t||}| |||fS )zD
|
Returns
|
(`arrays`, list_ndim, result_ndim, final_size)
|
rV NzList at {} cannot be empty)rS r rG rM rR Úmax)r. Z bottom_indexZarr_ndimr^ r rJ r r r r ~ s ÿÿ
|
r c C s t | ||\}}} tjdd | D }tdd | D }tdd | D }|rV|sVdnd}tj|||d} t|| D ]\}
|
} | | tf|
|
< qt| S ) Nc S s g | ]
|
}|j qS r )r1 r? r r r rB s z"_block_slicing.<locals>.<listcomp>c s s | ]}|j d V qdS )Z F_CONTIGUOUSN©Úflagsr? r r r rO s z!_block_slicing.<locals>.<genexpr>c s s | ]}|j d V qdS )Z C_CONTIGUOUSNr r? r r r rO s ÚFÚC)rC r1 Úorder)rr r! Z result_typeÚallÚemptyrn ÚEllipsis) r. r rJ rC r{ r1 ZF_orderZC_orderr r rv rA r r r r s ÿ
|
r c C s t | ||}|dkr | ¡ }|S )Nr )r| r` )r. r rJ r r r r r ¢ s r )r% )NN)r N)r )r )0Ú__all__rw rc ry r+ rL r
|
r! r Z
|
multiarrayr r r r Z_from_nxÚpartialZarray_function_dispatchr r r r r# r r/ r4 r r r> r Úgetattrr_ r\ r r] r8 r} rR rS rb rf rp rr r| r~ r r r r r r r r Ú<module> st
|
ÿ ÿ
|
5
|
5
|
C
|
ÿ KI ÿ
|
^ ÿ L9
|
5
|
|
0
|
