sisl_toolbox.btd.BlockArray

class sisl_toolbox.btd.BlockArray

Bases: ndarray

N-dimensional array split into blocks where undefined blocks are (structurally) zero

Each axis is split into blocks of the sizes in blocks, e.g. a block-tridiagonal matrix is a 2D array with the same blocks along both axes, BlockArray([blocks, blocks]).

The array is a numpy.ndarray subclass whose elements are the blocks. The underlying array is a grid of objects (one dimension per axis), each either a dense numpy.ndarray (a defined block) or None (an undefined, zero, block). shape, dtype and len refer to the (dense) array, i.e. shape == tuple(b.sum() for b in blocks).

Blocks are accessed and assigned through block_indexer with block indices, the array can be extended with new blocks at any time. All blocks have the data-type dtype and memory order order.

Indexing the array (ba[i, j, ...]) uses array indices and follows the numpy semantics, returning dense arrays. If the index along each axis is a sequence of complete blocks a BlockArray of these blocks is returned instead (the blocks are shared when indexing with slices, otherwise copied). Assigning elements allocates the blocks that are needed (unless the assigned values are zero).

Element-wise ufuncs (-ba, ba * 2, ba + ba, np.conj(ba), …) and matrix multiplications (ba @ ba, and ba @ x, x @ ba for 2D arrays) only operate on the defined blocks, when the undefined blocks remain zero. The undefined blocks are exact zeros, so np.multiply only stores the blocks defined in all arguments (like scipy.sparse). Any other operation returns the result of the dense array (toarray), e.g. ba + 1.

Parameters:

blocks – the size of the blocks along each axis (one 1D array per axis)
dtype – data-type of the array, all blocks are converted to this data-type
order ({"C", "F"}) – memory order of the blocks

Notes

numpy.asarray returns the grid of blocks, use toarray for the dense array.

Examples

>>> ba = BlockArray([[2, 3], [2, 3]], dtype=np.float64)
>>> ba.block_indexer[1, 1] = np.ones([3, 3])
>>> ba.shape
(5, 5)
>>> full = np.zeros(ba.shape, dtype=ba.dtype)
>>> full[ba.indices()] = ba[ba.indices()]
>>> np.allclose(full, ba.toarray())
True

Methods

`all`(args, *kwargs)	Equivalent to `self.toarray().all(...)`
`any`(args, *kwargs)	Equivalent to `self.toarray().any(...)`
`argmax`(args, *kwargs)	Equivalent to `self.toarray().argmax(...)`
`argmin`(args, *kwargs)	Equivalent to `self.toarray().argmin(...)`
`argpartition`(args, *kwargs)	Equivalent to `self.toarray().argpartition(...)`
`argsort`(args, *kwargs)	Equivalent to `self.toarray().argsort(...)`
`asformat`(format)	Convert to a particular format
`astype`(dtype[, order, casting, copy])	Block array with blocks converted to `dtype` (and `order`)
`byteswap`([inplace])	Swap the bytes of the array elements
`choose`(args, *kwargs)	Equivalent to `self.toarray().choose(...)`
`clip`(args, *kwargs)	Equivalent to `self.toarray().clip(...)`
`compress`(args, *kwargs)	Equivalent to `self.toarray().compress(...)`
`conj`()	Complex-conjugate all elements.
`conjugate`()	Return the complex conjugate, element-wise.
`copy`()	Create a copy of this block array (all blocks are copied)
`cumprod`(args, *kwargs)	Equivalent to `self.toarray().cumprod(...)`
`cumsum`(args, *kwargs)	Equivalent to `self.toarray().cumsum(...)`
`diagonal`([offset, axis1, axis2])	Diagonal of the array along axis1 and axis2, see `numpy.diagonal`
`dot`(other, /[, out])	Refer to `numpy.dot` for full documentation.
`dump`(file)	Dump a pickle of the array to the specified file.
`dumps`()	Returns the pickle of the array as a string.
`fill`(value)	Fill the array with a scalar value.
`flatten`(args, *kwargs)	Equivalent to `self.toarray().flatten(...)`
`getfield`(dtype[, offset])	Returns a field of the given array as a certain type.
`indices`([defined])	Array indices (one array per axis) of the defined (or undefined) blocks
`item`(args, *kwargs)	Equivalent to `self.toarray().item(...)`
`itemset`(args, *kwargs)
`max`(args, *kwargs)	Equivalent to `self.toarray().max(...)`
`mean`(args, *kwargs)	Equivalent to `self.toarray().mean(...)`
`min`(args, *kwargs)	Equivalent to `self.toarray().min(...)`
`nonzero`(args, *kwargs)	Equivalent to `self.toarray().nonzero(...)`
`partition`(kth[, axis, kind, order])	Partially sorts the elements in the array in such a way that the value of the element in k-th position is in the position it would be in a sorted array.
`prod`(args, *kwargs)	Equivalent to `self.toarray().prod(...)`
`ptp`(args, *kwargs)	Equivalent to `self.toarray().ptp(...)`
`put`(indices, values[, mode])	Set `a.flat[n] = values[n]` for all `n` in indices.
`ravel`(args, *kwargs)	Equivalent to `self.toarray().ravel(...)`
`repeat`(args, *kwargs)	Equivalent to `self.toarray().repeat(...)`
`reshape`(args, *kwargs)	Equivalent to `self.toarray().reshape(...)`
`resize`()	Change shape and size of array in-place.
`round`(args, *kwargs)	Equivalent to `self.toarray().round(...)`
`searchsorted`(args, *kwargs)	Equivalent to `self.toarray().searchsorted(...)`
`setfield`(val, dtype[, offset])	Put a value into a specified place in a field defined by a data-type.
`setflags`([write, align, uic])	Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY, respectively.
`sort`([axis, kind, order, stable, descending])	Sort an array in-place.
`squeeze`(args, *kwargs)	Equivalent to `self.toarray().squeeze(...)`
`std`(args, *kwargs)	Equivalent to `self.toarray().std(...)`
`sum`(args, *kwargs)	Equivalent to `self.toarray().sum(...)`
`swapaxes`(args, *kwargs)	Equivalent to `self.toarray().swapaxes(...)`
`take`(args, *kwargs)	Equivalent to `self.toarray().take(...)`
`to_device`(device, /, *[, stream])	For Array API compatibility.
`toarray`()	Convert to a dense array, where non-defined blocks will be zero
`tobd`([axes])	Return only the block diagonal part of the array (blocks are shared)
`tobtd`([axes])	Return only the block tridiagonal part of the array (blocks are shared)
`tobytes`(args, *kwargs)	Equivalent to `self.toarray().tobytes(...)`
`tofile`(args, *kwargs)	Equivalent to `self.toarray().tofile(...)`
`tolist`(args, *kwargs)	Equivalent to `self.toarray().tolist(...)`
`trace`([offset, axis1, axis2, dtype, out])	Sum along the diagonal of the array, see `numpy.trace`
`transpose`(*axes)	Array with permuted axes, the blocks are views of the transposed blocks
`var`(args, *kwargs)	Equivalent to `self.toarray().var(...)`
`view`([dtype][, type])	New view of array with the same data.

