# nlcpy.diagonal

nlcpy.diagonal(a, offset=0, axis1=0, axis2=1)[ソース]

Returns specified diagonals.

If a is 2-D, returns the diagonal of a with the given offset, i.e., the collection of elements of the form `a[i, i+offset]`. If a has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-D sub-array whose diagonal is returned. The shape of the resulting array can be determined by removing axis1 and axis2 and appending an index to the right equal to the size of the resulting diagonals. This function returns a writable view of the original array.

Parameters
aarray_like

Array from which the diagonals are taken.

offsetint, optional

Offset of the diagonal from the main diagonal. Can be positive or negative. Defaults to main diagonal (0).

axis1int, optional

Axis to be used as the first axis of the 2-D sub-arrays from which the diagonals should be taken. Defaults to first axis (0).

axis2int, optional

Axis to be used as the second axis of the 2-D sub-arrays from which the diagonals should be taken. Defaults to second axis (1).

Returns
array_of_diagonalsndarray

If a is 2-D, then a 1-D array containing the diagonal and of the same type as a is returned. If `a.ndim > 2`, then the dimensions specified by axis1 and axis2 are removed, and a new axis inserted at the end corresponding to the diagonal.

`diag`

Extracts a diagonal or constructs a diagonal array.

`a.ndim < 2` : ValueError occurs.

Examples

```>>> import nlcpy as vp
>>> a = vp.arange(4).reshape(2,2)
>>> a
array([[0, 1],
[2, 3]])
>>> a.diagonal()
array([0, 3])
>>> a.diagonal(1)
array([1])
```

A 3-D example:

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

[[4, 5],
[6, 7]]])
>>> a.diagonal(0,  # Main diagonals of two arrays created by skipping
...            0,  # across the outer(left)-most axis last and
...            1)  # the "middle" (row) axis first.
array([[0, 6],
[1, 7]])
```

The sub-arrays whose main diagonals we just obtained; note that each corresponds to fixing the right-most (column) axis, and that the diagonals are “packed” in rows.

```>>> a[:,:,0]  # main diagonal is [0 6]
array([[0, 2],
[4, 6]])
>>> a[:,:,1]  # main diagonal is [1 7]
array([[1, 3],
[5, 7]])
```