nlcpy.fill_diagonal

nlcpy.fill_diagonal(a, val, wrap=False)[source]

Fills the main diagonal of the given array of any dimensionality.

For an array a with a.ndim >= 2, the diagonal is the list of locations with indices a[i, ..., i] all identical. This function modifies the input array in-place, it does not return a value.

Parameters

aarray_like: Array whose diagonal is to be filled, it gets modified in-place.
valscalar: Value to be written on the diagonal, its type must be compatible with that of the array a.
wrapbool: For tall matrices, the diagonal “wrapped” after N columns. You can have this behavior with this option. This affects only tall matrices.

See also

diag_indices: Returns the indices to access the main diagonal of an array.

Note

This functionality can be obtained via diag_indices, but internally this version uses a much faster implementation that never constructs the indices and uses simple slicing.

Examples

>>> import nlcpy as vp
>>> a = vp.zeros((3, 3), int)
>>> vp.fill_diagonal(a, 5)
>>> a
array([[5, 0, 0],
       [0, 5, 0],
       [0, 0, 5]])

The same function can operate on a 4-D array:

>>> a = vp.zeros((3, 3, 3, 3), int)
>>> vp.fill_diagonal(a, 4)

We only show a few blocks for clarity:

>>> a[0, 0]
array([[4, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])
>>> a[1, 1]
array([[0, 0, 0],
       [0, 4, 0],
       [0, 0, 0]])
>>> a[2, 2]
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 4]])

The wrap option affects only tall matrices:

>>> # tall matrices no wrap
>>> a = vp.zeros((5, 3), int)
>>> vp.fill_diagonal(a, 4)
>>> a
array([[4, 0, 0],
       [0, 4, 0],
       [0, 0, 4],
       [0, 0, 0],
       [0, 0, 0]])

>>> # tall matrices wrap
>>> a = vp.zeros((5, 3), int)
>>> vp.fill_diagonal(a, 4, wrap=True)
>>> a
array([[4, 0, 0],
       [0, 4, 0],
       [0, 0, 4],
       [0, 0, 0],
       [4, 0, 0]])

>>> # wide matrices
>>> a = vp.zeros((3, 5), int)
>>> vp.fill_diagonal(a, 4, wrap=True)
>>> a
array([[4, 0, 0, 0, 0],
       [0, 4, 0, 0, 0],
       [0, 0, 4, 0, 0]])

The anti-diagonal can be filled by reversing the order of elements using either nlcpy.flipud or nlcpy.fliplr.

>>> a = vp.zeros((3, 3), int);
>>> vp.fill_diagonal(vp.fliplr(a), [1,2,3])  # Horizontal flip
>>> a
array([[0, 0, 1],
       [0, 2, 0],
       [3, 0, 0]])
>>> vp.fill_diagonal(vp.flipud(a), [1,2,3])  # Vertical flip
>>> a
array([[0, 0, 3],
       [0, 2, 0],
       [1, 0, 0]])

Note that the order in which the diagonal is filled varies depending on the flip function.