Attributes

`T`	Array with reversed axes, see `transpose`
`base`	Base object if memory is from some other object.
`block_indexer`	Get the indexer for this block array
`blocks`	Size of the blocks along each axis
`ctypes`	An object to simplify the interaction of the array with the ctypes module.
`data`	Python buffer object pointing to the start of the array's data.
`device`
`dtype`	Data-type of the array
`flags`	Information about the memory layout of the array.
`flat`	A 1-D iterator over the array.
`imag`	Imaginary part of the array, the blocks are views
`itemsize`	Length of one array element in bytes.
`mT`	View of the matrix transposed array.
`nbytes`	Number of bytes of the defined blocks
`ndim`	Number of array dimensions.
`order`	Memory order of the blocks
`real`	Real part of the array, the blocks are views
`shape`	Shape of the (dense) array
`size`	Number of elements in the (dense) array
`strides`	Tuple of bytes to step in each dimension when traversing an array.

all(*args, **kwargs): Equivalent to self.toarray().all(...)

any(*args, **kwargs): Equivalent to self.toarray().any(...)

argmax(*args, **kwargs): Equivalent to self.toarray().argmax(...)

argmin(*args, **kwargs): Equivalent to self.toarray().argmin(...)

argpartition(*args, **kwargs): Equivalent to self.toarray().argpartition(...)

argsort(*args, **kwargs): Equivalent to self.toarray().argsort(...)

asformat(format)[source]: Convert to a particular format

astype(dtype, order=None, casting='unsafe', copy=True)[source]

Block array with blocks converted to dtype (and order)

Parameters:: copy (bool)
Return type:: BlockArray

byteswap(inplace=False)

Swap the bytes of the array elements

Toggle between low-endian and big-endian data representation by returning a byteswapped array, optionally swapped in-place. Arrays of byte-strings are not swapped. The real and imaginary parts of a complex number are swapped individually.

Parameters:: inplace (bool, optional) – If True, swap bytes in-place, default is False.
Returns:: out – The byteswapped array. If inplace is True, this is a view to self.
Return type:: ndarray

Examples

>>> import numpy as np
>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> list(map(hex, A))
['0x1', '0x100', '0x2233']
>>> A.byteswap(inplace=True)
array([  256,     1, 13090], dtype=int16)
>>> list(map(hex, A))
['0x100', '0x1', '0x3322']

Arrays of byte-strings are not swapped

>>> A = np.array([b'ceg', b'fac'])
>>> A.byteswap()
array([b'ceg', b'fac'], dtype='|S3')

