fill_diagonal(a, val, wrap=False)

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.

Notes

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.

Parameters

a : array, at least 2-D.

Array whose diagonal is to be filled, it gets modified in-place.

val : scalar or array_like

Value(s) to write on the diagonal. If :None:None:`val` is scalar, the value is written along the diagonal. If array-like, the flattened :None:None:`val` is written along the diagonal, repeating if necessary to fill all diagonal entries.

wrap : bool

For tall matrices in NumPy version up to 1.6.2, the diagonal "wrapped" after N columns. You can have this behavior with this option. This affects only tall matrices.

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

See Also

diag_indices

diag_indices_from

Examples

>>> a = np.zeros((3, 3), int)
... np.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 = np.zeros((3, 3, 3, 3), int)
... np.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 = np.zeros((5, 3), int)
... np.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 = np.zeros((5, 3), int)
... np.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 = np.zeros((3, 5), int)
... np.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 numpy.flipud or numpy.fliplr .

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

>>> np.fill_diagonal(np.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.

See :

Local connectivity graph

Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.

Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)

SVG is more flexible but power hungry; and does not scale well to 50 + nodes.

All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them

---

GitHub : /numpy/lib/index_tricks.py#779
type: <class 'function'>
Commit: