numpy.core.shape

module documentation

(source)

Undocumented

Function	`atleast_1d`	Convert inputs to arrays with at least one dimension.
Function	`atleast_2d`	View inputs as arrays with at least two dimensions.
Function	`atleast_3d`	View inputs as arrays with at least three dimensions.
Function	`block`	Assemble an nd-array from nested lists of blocks.
Function	`hstack`	Stack arrays in sequence horizontally (column wise).
Function	`stack`	Join a sequence of arrays along a new axis.
Function	`vstack`	Stack arrays in sequence vertically (row wise).
Variable	`array_function_dispatch`	Undocumented
Function	`_accumulate`	Undocumented
Function	`_arrays_for_stack_dispatcher`	Undocumented
Function	`_atleast_1d_dispatcher`	Undocumented
Function	`_atleast_2d_dispatcher`	Undocumented
Function	`_atleast_3d_dispatcher`	Undocumented
Function	`_atleast_nd`	Undocumented
Function	`_block`	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 ...
Function	`_block_check_depths_match`	Recursive function checking that the depths of nested lists in `arrays` all match. Mismatch raises a ValueError as described in the block docstring below.
Function	`_block_concatenate`	Undocumented
Function	`_block_dispatcher`	Undocumented
Function	`_block_format_index`	Convert a list of indices `[0, 1, 2]` into `"arrays[0][1][2]"`.
Function	`_block_info_recursion`	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
Function	`_block_setup`	Returns (`arrays`, list_ndim, result_ndim, final_size)
Function	`_block_slicing`	Undocumented
Function	`_concatenate_shapes`	Given array shapes, return the resulting shape and slices prefixes.
Function	`_stack_dispatcher`	Undocumented
Function	`_vhstack_dispatcher`	Undocumented
Variable	`_concatenate`	Undocumented
Variable	`_ndim`	Undocumented
Variable	`_size`	Undocumented

@array_function_dispatch(_atleast_1d_dispatcher)
def atleast_1d(*arys): (source) ¶

Convert inputs to arrays with at least one dimension.

Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.

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])]

Parameters
*arys	Undocumented
arys1:`array_like`	One or more input arrays.
arys2:`array_like`	One or more input arrays.
...:`array_like`	One or more input arrays.
Returns
`ndarray`	ret - An array, or list of arrays, each with `a.ndim >= 1`. Copies are made only if necessary.

@array_function_dispatch(_atleast_2d_dispatcher)
def atleast_2d(*arys): (source) ¶

View inputs as arrays with at least two dimensions.

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]])]

Parameters
*arys	Undocumented
arys1:`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.
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.
...:`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
`ndarray`	res, res2, ... - 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.

@array_function_dispatch(_atleast_3d_dispatcher)
def atleast_3d(*arys): (source) ¶

View inputs as arrays with at least three dimensions.

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)

Parameters
*arys	Undocumented
arys1:`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.
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.
...:`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
`ndarray`	res1, res2, ... - 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)`.

@array_function_dispatch(_block_dispatcher)
def block(arrays): (source) ¶

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.

New in version 1.13.0.

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]])

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
`ndarray`	block_array - 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], []]`

@array_function_dispatch(_vhstack_dispatcher)
def hstack(tup, *, dtype=None, casting='same_kind'): (source) ¶

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.

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]])

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`.
casting:{'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional	Controls what kind of data casting may occur. Defaults to 'same_kind'.
.. versionadded:	1.24:
Returns
`ndarray`	stacked - The array formed by stacking the given arrays.

@array_function_dispatch(_stack_dispatcher)
def stack(arrays, axis=0, out=None, *, dtype=None, casting='same_kind'): (source) ¶

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.

New in version 1.10.0.

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]])

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`. New in version 1.24.
casting:{'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional	Controls what kind of data casting may occur. Defaults to 'same_kind'. New in version 1.24.
Returns
`ndarray`	stacked - The stacked array has one more dimension than the input arrays.

@array_function_dispatch(_vhstack_dispatcher)
def vstack(tup, *, dtype=None, casting='same_kind'): (source) ¶

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.

np.row_stack is an alias for vstack. They are the same function.

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]])

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`.
casting:{'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional	Controls what kind of data casting may occur. Defaults to 'same_kind'.
.. versionadded:	1.24:
Returns
`ndarray`	stacked - The array formed by stacking the given arrays, will be at least 2-D.

array_function_dispatch = (source) ¶

Undocumented

def _accumulate(values): (source) ¶

Undocumented

def _arrays_for_stack_dispatcher(arrays, stacklevel=4): (source) ¶

Undocumented

def _atleast_1d_dispatcher(*arys): (source) ¶

Undocumented

def _atleast_2d_dispatcher(*arys): (source) ¶

Undocumented

def _atleast_3d_dispatcher(*arys): (source) ¶

Undocumented

def _atleast_nd(a, ndim): (source) ¶

Undocumented

def _block(arrays, max_depth, result_ndim, depth=0): (source) ¶

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).

def _block_check_depths_match(arrays, parent_index=[]): (source) ¶

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.

def _block_concatenate(arrays, list_ndim, result_ndim): (source) ¶

Undocumented

def _block_dispatcher(arrays): (source) ¶

Undocumented

def _block_format_index(index): (source) ¶

Convert a list of indices [0, 1, 2] into "arrays[0][1][2]".

def _block_info_recursion(arrays, max_depth, result_ndim, depth=0): (source) ¶

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.
depth	Undocumented
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

def _block_setup(arrays): (source) ¶

Returns (arrays, list_ndim, result_ndim, final_size)

def _block_slicing(arrays, list_ndim, result_ndim): (source) ¶

Undocumented

def _concatenate_shapes(shapes, axis): (source) ¶

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.

def _stack_dispatcher(arrays, axis=None, out=None, *, dtype=None, casting=None): (source) ¶

Undocumented

def _vhstack_dispatcher(tup, *, dtype=None, casting=None): (source) ¶

Undocumented

_concatenate = (source) ¶

Undocumented

_ndim = (source) ¶

Undocumented

_size = (source) ¶

Undocumented

numpy.core.shape_base

`numpy.core.shape_base`