A.view(A.dtype.newbyteorder()).byteswap() produces an array with the same values but different representation in memory

>>> A = np.array([1, 2, 3],dtype=np.int64)
>>> A.view(np.uint8)
array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
       0, 0], dtype=uint8)
>>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
array([1, 2, 3], dtype='>i8')
>>> A.view(np.uint8)
array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
       0, 3], dtype=uint8)

choose(*args, **kwargs): Equivalent to self.toarray().choose(...)

clip(*args, **kwargs): Equivalent to self.toarray().clip(...)

compress(*args, **kwargs): Equivalent to self.toarray().compress(...)

conj()[source]

Complex-conjugate all elements.

Refer to numpy.conjugate for full documentation.

See also

numpy.conjugate: equivalent function

Return type:: BlockArray

conjugate()

Return the complex conjugate, element-wise.

Refer to numpy.conjugate for full documentation.

See also

numpy.conjugate: equivalent function

Return type:: BlockArray

copy()[source]

Create a copy of this block array (all blocks are copied)

Return type:: BlockArray

cumprod(*args, **kwargs): Equivalent to self.toarray().cumprod(...)

cumsum(*args, **kwargs): Equivalent to self.toarray().cumsum(...)

diagonal(offset=0, axis1=0, axis2=1)[source]

Diagonal of the array along axis1 and axis2, see numpy.diagonal

The two axes are removed and the diagonal is the last axis. If offset is 0 and the two axes have the same blocks, the diagonal is a BlockArray (copies of the block diagonals), otherwise a dense array.

Parameters:

offset (int)
axis1 (int)
axis2 (int)

Return type:

BlockArray | TypeAliasForwardRef(’~numpy.ndarray’)

dot(other, /, out=None)[source]

Refer to numpy.dot for full documentation.

See also

numpy.dot: equivalent function

dump(file)

Dump a pickle of the array to the specified file. The array can be read back with pickle.load or numpy.load.

Parameters:: file (str or Path) – A string naming the dump file.

dumps()

Returns the pickle of the array as a string. pickle.loads will convert the string back to an array.

Parameters:: None

fill(value)

Fill the array with a scalar value.

Parameters:: value (scalar) – All elements of a will be assigned this value.

Examples

>>> import numpy as np
>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([1.,  1.])

Fill expects a scalar value and always behaves the same as assigning to a single array element. The following is a rare example where this distinction is important:

>>> a = np.array([None, None], dtype=np.object_)
>>> a[0] = np.array(3)
>>> a
array([array(3), None], dtype=object)
>>> a.fill(np.array(3))
>>> a
array([array(3), array(3)], dtype=object)

Where other forms of assignments will unpack the array being assigned:

>>> a[...] = np.array(3)
>>> a
array([3, 3], dtype=object)

flatten(*args, **kwargs): Equivalent to self.toarray().flatten(...)

getfield(dtype, offset=0)

Returns a field of the given array as a certain type.

A field is a view of the array data with a given data-type. The values in the view are determined by the given type and the offset into the current array in bytes. The offset needs to be such that the view dtype fits in the array dtype; for example an array of dtype complex128 has 16-byte elements. If taking a view with a 32-bit integer (4 bytes), the offset needs to be between 0 and 12 bytes.

Parameters:

dtype (str or dtype) – The data type of the view. The dtype size of the view can not be larger than that of the array itself.
offset (int) – Number of bytes to skip before beginning the element view.

Examples

>>> import numpy as np
>>> x = np.diag([1.+1.j]*2)
>>> x[1, 1] = 2 + 4.j
>>> x
array([[1.+1.j,  0.+0.j],
       [0.+0.j,  2.+4.j]])
>>> x.getfield(np.float64)
array([[1.,  0.],
       [0.,  2.]])

By choosing an offset of 8 bytes we can select the complex part of the array for our view:

>>> x.getfield(np.float64, offset=8)
array([[1.,  0.],
       [0.,  4.]])

indices(defined=True)[source]

Array indices (one array per axis) of the defined (or undefined) blocks

The indices are ordered by blocks (row-major over the blocks), and within each block in the memory order of the blocks.

Parameters:: defined (bool) – whether to return the indices of the defined blocks, or of the undefined (zero) blocks
Return type:: tuple[TypeAliasForwardRef(’~numpy.ndarray’), …]

Examples

>>> full = np.zeros(ba.shape, dtype=ba.dtype)
>>> full[ba.indices()] = ba[ba.indices()]
>>> np.allclose(full[ba.indices(defined=False)], 0)
True

item(*args, **kwargs): Equivalent to self.toarray().item(...)

itemset(*args, **kwargs)

max(*args, **kwargs): Equivalent to self.toarray().max(...)

mean(*args, **kwargs): Equivalent to self.toarray().mean(...)

min(*args, **kwargs): Equivalent to self.toarray().min(...)

