�
�9Zc@`
s@dd
lm
Z
mZmZ
ddlZddlZddljjZ	ddlm
Z
mZmZm
Z
mZmZ
ddlmZmZ
ddlmZ
ddljZddlmZ
ddlmZmZ
dd	lmZ
ejZd
ddd
ddddddddddgZd�Z de!f
d��YZ"e"de#�
Z$e"de%�
Z&de$_(de&_(de!f
d��YZ)de)f
d��YZ*e*�Z+d e)f
d!��YZ,e,�Z-de!f
d"��YZ.de!f
d#��YZ/d$e!f
d%��YZ0e0d&e%�
Z1e0d&e#�
Z2e#d'�
Z3d(d)�
Z4d*�Z5dS(+i(tdivisiontabsolute_importtprint_functionN(tasarrayt
ScalarTypetarraytalltruetcumprodtarange(tfind_common_typet
issubdtypei
(
t
function_base(
tdiff(travel_multi_indext
unravel_index(
t
as_stridedR
Rtmgridtogridtr_tc_ts_t	index_exptix_tndenumeratetndindext
fill_diagonaltdiag_indicestdiag_indices_fromcG`
s�g}
t|�
}x�t
|�
D]�\}}t|�
}|jd
krUtd�
�
n|jdkry|jtj�
}nt	|j
tj�r�|j�\
}n|j
d||jf
d||d
�
}|
j|�

qWt|
�
S(sa
    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

    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]])

    i
s!Cross index must be 1 dimensionali(
i
(
i
(tlent	enumerateRtndimt
ValueErrortsizetastypet_nxtintpR
tdtypetbool_tnonzerotreshapetappendttuple(targstouttndt
ktnew((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyRs,








-

tnd_gridcB`
s5eZ
dZed
�
Zd�Zd�Zd�ZRS(s
    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`::

        mgrid = nd_grid(sparse=False)
        ogrid = nd_grid(sparse=True)

    Users should use these pre-defined instances instead of using `nd_grid`
    directly.

    Examples
    --------
    >>> mgrid = np.lib.index_tricks.nd_grid()
    >>> 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]]])
    >>> mgrid[-1:1:5j]
    array([-1. , -0.5,  0. ,  0.5,  1. ])

    >>> ogrid = np.lib.index_tricks.nd_grid(sparse=True)
    >>> ogrid[0:5,0:5]
    [array([[0],
            [1],
            [2],
            [3],
            [4]]), array([[0, 1, 2, 3, 4]])]

    cC`
s
|
|_dS(
N(
tsparse(tselfR0((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyt__init__�s
c
C`
s�y�g}t}x�t
t|
�
�
D]�}|
|j}|
|j}|dkrWd
}n|dkrld}nt|t�r�|jtt	|�
�
�

t
}n/|jttj|
|j
||d�
�
�

t|t
�s
t|t
�s
t|
|j
t
�r"t
}q"q"W|jr]
gt||f
t|�
�D]!\}}tj|d|�

^q3
}	ntj||�}	x�t
t|�
�
D]�}|
|j}|
|j}|dkr�
d
}n|dkr�
d}nt|t�rtt	|�
�
}|dkr|
|j
|t
|d�
}qn|	||||	|<q�
W|jr�tjg
t|�
}
xOt
t|�
�
D]8}tdd�|
|<|	||
|	|<tj|
|<qjWn|	SWn�ttfk
r�


