'T}. P d dl Z d dlZd dlZd dlZd dlZddlmZ d dlm c m
Z d dlm Z m
Z
d dlmZ d dlmZ ddlmZ d dlmZmZ d d lmZmZ d d
lmZ e j ej d Z g d
Z d Z e e d Z G d d Z! G d de! Z" e" Z# G d de! Z$ e$ Z% G d d Z& G d de& Z' e' Z( G d de& Z) e) Z* ed G d d Z+ ed G d d Z, G d d! Z- e-d"# Z. e-d$# Z/d*d%Z0 e e0 d+d& Z1 ed d,d' Z2d( Z3 e e3 d) Z4dS )- N )
set_module)
ScalarTypearray)
issubdtype )diff)ravel_multi_index
unravel_index) overrideslinspace)
as_stridednumpy)module)r
r mgridogridr_c_s_ index_expix_ ndenumeratendindex
fill_diagonal diag_indicesdiag_indices_fromc | S N )argss j/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib64/python3.11/site-packages/numpy/lib/index_tricks.py_ix__dispatcherr" s K c > g }t | }t | D ]\ }}t |t j s>t j | }|j dk r | t j }|j
dk rt d t |j
t j r| \ }| d|z |j fz d||z
dz
z z }| | t% | S )a5
Construct an open mesh from multiple sequences.
This function takes N 1-D sequences and returns N outputs with N
dimensions each, such that the shape is 1 in all but one dimension
and the dimension with the non-unit shape value cycles through all
N dimensions.
Using `ix_` one can quickly construct index arrays that will index
the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array
``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.
Parameters
----------
args : 1-D sequences
Each sequence should be of integer or boolean type.
Boolean sequences will be interpreted as boolean masks for the
corresponding dimension (equivalent to passing in
``np.nonzero(boolean_sequence)``).
Returns
-------
out : tuple of ndarrays
N arrays with N dimensions each, with N the number of input
sequences. Together these arrays form an open mesh.
See Also
--------
ogrid, mgrid, meshgrid
Examples
--------
>>> a = np.arange(10).reshape(2, 5)
>>> a
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> ixgrid = np.ix_([0, 1], [2, 4])
>>> ixgrid
(array([[0],
[1]]), array([[2, 4]]))
>>> ixgrid[0].shape, ixgrid[1].shape
((2, 1), (1, 2))
>>> a[ixgrid]
array([[2, 4],
[7, 9]])
>>> ixgrid = np.ix_([True, True], [2, 4])
>>> a[ixgrid]
array([[2, 4],
[7, 9]])
>>> ixgrid = np.ix_([True, True], [False, False, True, False, True])
>>> a[ixgrid]
array([[2, 4],
[7, 9]])
r r z!Cross index must be 1 dimensional)r )len enumerate
isinstance_nxndarraynpasarraysizeastypeintpndim
ValueErrorr dtypebool_nonzeroreshapeappendtuple)r outndknews r! r r " s t
C TBD// 3#s{++ +*S//Cx1}}jj** 8q== @AA A ci + + !;;==DCkk$q&CH;.r!tAv >??
3 ::r# c e Zd ZdZddZd ZdS )nd_grida
Construct a multi-dimensional "meshgrid".
``grid = nd_grid()`` creates an instance which will return a mesh-grid
when indexed. The dimension and number of the output arrays are equal
to the number of indexing dimensions. If the step length is not a
complex number, then the stop is not inclusive.
However, if the step length is a **complex number** (e.g. 5j), then the
integer part of its magnitude is interpreted as specifying the
number of points to create between the start and stop values, where
the stop value **is inclusive**.
If instantiated with an argument of ``sparse=True``, the mesh-grid is
open (or not fleshed out) so that only one-dimension of each returned
argument is greater than 1.
Parameters
----------
sparse : bool, optional
Whether the grid is sparse or not. Default is False.
Notes
-----
Two instances of `nd_grid` are made available in the NumPy namespace,
`mgrid` and `ogrid`, approximately defined as::
mgrid = nd_grid(sparse=False)
ogrid = nd_grid(sparse=True)
Users should use these pre-defined instances instead of using `nd_grid`
directly.
Fc || _ d S r sparse)selfr? s r! __init__znd_grid.__init__ s
r# c
g }dg}t t | D ]}|| j }|| j }|| j }|d}|d}t |t j t f r2t | }|
t | n=|
t t j
||z
|dz z ||||gz
}t
j | }| j r,d t! ||ft | z D } nt
j || } t% | D ]\ }}
|
j }|
j }|d}|d}t |t j t f r?t t | }|dk r |
j |z
t' |dz
z }| | |z |z | |< | j r|t j gt | z } t t | D ]B}t+ d d | |< | | t- | | |< t j | |< C| S # t. t0 f$ r |j }|j }|j }|d}t |t j t f ryt | } t | x}}
|dk r |j |z
t' |dz
z }t
j ||| }t
j d|
d| |z |z cY S t
j ||| cY S w xY w)Nr r g ?c @ g | ]\ }}t j || S )r1 )r( arange).0_x_ts r!
z'nd_grid.__getitem__.. sA A A A "b j2... A A Ar# rD )ranger% stepstartstopr' r( complexfloatingcomplexabsr5 intmathceil result_typer? zipindicesr& floatnewaxisslicer6
IndexError TypeErrorrE )r@ keyr, num_listr9 rK rL rM typnnkkslobj
step_floatlengths r! __getitem__znd_grid.__getitem__ s` < 5D sH3s88__
0
01v{A 1v{= E< D dS%8'$BCC E t99DKKD ****KKDIte|S&A B BCCE E EUD$ ///8,C{
,A A$'sfSYY.>$?$?A A A [s++"3
+
+2w= E< D dS%8'$BCC C s4yy>>Dqyy "%5?? BAtE)1{
+
c$ii/ s4yy)) + +A $T4 0 0E!H qE%,, /BqE "{E!HHII& 5 5 58D8DIE}$!4g >??
5 YY
#J/v199 HUNE$q&MM9DoeT:>>z!VQc:::4?%GGGGz%t44444 5s I!I$ $CM(M MNF__name__
__module__ __qualname____doc__rA rd r r# r! r< r< m sB D =5 =5 =5 =5 =5r# r< c " e Zd ZdZ fdZ xZS )
MGridClassaM
An instance which returns a dense multi-dimensional "meshgrid".
An instance which returns a dense (or fleshed out) mesh-grid
when indexed, so that each returned argument has the same shape.
The dimensions and number of the output arrays are equal to the
number of indexing dimensions. If the step length is not a complex
number, then the stop is not inclusive.
However, if the step length is a **complex number** (e.g. 5j), then
the integer part of its magnitude is interpreted as specifying the
number of points to create between the start and stop values, where
the stop value **is inclusive**.
Returns
-------
mesh-grid `ndarrays` all of the same dimensions
See Also
--------
ogrid : like `mgrid` but returns open (not fleshed out) mesh grids
meshgrid: return coordinate matrices from coordinate vectors
r_ : array concatenator
:ref:`how-to-partition`
Examples
--------
>>> np.mgrid[0:5, 0:5]
array([[[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1],
[2, 2, 2, 2, 2],
[3, 3, 3, 3, 3],
[4, 4, 4, 4, 4]],
[[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]]])
>>> np.mgrid[-1:1:5j]
array([-1. , -0.5, 0. , 0.5, 1. ])
c L t d d S )NFr> superrA r@ __class__s r! rA zMGridClass.__init__ s$
&&&&&r# rg rh ri rj rA
__classcell__rq s @r! rl rl sC ) )V' ' ' ' ' ' ' ' 'r# rl c " e Zd ZdZ fdZ xZS )
OGridClassa
An instance which returns an open multi-dimensional "meshgrid".
An instance which returns an open (i.e. not fleshed out) mesh-grid
when indexed, so that only one dimension of each returned array is
greater than 1. The dimension and number of the output arrays are
equal to the number of indexing dimensions. If the step length is
not a complex number, then the stop is not inclusive.
However, if the step length is a **complex number** (e.g. 5j), then
the integer part of its magnitude is interpreted as specifying the
number of points to create between the start and stop values, where
the stop value **is inclusive**.
Returns
-------
mesh-grid
`ndarrays` with only one dimension not equal to 1
See Also
--------
mgrid : like `ogrid` but returns dense (or fleshed out) mesh grids
meshgrid: return coordinate matrices from coordinate vectors
r_ : array concatenator
:ref:`how-to-partition`
Examples
--------
>>> from numpy import ogrid
>>> ogrid[-1:1:5j]
array([-1. , -0.5, 0. , 0.5, 1. ])
>>> ogrid[0:5,0:5]
[array([[0],
[1],
[2],
[3],
[4]]), array([[0, 1, 2, 3, 4]])]
c L t d d S )NTr> rn rp s r! rA zOGridClass.__init__/ s$
%%%%%r# rr rt s @r! rv rv sC & &P& & & & & & & & &r# rv c f e Zd ZdZ eej Z eej Z d
dZ
d Z d Z d S ) AxisConcatenatorzv
Translates slice objects to concatenation along an axis.
For detailed documentation on usage, see `r_`.
r Fr c > || _ || _ || _ || _ d S r )axismatrixtrans1dndmin)r@ r| r} r r~ s r! rA zAxisConcatenator.__init__@ s"
r# c t |t r:t j j }t j ||j |j }|S t |t s|f}| j
}| j | j }| j
}g }g }t | D ]\ } }
d} t |
t r|
j } |
j }
|
j }|
d}
| d} t | t& j t* f r/t- t/ | }t1 |
|| }nt' j |
|| } dk r.t5 |d }|dk r| d| }nt |
t r| dk rt9 d |
dv r
d }|
d
k }d |
v r|
d } d |d d
D \ } t= | dk rt- |d
}i# t> $ r(}t9 d |
|d }~ww xY w t- |
}# t8 tB f$ r}t9 d |d }~ww xY wtE |
tF v rd } |
}ntI j% |
}t5 |
dd }|dk rl| k rf |z
}|}|dk r||dz z
}tM tO }|d | ||d z ||| z }|( | }|) | | r|) |
|) |j* t= | dk r t' j+ | fd|D }| , t | | }|r+|j% }| - | }|dk r |r|j. }|S )NFr r )num)copyr rz z+special directives must be the first entry.)rcTr ,c , g | ]}t | S r )rQ )rF xs r! rI z0AxisConcatenator.__getitem__..x s &?&?&?!s1vv&?&?&?r# r z unknown special directive {!r}zunknown special directive)r subokr c 8 g | ]}t |d d S )FT)r r r r1 )r )rF obj final_dtyper s r! rI z0AxisConcatenator.__getitem__.. sI K K K>A #E %[: : : K K Kr# )r| )/r' strsys _getframef_back matrixlibbmat f_globalsf_localsr6 r~ r r} r| r& rY rK rL rM r( rN rO rQ rP r
rE r swapaxesr0 splitr% Exceptionformatr[ typer r* r/ listrJ transposer5 r1 rT concatenatemakematT) r@ r\ framemymatr~ r} r| objsresult_type_objsr9 itemscalarrK rL rM r, newobjcolvece item_ndimk2k1defaxesaxesresoldndimr r s @@r! rd z AxisConcatenator.__getitem__F sf c3 MOO*E N3 HHEL#u%% &C ,
y ~~ > 6 > 6GAtF$&& 6
4y
y= E< D dS%8'$BCC ; s4yy>>D %eTt < < >> np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])]
array([1, 2, 3, ..., 4, 5, 6])
>>> np.r_[-1:1:6j, [0]*3, 5, 6]
array([-1. , -0.6, -0.2, 0.2, 0.6, 1. , 0. , 0. , 0. , 5. , 6. ])
String integers specify the axis to concatenate along or the minimum
number of dimensions to force entries into.
>>> a = np.array([[0, 1, 2], [3, 4, 5]])
>>> np.r_['-1', a, a] # concatenate along last axis
array([[0, 1, 2, 0, 1, 2],
[3, 4, 5, 3, 4, 5]])
>>> np.r_['0,2', [1,2,3], [4,5,6]] # concatenate along first axis, dim>=2
array([[1, 2, 3],
[4, 5, 6]])
>>> np.r_['0,2,0', [1,2,3], [4,5,6]]
array([[1],
[2],
[3],
[4],
[5],
[6]])
>>> np.r_['1,2,0', [1,2,3], [4,5,6]]
array([[1, 4],
[2, 5],
[3, 6]])
Using 'r' or 'c' as a first string argument creates a matrix.
>>> np.r_['r',[1,2,3], [4,5,6]]
matrix([[1, 2, 3, 4, 5, 6]])
c < t | d d S r ry rA r s r! rA zRClass.__init__ s !!$*****r# Nrg rh ri rj rA r r# r! r r s0 \ \|+ + + + +r# r c e Zd ZdZd ZdS )CClassa
Translates slice objects to concatenation along the second axis.
This is short-hand for ``np.r_['-1,2,0', index expression]``, which is
useful because of its common occurrence. In particular, arrays will be
stacked along their last axis after being upgraded to at least 2-D with
1's post-pended to the shape (column vectors made out of 1-D arrays).
See Also
--------
column_stack : Stack 1-D arrays as columns into a 2-D array.
r_ : For more detailed documentation.
Examples
--------
>>> np.c_[np.array([1,2,3]), np.array([4,5,6])]
array([[1, 4],
[2, 5],
[3, 6]])
>>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
array([[1, 2, 3, ..., 4, 5, 6]])
c B t | ddd d S )Nrz r r )r r~ r r s r! rA zCClass.__init__2 s% !!$!Q!?????r# Nr r r# r! r r s2 0@ @ @ @ @r# r c $ e Zd ZdZd Zd Zd ZdS )r a
Multidimensional index iterator.
Return an iterator yielding pairs of array coordinates and values.
Parameters
----------
arr : ndarray
Input array.
See Also
--------
ndindex, flatiter
Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> for index, x in np.ndenumerate(a):
... print(index, x)
(0, 0) 1
(0, 1) 2
(1, 0) 3
(1, 1) 4
c B t j | j | _ d S r )r* r+ flatiter)r@ arrs r! rA zndenumerate.__init__U s JsOO( r# c B | j j t | j fS )a
Standard iterator method, returns the index tuple and array value.
Returns
-------
coords : tuple of ints
The indices of the current iteration.
val : scalar
The array element of the current iteration.
)r coordsnextr s r! __next__zndenumerate.__next__X s y di 00r# c | S r r r s r! __iter__zndenumerate.__iter__f r# N)rg rh ri rj rA r r r r# r! r r 9 sK 4) ) ) 1 1 1 r# r c * e Zd ZdZd Zd Zd Zd ZdS )r a
An N-dimensional iterator object to index arrays.
Given the shape of an array, an `ndindex` instance iterates over
the N-dimensional index of the array. At each iteration a tuple
of indices is returned, the last dimension is iterated over first.
Parameters
----------
shape : ints, or a single tuple of ints
The size of each dimension of the array can be passed as
individual parameters or as the elements of a tuple.
See Also
--------
ndenumerate, flatiter
Examples
--------
Dimensions as individual arguments
>>> for index in np.ndindex(3, 2, 1):
... print(index)
(0, 0, 0)
(0, 1, 0)
(1, 0, 0)
(1, 1, 0)
(2, 0, 0)
(2, 1, 0)
Same dimensions - but in a tuple ``(3, 2, 1)``
>>> for index in np.ndindex((3, 2, 1)):
... print(index)
(0, 0, 0)
(0, 1, 0)
(1, 0, 0)
(1, 1, 0)
(2, 0, 0)
(2, 1, 0)
c t | dk r#t |d t r|d }t t j d |t j | }t j |ddgd | _ d S )Nr r )shapestrides multi_index zerosize_okC)flagsorder) r% r' r6 r r( zeros
zeros_likenditer_it)r@ r r s r! rA zndindex.__init__ s u::??z%(E : :?!HE sy||5 "~e 4 4
6
6
6:a
}'E$') ) )r# c | S r r r s r! r zndindex.__iter__ r r# c \ t j dt d t | dS )a5
Increment the multi-dimensional index by one.
This method is for backward compatibility only: do not use.
.. deprecated:: 1.20.0
This method has been advised against since numpy 1.8.0, but only
started emitting DeprecationWarning as of this version.
z=`ndindex.ndincr()` is deprecated, use `next(ndindex)` insteadr )
stacklevelN)warningswarnDeprecationWarningr r s r! ndincrzndindex.ndincr s6
K 1 . . . .
T
r# c B t | j | j j S )z
Standard iterator method, updates the index and returns the index
tuple.
Returns
-------
val : tuple of ints
Returns a tuple containing the indices of the current
iteration.
)r r r r s r! r zndindex.__next__ s
TXx##r# N)rg rh ri rj rA r r r r r# r! r r j s[ ) )V) ) )
$
$
$
$
$r# r c e Zd ZdZd Zd ZdS )IndexExpressiona
A nicer way to build up index tuples for arrays.
.. note::
Use one of the two predefined instances `index_exp` or `s_`
rather than directly using `IndexExpression`.
For any index combination, including slicing and axis insertion,
``a[indices]`` is the same as ``a[np.index_exp[indices]]`` for any
array `a`. However, ``np.index_exp[indices]`` can be used anywhere
in Python code and returns a tuple of slice objects that can be
used in the construction of complex index expressions.
Parameters
----------
maketuple : bool
If True, always returns a tuple.
See Also
--------
index_exp : Predefined instance that always returns a tuple:
`index_exp = IndexExpression(maketuple=True)`.
s_ : Predefined instance without tuple conversion:
`s_ = IndexExpression(maketuple=False)`.
Notes
-----
You can do all this with `slice()` plus a few special objects,
but there's a lot to remember and this version is simpler because
it uses the standard array indexing syntax.
Examples
--------
>>> np.s_[2::2]
slice(2, None, 2)
>>> np.index_exp[2::2]
(slice(2, None, 2),)
>>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
array([2, 4])
c || _ d S r maketuple)r@ r s r! rA zIndexExpression.__init__ s
"r# c D | j rt |t s|fS |S r )r r' r6 )r@ r s r! rd zIndexExpression.__getitem__ s) > *T5"9"9 7NKr# Nrf r r# r! r r s= ) )V# # # r# r Tr Fc | fS r r )avalwraps r! _fill_diagonal_dispatcherr
s
4Kr# c | j dk rt d d}| j dk r.| j d dz }|s| j d | j d z }not j t | j dk st d dt j | j dd z }|| j d||< dS )a Fill 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
----------
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 `val` is scalar, the value is
written along the diagonal. If array-like, the flattened `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.
See also
--------
diag_indices, diag_indices_from
Notes
-----
.. versionadded:: 1.4.0
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
--------
>>> 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.
r zarray must be at least 2-dNr r /All dimensions of input must be of equal lengthrz ) r/ r0 r r* allr cumprodsumr )r r r endrK s r! r r s b vzz5666
Cv{{ wqzA~ *'!*qwqz)C vd17mmq()) P NOO OBJqwss|,,11333 AF9C9r# c 6 t j | }|f|z S )a(
Return the indices to access the main diagonal of an array.
This returns a tuple of indices that can be used to access the main
diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape
(n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for
``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]``
for ``i = [0..n-1]``.
Parameters
----------
n : int
The size, along each dimension, of the arrays for which the returned
indices can be used.
ndim : int, optional
The number of dimensions.
See Also
--------
diag_indices_from
Notes
-----
.. versionadded:: 1.4.0
Examples
--------
Create a set of indices to access the diagonal of a (4, 4) array:
>>> di = np.diag_indices(4)
>>> di
(array([0, 1, 2, 3]), array([0, 1, 2, 3]))
>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> a[di] = 100
>>> a
array([[100, 1, 2, 3],
[ 4, 100, 6, 7],
[ 8, 9, 100, 11],
[ 12, 13, 14, 100]])
Now, we create indices to manipulate a 3-D array:
>>> d3 = np.diag_indices(2, 3)
>>> d3
(array([0, 1]), array([0, 1]), array([0, 1]))
And use it to set the diagonal of an array of zeros to 1:
>>> a = np.zeros((2, 2, 2), dtype=int)
>>> a[d3] = 1
>>> a
array([[[1, 0],
[0, 0]],
[[0, 0],
[0, 1]]])
)r* rE )nr/ idxs r! r r s B
)A,,C 6D=r# c | fS r r r s r! _diag_indices_fromr s 6Mr# c | j dk st d t j t | j dk st d t
| j d | j S )aC
Return the indices to access the main diagonal of an n-dimensional array.
See `diag_indices` for full details.
Parameters
----------
arr : array, at least 2-D
See Also
--------
diag_indices
Notes
-----
.. versionadded:: 1.4.0
Examples
--------
Create a 4 by 4 array.
>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
Get the indices of the diagonal elements.
>>> di = np.diag_indices_from(a)
>>> di
(array([0, 1, 2, 3]), array([0, 1, 2, 3]))
>>> a[di]
array([ 0, 5, 10, 15])
This is simply syntactic sugar for diag_indices.
>>> np.diag_indices(a.shape[0])
(array([0, 1, 2, 3]), array([0, 1, 2, 3]))
r z input array must be at least 2-dr r )r/ r0 r* r r r r r s r! r r sh ^ 8q==;<<< 6$sy//Q& ' ' LJKKK ! ch / //r# r re )r )5 functoolsr rR r r r* _utilsr numpy.core.numericcorenumericr( r r numpy.core.numerictypesr numpy.matrixlibr
function_baser numpy.core.multiarrayr
r
numpy.corer r
numpy.lib.stride_tricksr partialarray_function_dispatch__all__r" r r< rl r rv r ry r r r r r r r r r r r r r r r r# r! r sE
0 0 0 0 0 0 0 0 . . . . . . # # # # # # B B B B B B B B * * * * * * * * . . . . . . ,)+
%g7 7 7 ))G G *)GTc5 c5 c5 c5 c5 c5 c5 c5L-' -' -' -' -' -' -' -'`
*& *& *& *& *& *& *& *&Z
v v v v v v v vz`+ `+ `+ `+ `+
`+ `+ `+F VXX@ @ @ @ @
@ @ @: VXX G- - - - - - - -` GT$ T$ T$ T$ T$ T$ T$ T$D3 3 3 3 3 3 3 3l
Od + + + _u%%% 233B B B 43B J GA A A AH +,,50 50 -,50 50 50r#