nonzero(*args, **kwargs): Equivalent to self.toarray().nonzero(...)

partition(kth, axis=-1, kind='introselect', order=None)

Partially sorts the elements in the array in such a way that the value of the element in k-th position is in the position it would be in a sorted array. In the output array, all elements smaller than the k-th element are located to the left of this element and all equal or greater are located to its right. The ordering of the elements in the two partitions on the either side of the k-th element in the output array is undefined.

Parameters:

kth (int or sequence of ints) –
Element index to partition by. The kth element value will be in its final sorted position and all smaller elements will be moved before it and all equal or greater elements behind it. The order of all elements in the partitions is undefined. If provided with a sequence of kth it will partition all elements indexed by kth of them into their sorted position at once.

Deprecated since version 1.22.0: Passing booleans as index is deprecated.
axis (int, optional) – Axis along which to sort. Default is -1, which means sort along the last axis.
kind ({'introselect'}, optional) – Selection algorithm. Default is ‘introselect’.
order (str or list of str, optional) – When a is an array with fields defined, this argument specifies which fields to compare first, second, etc. A single field can be specified as a string, and not all fields need to be specified, but unspecified fields will still be used, in the order in which they come up in the dtype, to break ties.

See also

numpy.partition: Return a partitioned copy of an array.
argpartition: Indirect partition.
sort: Full sort.

Notes

See np.partition for notes on the different algorithms.

Examples

>>> import numpy as np
>>> a = np.array([3, 4, 2, 1])
>>> a.partition(3)
>>> a
array([2, 1, 3, 4]) # may vary

>>> a.partition((1, 3))
>>> a
array([1, 2, 3, 4])

prod(*args, **kwargs): Equivalent to self.toarray().prod(...)

ptp(*args, **kwargs): Equivalent to self.toarray().ptp(...)

put(indices, values, mode='raise')

Set a.flat[n] = values[n] for all n in indices.

Refer to numpy.put for full documentation.

See also

numpy.put: equivalent function

ravel(*args, **kwargs): Equivalent to self.toarray().ravel(...)

repeat(*args, **kwargs): Equivalent to self.toarray().repeat(...)

reshape(*args, **kwargs): Equivalent to self.toarray().reshape(...)

resize(new_shape, /, *, refcheck=True)

resize(*new_shape, refcheck=True)

Change shape and size of array in-place.

Parameters:

new_shape (tuple of ints, or n ints) – Shape of resized array.
refcheck (bool, optional) – If False, reference count will not be checked. Default is True. See Notes below for more explanation.

Return type:

None

Raises:

ValueError – If a does not own its own data or references or views to may exist.

See also

resize: Return a new array with the specified shape.

Notes

This reallocates space for the data area if necessary.

Only contiguous arrays (data elements consecutive in memory) can be resized.

Reallocating arrays in-place can often lead to memory fragmentation and should be avoided. If the goal is to reclaim over-allocated memory, alternatives are to create a view or a copy of just the desired data, or using two passes to build the array: one to cheaply determine the shape and another to allocate and fill. Benchmark your use case to determine what is optimum. You may be surprised to find resize actually slows down or bloats your application.

The purpose of the reference count check is to make sure you do not use this array as a buffer for another Python object and then reallocate the memory.

On Python 3.13 and older, the check allows objects with exactly one reference to be reallocated in-place. On Python 3.14 and newer, the array must be uniquely referenced. See [1] for more details.

If you are sure that you have not shared the memory for this array with another Python object, then you may safely set refcheck to False.

References

Examples

Shrinking an array: array is flattened (in the order that the data are stored in memory), resized, and reshaped:

>>> import numpy as np

>>> a = np.array([[0, 1], [2, 3]], order='C')
>>> a.resize((2, 1))
>>> a
array([[0],
       [1]])

>>> a = np.array([[0, 1], [2, 3]], order='F')
>>> a.resize((2, 1))
>>> a
array([[0],
       [2]])

Enlarging an array: as above, but missing entries are filled with zeros:

>>> b = np.array([[0, 1], [2, 3]])
>>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
>>> b
array([[0, 1, 2],
       [3, 0, 0]])

Referencing an array prevents resizing…