|
j}|
j
}|
j}|dkr�d
}nt|t�rpt	|�
}t|�
}|dkrE|
j
|t
|d�
}n|
j
|}tjd
|dt
�||Stj|||�Sn
XdS(Nii
g�?R$(tinttrangeRtsteptstarttNonet
isinstancetcomplexR(tabstfloattmathtceiltstopR0tzipR"Rtindicestnewaxistslicet
IndexErrort	TypeError(
R1tkeyR ttypR-R5R6t_xt_ttnntslobjR>tlength((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyt__getitem__�sp









	

	


	
)





	

D






	

	



%

	







	
	
	

	







cC`
stj
|
|�S(
N(R"R(R1t
it
j((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyt__getslice__�s
c


C`
sd
S(Ni((
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyt__len__�s
(t__name__t
__module__t__doc__tFalseR2RLRORP(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR/Ws
;	=	R0tAxisConcatenatorcB`
sGeZ
dZd
�Zdeddd�Zd�Zd�Zd�ZRS(	sw
    Translates slice objects to concatenation along an axis.

    For detailed documentation on usage, see `r_`.

    cC`
sg|jrB|
j
}t|
�
}
|d
krB|jrB|
j}
qBn|j|_|j|_d|_|
S(Ni
i(tmatrixRtmakemattcolt
Tt_axistaxist_matrix(R1trestoldndim((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyt_retval�s
	
	





	
ii
i����cC`
sC|
|_||_
|
|_||_d
|_||_||_dS(Ni(RZR\R[RVRXttrans1dtndmin(R1R[RVRaR`((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR2�s
	
	
	
	
	
	
c	C`
s�|j}|j
}t|
t�rOtj�j}tj|
|j	|j
�}|St|
t�sj|
f
}
ng}g}g}g}	x�tt
|
�
�
D]�}
t}t|
|
t�r�
|
|
j}|
|
j}
|
|
j}|
dkr�d
}
n|dkr
d}nt|t�rA
tt|�
�
}tj|
|d|�
}ntj|
||�}|dkrt|dtd|�
}|dkr�
|jd|�}q�
qnat|
|
t�r�|
d
kr�
td�
�
n|
d
}|dkrt|_|d	k|_q�nd
|kr�|j d
�
}yXg|d D]}t|�
^q,\|_!}t
|�
dkrrt|d�
}nw�Wq�


td
�
�
q�Xnyt|
|
�
|_!w�Wqtt"fk
r�


td
�
�
qXn0
t#|
|
�
t$kr$t|
|
d|�

}|j%|
�

t}|	j%|j&�

n�|
|
}|dkrt|dtdt�
}t|dtdtd|�
}|dkr�|j'|kr�||j'}|d
kr�||d7}nt(t|�
�
}|}|| |||||!}|j)|�
}n~n|j%|�

|r�t|tj*�r�|j%|j&�

q�q�Wt+||	�}|dk	r�x(|D]}
||
j,|�
||
<qaWntj-t|�
d|j!�

}|j.|�
S(Nii
tnumtcopyRai����s+special directives must be the first entry.trct
ct
,iisunknown special directivetsubokR[(/R`RaR8tstrtsyst	_getframetf_backRVtbmatt	f_globalstf_localsR)R4RRTRBR5R6R>R7R9R3R:RtlinspaceR"RRtswapaxesRtTrueRXtsplitR[RDttypeRR(R$Rtlistt	transposetndarrayR	R!tconcatenateR_(R1RER`Ratframetmymattobjstscalarst
arraytypestscalartypesR-tscalarR5R6R>R tnewobjtkey0tvect
xttempobjtk2tdefaxestk1taxestfinal_dtypeR]((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyRL�s�
	
	




















	

	












	




,




















	



















cC`
stj
|
|�}|j|�
S(
N(R"RR_(R1RMRNR]((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyROU
s

c


C`
sd
S(Ni((
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyRPY
s
(	RQRRRSR_RTR2RLRORP(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyRU�s			Z	tRClassc
B`
seZ
dZd
�ZRS(s�
    Translates slice objects to concatenation along the first axis.

    This is a simple way to build up arrays quickly. There are two use cases.

    1. If the index expression contains comma separated arrays, then stack
       them along their first axis.
    2. If the index expression contains slice notation or scalars then create
       a 1-D array with a range indicated by the slice notation.

    If slice notation is used, the syntax ``start:stop:step`` is equivalent
    to ``np.arange(start, stop, step)`` inside of the brackets. However, if
    ``step`` is an imaginary number (i.e. 100j) then its integer portion is
    interpreted as a number-of-points desired and the start and stop are
    inclusive. In other words ``start:stop:stepj`` is interpreted as
    ``np.linspace(start, stop, step, endpoint=1)`` inside of the brackets.
    After expansion of slice notation, all comma separated sequences are
    concatenated together.

    Optional character strings placed as the first element of the index
    expression can be used to change the output. The strings 'r' or 'c' result
    in matrix output. If the result is 1-D and 'r' is specified a 1 x N (row)
    matrix is produced. If the result is 1-D and 'c' is specified, then a N x 1
    (column) matrix is produced. If the result is 2-D then both provide the
    same matrix result.

    A string integer specifies which axis to stack multiple comma separated
    arrays along. A string of two comma-separated integers allows indication
    of the minimum number of dimensions to force each entry into as the
    second integer (the axis to concatenate along is still the first integer).

    A string with three comma-separated integers allows specification of the
    axis to concatenate along, the minimum number of dimensions to force the
    entries to, and which axis should contain the start of the arrays which
    are less than the specified number of dimensions. In other words the third
    integer allows you to specify where the 1's should be placed in the shape
    of the arrays that have their shapes upgraded. By default, they are placed
    in the front of the shape tuple. The third argument allows you to specify
    where the start of the array should be instead. Thus, a third argument of
    '0' would place the 1's at the end of the array shape. Negative integers
    specify where in the new shape tuple the last dimension of upgraded arrays
    should be placed, so the default is '-1'.

    Parameters
    ----------
    Not a function, so takes no parameters


    Returns
    -------
    A concatenated ndarray or matrix.

    See Also
    --------
    concatenate : Join a sequence of arrays along an existing axis.
    c_ : Translates slice objects to concatenation along the second axis.

    Examples
    --------
    >>> np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])]
    array([1, 2, 3, 0, 0, 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

C`
stj
|d
�
dS(Ni(RUR2(
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR2�
s
(RQRRRSR2(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR�`
s]tCClassc
B`
seZ
dZd
�ZRS(s"
    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).

    For detailed documentation, see `r_`.

    Examples
    --------
    >>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
    array([[1, 2, 3, 0, 0, 4, 5, 6]])

    c

C`
s tj
|d
dddd�
dS(Ni����RaiR`i(RUR2(
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR2�
s
(RQRRRSR2(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR��
sc
B`
s/eZ
dZd
�Zd�Zd�ZeZRS(s�

    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

    cC`
st|
�
j
|_dS(
N(Rtflattiter(R1tarr((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR2�
s
c

C`
s|jj
t|j�
fS(
s

        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�tcoordstnext(
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyt__next__�
sc


C`
s|S(
N((
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyt__iter__s
(RQRRRSR2R�R�R�(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR�
s
			c
B`
s8eZ
dZd
�Zd�Zd�Zd�ZeZRS(sU
    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
    ----------
    `*args` : ints
      The size of each dimension of the array.

    See Also
    --------
    ndenumerate, flatiter

    Examples
    --------
    >>> 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
G`
s�t|
�
d
kr2t
|
dt�r2|
d}
nttjd
�
d|
dtj|
�
�
}tj|dddgdd	�
|_dS(
Ni
itshapetstridestflagstmulti_indextzerosize_oktordert
C(	RR8R)RR"tzerost
zeros_liketnditert_it(R1R�R�((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR2+s
%





c


C`
s|S(
N((
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR�3s
c

C`
st|�

d
S(s�
        Increment the multi-dimensional index by one.

        This method is for backward compatibility only: do not use.
        N(
R�(
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pytndincr6sc

C`
st|j
�

|j
jS(
s�
        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�(
R1((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR�>s

(RQRRRSR2R�R�R�R�(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR
s				tIndexExpressionc
B`
s eZ
dZd
�Zd�ZRS(s�
    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])

    cC`
s
|
|_dS(
N(
t	maketuple(R1R�((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR2�s
cC`
s(|jr t
|
t�r |
f
S|
SdS(
N(R�R8R)(R1titem((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyRL�s

(RQRRRSR2RL(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR�[s*	R�cC`
s�|jd
krt
d�
�
nd}|jd
krh|jdd}|s�|jd|jd}q�nGtt|j�
dk�
s�t
d�
�
ndt|jd �
j�}|
|jd||�<dS(s�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, ..., 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
      Value to be written on the diagonal, its type must be compatible with
      that of the array a.

    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)
    >>> 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)
    >>> 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)
    >>> fill_diagonal(a, 4, wrap=True)
    >>> a
    array([[4, 0, 0, 0, 0],
           [0, 4, 0, 0, 0],
           [0, 0, 4, 0, 0]])

    isarray must be at least 2-di
is/All dimensions of input must be of equal lengthi����N(	RRR7R�RRRtsumR�(t
atvaltwraptendR5((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyR�s]





icC`
st|�
}|f
|
S(
s+
    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=np.int)
    >>> a[d3] = 1
    >>> a
    array([[[1, 0],
            [0, 0]],
           [[0, 0],
            [0, 1]]])

    (
R(t
nRtidx((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyRs@
c

C`
s_|jd
kst
d�
�
ntt|j�
dk�
sHt
d�
�
nt|jd|j�S(s

    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

    is input array must be at least 2-dis/All dimensions of input must be of equal length(RRRRR�R(
R�((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyROs


(6t
__future__RR
RRiR<tnumpy.core.numerictcoretnumericR"RRRRRRtnumpy.core.numerictypesR	R
tRtnumpy.matrixlibt	matrixlibRVRtnumpy.core.multiarrayR
Rtnumpy.lib.stride_tricksRRWt__all__RtobjectR/RTRRqRR7RSRUR�RR�RRRR�RRRRR(((sI/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/index_tricks.pyt<module>
sB

.



	

	;�

	
	�b		2N5
rD