>>> c = a
>>> a.resize((1, 1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that references or is referenced ...

Unless refcheck is False:

>>> a.resize((1, 1), refcheck=False)
>>> a
array([[0]])
>>> c
array([[0]])

round(*args, **kwargs): Equivalent to self.toarray().round(...)

searchsorted(*args, **kwargs): Equivalent to self.toarray().searchsorted(...)

setfield(val, dtype, offset=0)

Put a value into a specified place in a field defined by a data-type.

Place val into a’s field defined by dtype and beginning offset bytes into the field.

Parameters:

val (object) – Value to be placed in field.
dtype (dtype object) – Data-type of the field in which to place val.
offset (int, optional) – The number of bytes into the field at which to place val.

Return type:

None

See also

getfield

Examples

>>> import numpy as np
>>> x = np.eye(3)
>>> x.getfield(np.float64)
array([[1.,  0.,  0.],
       [0.,  1.,  0.],
       [0.,  0.,  1.]])
>>> x.setfield(3, np.int32)
>>> x.getfield(np.int32)
array([[3, 3, 3],
       [3, 3, 3],
       [3, 3, 3]], dtype=int32)
>>> x
array([[1.0e+000, 1.5e-323, 1.5e-323],
       [1.5e-323, 1.0e+000, 1.5e-323],
       [1.5e-323, 1.5e-323, 1.0e+000]])
>>> x.setfield(np.eye(3), np.int32)
>>> x
array([[1.,  0.,  0.],
       [0.,  1.,  0.],
       [0.,  0.,  1.]])

setflags(write=None, align=None, uic=None)

Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY, respectively.

These Boolean-valued flags affect how numpy interprets the memory area used by a (see Notes below). The ALIGNED flag can only be set to True if the data is actually aligned according to the type. The WRITEBACKIFCOPY flag can never be set to True. The flag WRITEABLE can only be set to True if the array owns its own memory, or the ultimate owner of the memory exposes a writeable buffer interface, or is a string. (The exception for string is made so that unpickling can be done without copying memory.)

Parameters:

write (bool, optional) – Describes whether or not a can be written to.
align (bool, optional) – Describes whether or not a is aligned properly for its type.
uic (bool, optional) – Describes whether or not a is a copy of another “base” array.

Notes

Array flags provide information about how the memory area used for the array is to be interpreted. There are 7 Boolean flags in use, only three of which can be changed by the user: WRITEBACKIFCOPY, WRITEABLE, and ALIGNED.

WRITEABLE (W) the data area can be written to;

ALIGNED (A) the data and strides are aligned appropriately for the hardware (as determined by the compiler);

WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced by .base). When the C-API function PyArray_ResolveWritebackIfCopy is called, the base array will be updated with the contents of this array.

All flags can be accessed using the single (upper case) letter as well as the full name.

Examples

>>> import numpy as np
>>> y = np.array([[3, 1, 7],
...               [2, 0, 0],
...               [8, 5, 9]])
>>> y
array([[3, 1, 7],
       [2, 0, 0],
       [8, 5, 9]])
>>> y.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
>>> y.setflags(write=0, align=0)
>>> y.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : False
  ALIGNED : False
  WRITEBACKIFCOPY : False
>>> y.setflags(uic=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot set WRITEBACKIFCOPY flag to True

sort(axis=-1, kind=None, order=None, *, stable=None, descending=None)

Sort an array in-place. Refer to numpy.sort for full documentation.

Parameters:

axis (int, optional) – Axis along which to sort. Default is -1, which means sort along the last axis.
kind ({'quicksort', 'mergesort', 'heapsort', 'stable'}, optional) – Sorting algorithm. The default is ‘quicksort’. Note that both ‘stable’ and ‘mergesort’ use timsort under the covers and, in general, the actual implementation will vary with datatype. The ‘mergesort’ option is retained for backwards compatibility.
order (str or list of str, optional) – When a is an array with fields defined, this argument specifies which fields to compare first, second, etc. A single field can be specified as a string, and not all fields need be specified, but unspecified fields will still be used, in the order in which they come up in the dtype, to break ties.
stable (bool, optional) –
Sort stability. If True, the returned array will maintain the relative order of a values which compare as equal. If False or None, this is not guaranteed. Internally, this option selects kind='stable'. Default: None.

Added in version 2.0.0.

See also

numpy.sort: Return a sorted copy of an array.
numpy.argsort: Indirect sort.
numpy.lexsort: Indirect stable sort on multiple keys.
numpy.searchsorted: Find elements in sorted array.
numpy.partition: Partial sort.

Notes

See numpy.sort for notes on the different sorting algorithms.

Examples

>>> import numpy as np
>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
       [1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
       [1, 4]])

Use the order keyword to specify a field to use when sorting a structured array:

>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([(b'c', 1), (b'a', 2)],
      dtype=[('x', 'S1'), ('y', '<i8')])

squeeze(*args, **kwargs): Equivalent to self.toarray().squeeze(...)

std(*args, **kwargs): Equivalent to self.toarray().std(...)

sum(*args, **kwargs): Equivalent to self.toarray().sum(...)

swapaxes(*args, **kwargs): Equivalent to self.toarray().swapaxes(...)

take(*args, **kwargs): Equivalent to self.toarray().take(...)

to_device(device, /, *, stream=None)

For Array API compatibility. Since NumPy only supports CPU arrays, this method is a no-op that returns the same array.

Parameters:

device ("cpu") – Must be "cpu".
stream (None, optional) – Currently unsupported.

Returns:

out – Returns the same array.

Return type:

Self

toarray()[source]

Convert to a dense array, where non-defined blocks will be zero

Return type:: ndarray

tobd(axes=None)[source]

Return only the block diagonal part of the array (blocks are shared)

Parameters:: axes (Sequence[int] | None) – the axes where the block indices are equal, defaults to all axes
Return type:: BlockArray

tobtd(axes=None)[source]

Return only the block tridiagonal part of the array (blocks are shared)

Parameters:: axes (Sequence[int] | None) – the axes where the block indices may differ by at most 1, defaults to all axes
Return type:: BlockArray

tobytes(*args, **kwargs): Equivalent to self.toarray().tobytes(...)

tofile(*args, **kwargs): Equivalent to self.toarray().tofile(...)

tolist(*args, **kwargs): Equivalent to self.toarray().tolist(...)

trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)[source]

Sum along the diagonal of the array, see numpy.trace

Parameters:

offset (int)
axis1 (int)
axis2 (int)

transpose(*axes)[source]

Array with permuted axes, the blocks are views of the transposed blocks

Reversing the axes swaps the memory order (“C” <-> “F”), for other permutations the blocks are not contiguous.

Return type:: BlockArray

var(*args, **kwargs): Equivalent to self.toarray().var(...)

view([dtype][, type])

New view of array with the same data.

Note

Passing None for dtype is different from omitting the parameter, since the former invokes dtype(None) which is an alias for dtype(np.float64).

Parameters:

dtype (data-type or ndarray sub-class, optional) – Data-type descriptor of the returned view, e.g., float32 or int16. Omitting it results in the view having the same data-type as a. This argument can also be specified as an ndarray sub-class, which then specifies the type of the returned object (this is equivalent to setting the type parameter).
type (Python type, optional) – Type of the returned view, e.g., ndarray or matrix. Again, omission of the parameter results in type preservation.

Notes

a.view() is used two different ways:

a.view(some_dtype) or a.view(dtype=some_dtype) constructs a view of the array’s memory with a different data-type. This can cause a reinterpretation of the bytes of memory.

a.view(ndarray_subclass) or a.view(type=ndarray_subclass) just returns an instance of ndarray_subclass that looks at the same array (same shape, dtype, etc.) This does not cause a reinterpretation of the memory.

For a.view(some_dtype), if some_dtype has a different number of bytes per entry than the previous dtype (for example, converting a regular array to a structured array), then the last axis of a must be contiguous. This axis will be resized in the result.

Changed in version 1.23.0: Only the last axis needs to be contiguous. Previously, the entire array had to be C-contiguous.

Examples

>>> import numpy as np
>>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)])

Viewing array data using a different type and dtype:

>>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)])
>>> y = x.view(dtype=nonneg, type=np.recarray)
>>> x["a"]
array([-1], dtype=int8)
>>> y.a
array([255], dtype=uint8)

Creating a view on a structured array so it can be used in calculations

>>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
>>> xv = x.view(dtype=np.int8).reshape(-1,2)
>>> xv
array([[1, 2],
       [3, 4]], dtype=int8)
>>> xv.mean(0)
array([2.,  3.])

Making changes to the view changes the underlying array

>>> xv[0,1] = 20
>>> x
array([(1, 20), (3,  4)], dtype=[('a', 'i1'), ('b', 'i1')])

Using a view to convert an array to a recarray:

>>> z = x.view(np.recarray)
>>> z.a
array([1, 3], dtype=int8)

Views share data:

>>> x[0] = (9, 10)
>>> z[0]
np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')])

Views that change the dtype size (bytes per entry) should normally be avoided on arrays defined by slices, transposes, fortran-ordering, etc.:

>>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16)
>>> y = x[:, ::2]
>>> y
array([[1, 3],
       [4, 6]], dtype=int16)
>>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
Traceback (most recent call last):
    ...
ValueError: To change to a dtype of a different size, the last axis must be contiguous
>>> z = y.copy()
>>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
array([[(1, 3)],
       [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])

However, views that change dtype are totally fine for arrays with a contiguous last axis, even if the rest of the axes are not C-contiguous:

>>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
>>> x.transpose(1, 0, 2).view(np.int16)
array([[[ 256,  770],
        [3340, 3854]],

       [[1284, 1798],
        [4368, 4882]],

       [[2312, 2826],
        [5396, 5910]]], dtype=int16)

property T: BlockArray: Array with reversed axes, see transpose

base

Base object if memory is from some other object.

Examples

The base of an array that owns its memory is None:

>>> import numpy as np
>>> x = np.array([1,2,3,4])
>>> x.base is None
True

Slicing creates a view, whose memory is shared with x:

>>> y = x[2:]
>>> y.base is x
True

property block_indexer: BlockArrayIndexer

Get the indexer for this block array

The indexer allows manipulating the array using indices of the blocks, rather than indices of the array elements.

property blocks: tuple[TypeAliasForwardRef('~numpy.ndarray'), ...]: Size of the blocks along each axis

ctypes

An object to simplify the interaction of the array with the ctypes module.

This attribute creates an object that makes it easier to use arrays when calling shared libraries with the ctypes module. The returned object has, among others, data, shape, and strides attributes (see Notes below) which themselves return ctypes objects that can be used as arguments to a shared library.

Parameters:: None
Returns:: c – Possessing attributes data, shape, strides, etc.
Return type:: Python object

See also

numpy.ctypeslib

Notes

Below are the public attributes of this object which were documented in “Guide to NumPy” (we have omitted undocumented public attributes, as well as documented private attributes):

_ctypes.data

A pointer to the memory area of the array as a Python integer. This memory area may contain data that is not aligned, or not in correct byte-order. The memory area may not even be writeable. The array flags and data-type of this array should be respected when passing this attribute to arbitrary C-code to avoid trouble that can include Python crashing. User Beware! The value of this attribute is exactly the same as: self._array_interface_['data'][0].

Note that unlike data_as, a reference won’t be kept to the array: code like ctypes.c_void_p((a + b).ctypes.data) will result in a pointer to a deallocated array, and should be spelt (a + b).ctypes.data_as(ctypes.c_void_p)

_ctypes.shape

A ctypes array of length self.ndim where the basetype is the C-integer corresponding to dtype('p') on this platform (see c_intp). This base-type could be ctypes.c_int, ctypes.c_long, or ctypes.c_longlong depending on the platform. The ctypes array contains the shape of the underlying array.

Type:: (c_intp*self.ndim)

_ctypes.strides

A ctypes array of length self.ndim where the basetype is the same as for the shape attribute. This ctypes array contains the strides information from the underlying array. This strides information is important for showing how many bytes must be jumped to get to the next element in the array.

Type:: (c_intp*self.ndim)

_ctypes.data_as(obj)

Return the data pointer cast to a particular c-types object. For example, calling self._as_parameter_ is equivalent to self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a pointer to a ctypes array of floating-point data: self.data_as(ctypes.POINTER(ctypes.c_double)).

The returned pointer will keep a reference to the array.

_ctypes.shape_as(obj): Return the shape tuple as an array of some other c-types type. For example: self.shape_as(ctypes.c_short).

_ctypes.strides_as(obj): Return the strides tuple as an array of some other c-types type. For example: self.strides_as(ctypes.c_longlong).

If the ctypes module is not available, then the ctypes attribute of array objects still returns something useful, but ctypes objects are not returned and errors may be raised instead. In particular, the object will still have the as_parameter attribute which will return an integer equal to the data attribute.

Examples

>>> import numpy as np
>>> import ctypes
>>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
>>> x
array([[0, 1],
       [2, 3]], dtype=int32)
>>> x.ctypes.data
31962608 # may vary
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
<__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
c_uint(0)
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
c_ulong(4294967296)
>>> x.ctypes.shape
<numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
>>> x.ctypes.strides
<numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary

data: Python buffer object pointing to the start of the array’s data.

device

property dtype: np.dtype: Data-type of the array

flags

Information about the memory layout of the array.

C_CONTIGUOUS(C): The data is in a single, C-style contiguous segment.

F_CONTIGUOUS(F): The data is in a single, Fortran-style contiguous segment.

OWNDATA(O): The array owns the memory it uses or borrows it from another object.

WRITEABLE(W): The data area can be written to. Setting this to False locks the data, making it read-only. A view (slice, etc.) inherits WRITEABLE from its base array at creation time, but a view of a writeable array may be subsequently locked while the base array remains writeable. (The opposite is not true, in that a view of a locked array may not be made writeable. However, currently, locking a base object does not lock any views that already reference it, so under that circumstance it is possible to alter the contents of a locked array via a previously created writeable view onto it.) Attempting to change a non-writeable array raises a RuntimeError exception.

ALIGNED(A): The data and all elements are aligned appropriately for the hardware.

WRITEBACKIFCOPY(X): This array is a copy of some other array. The C-API function PyArray_ResolveWritebackIfCopy must be called before deallocating to the base array will be updated with the contents of this array.

FNC: F_CONTIGUOUS and not C_CONTIGUOUS.

FORC: F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).

BEHAVED(B): ALIGNED and WRITEABLE.

CARRAY(CA): BEHAVED and C_CONTIGUOUS.

FARRAY(FA): BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.

Notes

The flags object can be accessed dictionary-like (as in a.flags['WRITEABLE']), or by using lowercased attribute names (as in a.flags.writeable). Short flag names are only supported in dictionary access.

Only the WRITEBACKIFCOPY, WRITEABLE, and ALIGNED flags can be changed by the user, via direct assignment to the attribute or dictionary entry, or by calling ndarray.setflags.

The array flags cannot be set arbitrarily:

WRITEBACKIFCOPY can only be set False.
ALIGNED can only be set True if the data is truly aligned.
WRITEABLE can only be set True if the array owns its own memory or the ultimate owner of the memory exposes a writeable buffer interface or is a string.

Arrays can be both C-style and Fortran-style contiguous simultaneously. This is clear for 1-dimensional arrays, but can also be true for higher dimensional arrays.

Even for contiguous arrays a stride for a given dimension arr.strides[dim] may be arbitrary if arr.shape[dim] == 1 or the array has no elements. It does not generally hold that self.strides[-1] == self.itemsize for C-style contiguous arrays or self.strides[0] == self.itemsize for Fortran-style contiguous arrays is true.

flat

A 1-D iterator over the array.

This is a numpy.flatiter instance, which acts similarly to, but is not a subclass of, Python’s built-in iterator object.

See also

flatten: Return a copy of the array collapsed into one dimension.

flatiter

Examples

>>> import numpy as np
>>> x = np.arange(1, 7).reshape(2, 3)
>>> x
array([[1, 2, 3],
       [4, 5, 6]])
>>> x.flat[3]
4
>>> x.T
array([[1, 4],
       [2, 5],
       [3, 6]])
>>> x.T.flat[3]
5
>>> type(x.flat)
<class 'numpy.flatiter'>

An assignment example:

>>> x.flat = 3; x
array([[3, 3, 3],
       [3, 3, 3]])
>>> x.flat[[1,4]] = 1; x
array([[3, 1, 3],
       [3, 1, 3]])

property imag: BlockArray: Imaginary part of the array, the blocks are views

property itemsize: int

Length of one array element in bytes.

Examples

>>> import numpy as np
>>> x = np.array([1,2,3], dtype=np.float64)
>>> x.itemsize
8
>>> x = np.array([1,2,3], dtype=np.complex128)
>>> x.itemsize
16

mT

View of the matrix transposed array.

The matrix transpose is the transpose of the last two dimensions, even if the array is of higher dimension.

Added in version 2.0.

Raises:: ValueError – If the array is of dimension less than 2.

Examples

>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
       [3, 4]])
>>> a.mT
array([[1, 3],
       [2, 4]])

>>> a = np.arange(8).reshape((2, 2, 2))
>>> a
array([[[0, 1],
        [2, 3]],

       [[4, 5],
        [6, 7]]])
>>> a.mT
array([[[0, 2],
        [1, 3]],

       [[4, 6],
        [5, 7]]])

property nbytes: int: Number of bytes of the defined blocks

ndim

Number of array dimensions.

Examples

>>> import numpy as np
>>> x = np.array([1, 2, 3])
>>> x.ndim
1
>>> y = np.zeros((2, 3, 4))
>>> y.ndim
3

property order: str: Memory order of the blocks

property real: BlockArray: Real part of the array, the blocks are views

property shape: tuple[int, ...]: Shape of the (dense) array

property size: int: Number of elements in the (dense) array

strides

Tuple of bytes to step in each dimension when traversing an array.

The byte offset of element (i[0], i[1], ..., i[n]) in an array a is:

offset = sum(np.array(i) * a.strides)

A more detailed explanation of strides can be found in The N-dimensional array (ndarray).

Warning

Setting arr.strides is discouraged and may be deprecated in the future. numpy.lib.stride_tricks.as_strided should be preferred to create a new view of the same data in a safer way.

Notes

Imagine an array of 32-bit integers (each 4 bytes):

x = np.array([[0, 1, 2, 3, 4],
              [5, 6, 7, 8, 9]], dtype=np.int32)

This array is stored in memory as 40 bytes, one after the other (known as a contiguous block of memory). The strides of an array tell us how many bytes we have to skip in memory to move to the next position along a certain axis. For example, we have to skip 4 bytes (1 value) to move to the next column, but 20 bytes (5 values) to get to the same position in the next row. As such, the strides for the array x will be (20, 4).

See also

numpy.lib.stride_tricks.as_strided

Examples

>>> import numpy as np
>>> y = np.reshape(np.arange(2 * 3 * 4, dtype=np.int32), (2, 3, 4))
>>> y
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]]], dtype=np.int32)
>>> y.strides
(48, 16, 4)
>>> y[1, 1, 1]
np.int32(17)
>>> offset = sum(y.strides * np.array((1, 1, 1)))
>>> offset // y.itemsize
np.int64(17)

>>> x = np.reshape(np.arange(5*6*7*8, dtype=np.int32), (5, 6, 7, 8))
>>> x = x.transpose(2, 3, 1, 0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3, 5, 2, 2], dtype=np.int32)
>>> offset = sum(i * x.strides)
>>> x[3, 5, 2, 2]
np.int32(813)
>>> offset // x.itemsize
np.int64(813)