golden hour

/opt/alt/python37/lib64/python3.7/site-packages/numpy/lib/__pycache__

File/Folder	Size	Actions
__init__.cpython-37.opt-1.pyc	1.15 KB
__init__.cpython-37.pyc	1.15 KB
_datasource.cpython-37.opt-1.pyc	18.63 KB
_datasource.cpython-37.pyc	18.63 KB
_iotools.cpython-37.opt-1.pyc	25.7 KB
_iotools.cpython-37.pyc	25.7 KB
_version.cpython-37.opt-1.pyc	4.74 KB
_version.cpython-37.pyc	4.74 KB
arraypad.cpython-37.opt-1.pyc	40.54 KB
arraypad.cpython-37.pyc	40.54 KB
arraysetops.cpython-37.opt-1.pyc	17.71 KB
arraysetops.cpython-37.pyc	17.71 KB
arrayterator.cpython-37.opt-1.pyc	7.01 KB
arrayterator.cpython-37.pyc	7.01 KB
financial.cpython-37.opt-1.pyc	22.62 KB
financial.cpython-37.pyc	22.62 KB
format.cpython-37.opt-1.pyc	22.42 KB
format.cpython-37.pyc	22.42 KB
function_base.cpython-37.opt-1.pyc	140.2 KB
function_base.cpython-37.pyc	140.2 KB
index_tricks.cpython-37.opt-1.pyc	23.71 KB
index_tricks.cpython-37.pyc	23.71 KB
info.cpython-37.opt-1.pyc	6.66 KB
info.cpython-37.pyc	6.66 KB
mixins.cpython-37.opt-1.pyc	7.21 KB
mixins.cpython-37.pyc	7.21 KB
nanfunctions.cpython-37.opt-1.pyc	45.42 KB
nanfunctions.cpython-37.pyc	45.42 KB
npyio.cpython-37.opt-1.pyc	56.75 KB
npyio.cpython-37.pyc	56.75 KB
polynomial.cpython-37.opt-1.pyc	35.31 KB
polynomial.cpython-37.pyc	35.31 KB
recfunctions.cpython-37.opt-1.pyc	28.42 KB
recfunctions.cpython-37.pyc	28.42 KB
scimath.cpython-37.opt-1.pyc	14.53 KB
scimath.cpython-37.pyc	14.53 KB
setup.cpython-37.opt-1.pyc	589 B
setup.cpython-37.pyc	589 B
shape_base.cpython-37.opt-1.pyc	25.19 KB
shape_base.cpython-37.pyc	25.19 KB
stride_tricks.cpython-37.opt-1.pyc	7.71 KB
stride_tricks.cpython-37.pyc	7.71 KB
twodim_base.cpython-37.opt-1.pyc	25.72 KB
twodim_base.cpython-37.pyc	25.72 KB
type_check.cpython-37.opt-1.pyc	15.65 KB
type_check.cpython-37.pyc	15.65 KB
ufunclike.cpython-37.opt-1.pyc	5.75 KB
ufunclike.cpython-37.pyc	5.75 KB
user_array.cpython-37.opt-1.pyc	11.19 KB
user_array.cpython-37.pyc	11.19 KB
utils.cpython-37.opt-1.pyc	27.23 KB
utils.cpython-37.pyc	27.23 KB

Edit: shape_base.cpython-37.opt-1.pyc

����<�Fd�k������������������@���s>��d�dl�mZmZmZ�d�dlZd�dlm��mZ�d�dlm	Z	m
Z
mZmZm
Z
mZmZ�d�dlmZmZmZ�d�dlmZ�d�dlmZmZ�d�dlmZ�d�dlmZ�d	d
ddd
dddddddddgZdd��Zdd��Zdd��Z eZ!dd	��Z"dd��Z#dd��Z$d(dd�Z%d)dd
�Z&d d��Z'd!d��Z(d"d��Z)d#d$��Z*d%d��Z+d&d��Z,d'd��Z-dS�)*�����)�division�absolute_import�print_functionN)�asarray�zeros�outer�concatenate�isscalar�array�
asanyarray)�product�reshape�	transpose)�normalize_axis_index)�vstack�
atleast_3d)�ndindex)�matrix�column_stack�	row_stack�dstack�array_split�split�hsplit�vsplit�dsplit�apply_over_axes�expand_dims�apply_along_axis�kron�tile�get_array_wrapc�������������O���s���t�|�}|j}t||�}tt|��}t||d|��||d�d���|g��}t|jdd���}dd��|D��}yt|�}	W�n�t	k
r����t
d��Y�nX�t�|�||	�f|�|��}
t|jdd��|
j�|
j�}tt|j��}|d|��||j|
j�|j���|||j|
j����}
t
|
t��s$|
�|�}|
||	<�x*|D�]"}t�|�||�f|�|��||<��q2W�t
|
t��sx|
�|�}t||
�S�t||
�}|
�|�S�dS�)ak��
    Apply a function to 1-D slices along the given axis.

Execute `func1d(a, *args)` where `func1d` operates on 1-D arrays and `a`
    is a 1-D slice of `arr` along `axis`.

Parameters
    ----------
    func1d : function
        This function should accept 1-D arrays. It is applied to 1-D
        slices of `arr` along the specified axis.
    axis : integer
        Axis along which `arr` is sliced.
    arr : ndarray
        Input array.
    args : any
        Additional arguments to `func1d`.
    kwargs : any
        Additional named arguments to `func1d`.

.. versionadded:: 1.9.0

Returns
    -------
    apply_along_axis : ndarray
        The output array. The shape of `outarr` is identical to the shape of
        `arr`, except along the `axis` dimension. This axis is removed, and
        replaced with new dimensions equal to the shape of the return value
        of `func1d`. So if `func1d` returns a scalar `outarr` will have one
        fewer dimensions than `arr`.

See Also
    --------
    apply_over_axes : Apply a function repeatedly over multiple axes.

Examples
    --------
    >>> def my_func(a):
    ...     """Average first and last element of a 1-D array"""
    ...     return (a[0] + a[-1]) * 0.5
    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
    >>> np.apply_along_axis(my_func, 0, b)
    array([ 4.,  5.,  6.])
    >>> np.apply_along_axis(my_func, 1, b)
    array([ 2.,  5.,  8.])

For a function that returns a 1D array, the number of dimensions in
    `outarr` is the same as `arr`.

>>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
    >>> np.apply_along_axis(sorted, 1, b)
    array([[1, 7, 8],
           [3, 4, 9],
           [2, 5, 6]])

For a function that returns a higher dimensional array, those dimensions
    are inserted in place of the `axis` dimension.

>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
    >>> np.apply_along_axis(np.diag, -1, b)
    array([[[1, 0, 0],
            [0, 2, 0],
            [0, 0, 3]],

[[4, 0, 0],
            [0, 5, 0],
            [0, 0, 6]],

[[7, 0, 0],
            [0, 8, 0],
            [0, 0, 9]]])
    N�������c�������������s���s���|�]}|t�f�V��qd�S�)N)�Ellipsis)�.0�ind��r'����G/opt/alt/python37/lib64/python3.7/site-packages/numpy/lib/shape_base.py�	<genexpr>m���s����z#apply_along_axis.<locals>.<genexpr>z;Cannot apply_along_axis when any iteration dimensions are 0r���)r����ndimr����list�ranger���r����shape�next�
StopIteration�
ValueErrorr����dtype�
isinstancer����__array_prepare__�__array_wrap__)Zfunc1d�axis�arr�args�kwargs�ndZin_dimsZ
inarr_viewZindsZind0�resZbuffZ	buff_dimsZbuff_permuter&���Zout_arrr'���r'���r(���r������s4����K
(

c�������������C���s����t�|�}|j}t|�jdkr"|f}xb|D�]Z}|dk�r<||�}||f}|�|��}|j|jkr^|}q(t||�}|j|jkrz|}q(td��q(W�|S�)az��
    Apply a function repeatedly over multiple axes.

`func` is called as `res = func(a, axis)`, where `axis` is the first
    element of `axes`.  The result `res` of the function call must have
    either the same dimensions as `a` or one less dimension.  If `res`
    has one less dimension than `a`, a dimension is inserted before
    `axis`.  The call to `func` is then repeated for each axis in `axes`,
    with `res` as the first argument.

Parameters
    ----------
    func : function
        This function must take two arguments, `func(a, axis)`.
    a : array_like
        Input array.
    axes : array_like
        Axes over which `func` is applied; the elements must be integers.

Returns
    -------
    apply_over_axis : ndarray
        The output array.  The number of dimensions is the same as `a`,
        but the shape can be different.  This depends on whether `func`
        changes the shape of its output with respect to its input.

See Also
    --------
    apply_along_axis :
        Apply a function to 1-D slices of an array along the given axis.

Notes
    ------
    This function is equivalent to tuple axis arguments to reorderable ufuncs
    with keepdims=True. Tuple axis arguments to ufuncs have been available since
    version 1.7.0.

Examples
    --------
    >>> a = np.arange(24).reshape(2,3,4)
    >>> a
    array([[[ 0,  1,  2,  3],
            [ 4,  5,  6,  7],
            [ 8,  9, 10, 11]],
           [[12, 13, 14, 15],
            [16, 17, 18, 19],
            [20, 21, 22, 23]]])

Sum over axes 0 and 2. The result has same number of dimensions
    as the original array:

>>> np.apply_over_axes(np.sum, a, [0,2])
    array([[[ 60],
            [ 92],
            [124]]])

Tuple axis arguments to ufuncs are equivalent:

>>> np.sum(a, axis=(0,2), keepdims=True)
    array([[[ 60],
            [ 92],
            [124]]])

r���z7function is not returning an array of the correct shape)r���r*���r
���r���r0���)�func�aZaxes�val�Nr5���r7���r:���r'���r'���r(���r�������s ����A

c�������������C���sp���t�|��}�|�j}||�jks(||�j�d�k�r8tjdtdd��|dk�rN||�j�d�}|��|d|��d�||d����S�)a���
    Expand the shape of an array.

Insert a new axis that will appear at the `axis` position in the expanded
    array shape.

.. note:: Previous to NumPy 1.13.0, neither ``axis < -a.ndim - 1`` nor
       ``axis > a.ndim`` raised errors or put the new axis where documented.
       Those axis values are now deprecated and will raise an AxisError in the
       future.

Parameters
    ----------
    a : array_like
        Input array.
    axis : int
        Position in the expanded axes where the new axis is placed.

Returns
    -------
    res : ndarray
        Output array. The number of dimensions is one greater than that of
        the input array.

See Also
    --------
    squeeze : The inverse operation, removing singleton dimensions
    reshape : Insert, remove, and combine dimensions, and resize existing ones
    doc.indexing, atleast_1d, atleast_2d, atleast_3d

Examples
    --------
    >>> x = np.array([1,2])
    >>> x.shape
    (2,)

The following is equivalent to ``x[np.newaxis,:]`` or ``x[np.newaxis]``:

>>> y = np.expand_dims(x, axis=0)
    >>> y
    array([[1, 2]])
    >>> y.shape
    (1, 2)

>>> y = np.expand_dims(x, axis=1)  # Equivalent to x[:,newaxis]
    >>> y
    array([[1],
           [2]])
    >>> y.shape
    (2, 1)

Note that some examples may use ``None`` instead of ``np.newaxis``.  These
    are the same objects:

>>> np.newaxis is None
    True

r"���zcBoth axis > a.ndim and axis < -a.ndim - 1 are deprecated and will raise an AxisError in the future.����)�
stacklevelr���N)r"���)r���r-���r*����warnings�warn�DeprecationWarningr
���)r<���r5���r-���r'���r'���r(���r�������s����;
c�������������C���sR���g�}x@|�D�]8}t�|ddd�}|jdk�r8t�|dddd�j}|�|��q
W�t�|d�S�)a���
    Stack 1-D arrays as columns into a 2-D array.

Take a sequence of 1-D arrays and stack them as columns
    to make a single 2-D array. 2-D arrays are stacked as-is,
    just like with `hstack`.  1-D arrays are turned into 2-D columns
    first.

Parameters
    ----------
    tup : sequence of 1-D or 2-D arrays.
        Arrays to stack. All of them must have the same first dimension.

Returns
    -------
    stacked : 2-D array
        The array formed by stacking the given arrays.

See Also
    --------
    hstack, vstack, concatenate

Examples
    --------
    >>> a = np.array((1,2,3))
    >>> b = np.array((2,3,4))
    >>> np.column_stack((a,b))
    array([[1, 2],
           [2, 3],
           [3, 4]])

FT)�copy�subokr?���)rD���rE����ndminr"���)r
���r*����T�append�_nxr���)�tupZarrays�vr6���r'���r'���r(���r���:��s����!

c�������������C���s���t��dd��|�D��d�S�)a���
    Stack arrays in sequence depth wise (along third axis).

Takes a sequence of arrays and stack them along the third axis
    to make a single array. Rebuilds arrays divided by `dsplit`.
    This is a simple way to stack 2D arrays (images) into a single
    3D array for processing.

This function continues to be supported for backward compatibility, but
    you should prefer ``np.concatenate`` or ``np.stack``. The ``np.stack``
    function was added in NumPy 1.10.

Parameters
    ----------
    tup : sequence of arrays
        Arrays to stack. All of them must have the same shape along all
        but the third axis.

Returns
    -------
    stacked : ndarray
        The array formed by stacking the given arrays.

See Also
    --------
    stack : Join a sequence of arrays along a new axis.
    vstack : Stack along first axis.
    hstack : Stack along second axis.
    concatenate : Join a sequence of arrays along an existing axis.
    dsplit : Split array along third axis.

Notes
    -----
    Equivalent to ``np.concatenate(tup, axis=2)`` if `tup` contains arrays that
    are at least 3-dimensional.

Examples
    --------
    >>> a = np.array((1,2,3))
    >>> b = np.array((2,3,4))
    >>> np.dstack((a,b))
    array([[[1, 2],
            [2, 3],
            [3, 4]]])

>>> a = np.array([[1],[2],[3]])
    >>> b = np.array([[2],[3],[4]])
    >>> np.dstack((a,b))
    array([[[1, 2]],
           [[2, 3]],
           [[3, 4]]])

c�������������S���s���g�|�]}t�|��qS�r'���)r���)r%����_mr'���r'���r(����
<listcomp>���s����zdstack.<locals>.<listcomp>r?���)rI���r���)rJ���r'���r'���r(���r���c��s����6c����������	���C���sz���xtt�t|���D�]d}t�|�|��dkr>tjd|�|�jd�|�|<�qt�t�t�|�|��d��rtjd|�|�jd�|�|<�qW�|�S�)Nr���)r1���)	r,����lenrI���r*����emptyr1���ZsometrueZequalr-���)�sub_arys�ir'���r'���r(����_replace_zero_by_x_arrays���s����rR���c�������������C���s��y|�j�|�}W�n�tk
r*���t|��}Y�nX�y$t|�d�}dgt|��|g�}W�nj�tk
r����t|�}|dkrxtd��t||�\}}dg||d�g��||�|g��}t�	|��
��}Y�nX�g�}	t�|�|d�}
x@t|�D�]4}||�}||d��}
|	�
t�|
||
��|d���q�W�|	S�)a��
    Split an array into multiple sub-arrays.

Please refer to the ``split`` documentation.  The only difference
    between these functions is that ``array_split`` allows
    `indices_or_sections` to be an integer that does *not* equally
    divide the axis.

See Also
    --------
    split : Split array into multiple sub-arrays of equal size.

Examples
    --------
    >>> x = np.arange(8.0)
    >>> np.array_split(x, 3)
        [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]

r"���r���z&number sections must be larger than 0.)r-����AttributeErrorrN���r+����	TypeError�intr0����divmodrI���r
���ZcumsumZswapaxesr,���rH���)�ary�indices_or_sectionsr5���ZNtotalZ	NsectionsZ
div_pointsZ
Neach_sectionZextrasZ
section_sizesrP���ZsaryrQ����st�endr'���r'���r(���r������s,���� c�������������C���sP���yt�|��W�n2�tk
r>���|}|�j|�}||�r:td��Y�nX�t|�||�}|S�)a���
    Split an array into multiple sub-arrays.

Parameters
    ----------
    ary : ndarray
        Array to be divided into sub-arrays.
    indices_or_sections : int or 1-D array
        If `indices_or_sections` is an integer, N, the array will be divided
        into N equal arrays along `axis`.  If such a split is not possible,
        an error is raised.

If `indices_or_sections` is a 1-D array of sorted integers, the entries
        indicate where along `axis` the array is split.  For example,
        ``[2, 3]`` would, for ``axis=0``, result in

- ary[:2]
          - ary[2:3]
          - ary[3:]

If an index exceeds the dimension of the array along `axis`,
        an empty sub-array is returned correspondingly.
    axis : int, optional
        The axis along which to split, default is 0.

Returns
    -------
    sub-arrays : list of ndarrays
        A list of sub-arrays.

Raises
    ------
    ValueError
        If `indices_or_sections` is given as an integer, but
        a split does not result in equal division.

See Also
    --------
    array_split : Split an array into multiple sub-arrays of equal or
                  near-equal size.  Does not raise an exception if
                  an equal division cannot be made.
    hsplit : Split array into multiple sub-arrays horizontally (column-wise).
    vsplit : Split array into multiple sub-arrays vertically (row wise).
    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
    concatenate : Join a sequence of arrays along an existing axis.
    stack : Join a sequence of arrays along a new axis.
    hstack : Stack arrays in sequence horizontally (column wise).
    vstack : Stack arrays in sequence vertically (row wise).
    dstack : Stack arrays in sequence depth wise (along third dimension).

Examples
    --------
    >>> x = np.arange(9.0)
    >>> np.split(x, 3)
    [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.,  8.])]

>>> x = np.arange(8.0)
    >>> np.split(x, [3, 5, 6, 10])
    [array([ 0.,  1.,  2.]),
     array([ 3.,  4.]),
     array([ 5.]),
     array([ 6.,  7.]),
     array([], dtype=float64)]

z0array split does not result in an equal division)rN���rT���r-���r0���r���)rW���rX���r5���Zsectionsr>���r:���r'���r'���r(���r������s����B
c�������������C���s<���t��|��dkrtd��|�jdkr,t|�|d�S�t|�|d�S�dS�)a���
    Split an array into multiple sub-arrays horizontally (column-wise).

Please refer to the `split` documentation.  `hsplit` is equivalent
    to `split` with ``axis=1``, the array is always split along the second
    axis regardless of the array dimension.

See Also
    --------
    split : Split an array into multiple sub-arrays of equal size.

Examples
    --------
    >>> x = np.arange(16.0).reshape(4, 4)
    >>> x
    array([[  0.,   1.,   2.,   3.],
           [  4.,   5.,   6.,   7.],
           [  8.,   9.,  10.,  11.],
           [ 12.,  13.,  14.,  15.]])
    >>> np.hsplit(x, 2)
    [array([[  0.,   1.],
           [  4.,   5.],
           [  8.,   9.],
           [ 12.,  13.]]),
     array([[  2.,   3.],
           [  6.,   7.],
           [ 10.,  11.],
           [ 14.,  15.]])]
    >>> np.hsplit(x, np.array([3, 6]))
    [array([[  0.,   1.,   2.],
           [  4.,   5.,   6.],
           [  8.,   9.,  10.],
           [ 12.,  13.,  14.]]),
     array([[  3.],
           [  7.],
           [ 11.],
           [ 15.]]),
     array([], dtype=float64)]

With a higher dimensional array the split is still along the second axis.

>>> x = np.arange(8.0).reshape(2, 2, 2)
    >>> x
    array([[[ 0.,  1.],
            [ 2.,  3.]],
           [[ 4.,  5.],
            [ 6.,  7.]]])
    >>> np.hsplit(x, 2)
    [array([[[ 0.,  1.]],
           [[ 4.,  5.]]]),
     array([[[ 2.,  3.]],
           [[ 6.,  7.]]])]

r���z3hsplit only works on arrays of 1 or more dimensionsr"���N)rI���r*���r0���r���)rW���rX���r'���r'���r(���r���!��s
����7
c�������������C���s"���t��|��dk�rtd��t|�|d�S�)aI��
    Split an array into multiple sub-arrays vertically (row-wise).

Please refer to the ``split`` documentation.  ``vsplit`` is equivalent
    to ``split`` with `axis=0` (default), the array is always split along the
    first axis regardless of the array dimension.

See Also
    --------
    split : Split an array into multiple sub-arrays of equal size.

Examples
    --------
    >>> x = np.arange(16.0).reshape(4, 4)
    >>> x
    array([[  0.,   1.,   2.,   3.],
           [  4.,   5.,   6.,   7.],
           [  8.,   9.,  10.,  11.],
           [ 12.,  13.,  14.,  15.]])
    >>> np.vsplit(x, 2)
    [array([[ 0.,  1.,  2.,  3.],
           [ 4.,  5.,  6.,  7.]]),
     array([[  8.,   9.,  10.,  11.],
           [ 12.,  13.,  14.,  15.]])]
    >>> np.vsplit(x, np.array([3, 6]))
    [array([[  0.,   1.,   2.,   3.],
           [  4.,   5.,   6.,   7.],
           [  8.,   9.,  10.,  11.]]),
     array([[ 12.,  13.,  14.,  15.]]),
     array([], dtype=float64)]

With a higher dimensional array the split is still along the first axis.

>>> x = np.arange(8.0).reshape(2, 2, 2)
    >>> x
    array([[[ 0.,  1.],
            [ 2.,  3.]],
           [[ 4.,  5.],
            [ 6.,  7.]]])
    >>> np.vsplit(x, 2)
    [array([[[ 0.,  1.],
            [ 2.,  3.]]]),
     array([[[ 4.,  5.],
            [ 6.,  7.]]])]

r?���z3vsplit only works on arrays of 2 or more dimensionsr���)rI���r*���r0���r���)rW���rX���r'���r'���r(���r���_��s����/c�������������C���s"���t��|��dk�rtd��t|�|d�S�)a��
    Split array into multiple sub-arrays along the 3rd axis (depth).

Please refer to the `split` documentation.  `dsplit` is equivalent
    to `split` with ``axis=2``, the array is always split along the third
    axis provided the array dimension is greater than or equal to 3.

See Also
    --------
    split : Split an array into multiple sub-arrays of equal size.

Examples
    --------
    >>> x = np.arange(16.0).reshape(2, 2, 4)
    >>> x
    array([[[  0.,   1.,   2.,   3.],
            [  4.,   5.,   6.,   7.]],
           [[  8.,   9.,  10.,  11.],
            [ 12.,  13.,  14.,  15.]]])
    >>> np.dsplit(x, 2)
    [array([[[  0.,   1.],
            [  4.,   5.]],
           [[  8.,   9.],
            [ 12.,  13.]]]),
     array([[[  2.,   3.],
            [  6.,   7.]],
           [[ 10.,  11.],
            [ 14.,  15.]]])]
    >>> np.dsplit(x, np.array([3, 6]))
    [array([[[  0.,   1.,   2.],
            [  4.,   5.,   6.]],
           [[  8.,   9.,  10.],
            [ 12.,  13.,  14.]]]),
     array([[[  3.],
            [  7.]],
           [[ 11.],
            [ 15.]]]),
     array([], dtype=float64)]

����z3dsplit only works on arrays of 3 or more dimensionsr?���)rI���r*���r0���r���)rW���rX���r'���r'���r(���r������s����)c��������������G���s*���t�dd��t|��D���}|r&|d�d�S�dS�)z�Find the wrapper for the array with the highest priority.

In case of ties, leftmost wins. If no wrapper is found, return None
    c�������������s���s2���|�]*\}}t�|d��rt|dd�|�|jfV��qdS�)r3����__array_priority__r���N)�hasattr�getattrr3���)r%���rQ����xr'���r'���r(���r)������s���z$get_array_prepare.<locals>.<genexpr>r#���N)�sorted�	enumerate)r7����wrappersr'���r'���r(����get_array_prepare���s
����rc���c��������������G���s*���t�dd��t|��D���}|r&|d�d�S�dS�)z�Find the wrapper for the array with the highest priority.

In case of ties, leftmost wins. If no wrapper is found, return None
    c�������������s���s2���|�]*\}}t�|d��rt|dd�|�|jfV��qdS�)r4���r\���r���N)r]���r^���r4���)r%���rQ���r_���r'���r'���r(���r)������s���z!get_array_wrap.<locals>.<genexpr>r#���N)r`���ra���)r7���rb���r'���r'���r(���r!������s
����c�������������C���s$��t�|�}t|�dd|jd�}�|j|�j�}}|dks8|dkrDt�|�|�S�|�j}|j}|�jjsbt|�|�}�|jjstt||�}|}||kr�||kr�d||��|�}nd||��|�}|}t	|�|��||��}|d�}xt
|�D�]}	t||d�}q�W�t|�|�}
|
dk	�r|
|�}t
|�|�}
|
dk	�r |
|�}|S�)	a��
    Kronecker product of two arrays.

Computes the Kronecker product, a composite array made of blocks of the
    second array scaled by the first.

Parameters
    ----------
    a, b : array_like

Returns
    -------
    out : ndarray

See Also
    --------
    outer : The outer product

Notes
    -----
    The function assumes that the number of dimensions of `a` and `b`
    are the same, if necessary prepending the smallest with ones.
    If `a.shape = (r0,r1,..,rN)` and `b.shape = (s0,s1,...,sN)`,
    the Kronecker product has shape `(r0*s0, r1*s1, ..., rN*SN)`.
    The elements are products of elements from `a` and `b`, organized
    explicitly by::

kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]

where::

kt = it * st + jt,  t = 0,...,N

In the common 2-D case (N=1), the block structure can be visualized::

[[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
         [  ...                              ...   ],
         [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]

Examples
    --------
    >>> np.kron([1,10,100], [5,6,7])
    array([  5,   6,   7,  50,  60,  70, 500, 600, 700])
    >>> np.kron([5,6,7], [1,10,100])
    array([  5,  50, 500,   6,  60, 600,   7,  70, 700])

>>> np.kron(np.eye(2), np.ones((2,2)))
    array([[ 1.,  1.,  0.,  0.],
           [ 1.,  1.,  0.,  0.],
           [ 0.,  0.,  1.,  1.],
           [ 0.,  0.,  1.,  1.]])

>>> a = np.arange(100).reshape((2,5,2,5))
    >>> b = np.arange(24).reshape((2,3,4))
    >>> c = np.kron(a,b)
    >>> c.shape
    (2, 10, 6, 20)
    >>> I = (1,3,0,2)
    >>> J = (0,2,1)
    >>> J1 = (0,) + J             # extend to ndim=4
    >>> S1 = (1,) + b.shape
    >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
    >>> c[K] == a[I]*b[J]
    True

FT)rD���rE���rF���r���)r"���r"���)r5���N)r���r
���r*���rI���Zmultiplyr-����flags�
contiguousr
���r���r,���r���rc���r!���)r<����bZndbZndaZas_Zbsr9����resultr5����_�wrapperr'���r'���r(���r������s8����D

c�������	������C���s����yt�|�}W�n�tk
r&���|f}Y�nX�t|�}tdd��|D���r`t|�tj�r`tj|�dd|d�S�tj|�dd|d�}||jk�r�d|j|��|�}t�dd��t	|j
|�D���}|j}|dkr�x<t	|j
|�D�],\}}|d	kr�|�d
|��
|d�}||�}q�W�|�|�S�)a��
    Construct an array by repeating A the number of times given by reps.

If `reps` has length ``d``, the result will have dimension of
    ``max(d, A.ndim)``.

If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new
    axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
    or shape (1, 1, 3) for 3-D replication. If this is not the desired
    behavior, promote `A` to d-dimensions manually before calling this
    function.

If ``A.ndim > d``, `reps` is promoted to `A`.ndim by pre-pending 1's to it.
    Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
    (1, 1, 2, 2).

Note : Although tile may be used for broadcasting, it is strongly
    recommended to use numpy's broadcasting operations and functions.

Parameters
    ----------
    A : array_like
        The input array.
    reps : array_like
        The number of repetitions of `A` along each axis.

Returns
    -------
    c : ndarray
        The tiled output array.

See Also
    --------
    repeat : Repeat elements of an array.
    broadcast_to : Broadcast an array to a new shape

Examples
    --------
    >>> a = np.array([0, 1, 2])
    >>> np.tile(a, 2)
    array([0, 1, 2, 0, 1, 2])
    >>> np.tile(a, (2, 2))
    array([[0, 1, 2, 0, 1, 2],
           [0, 1, 2, 0, 1, 2]])
    >>> np.tile(a, (2, 1, 2))
    array([[[0, 1, 2, 0, 1, 2]],
           [[0, 1, 2, 0, 1, 2]]])

>>> b = np.array([[1, 2], [3, 4]])
    >>> np.tile(b, 2)
    array([[1, 2, 1, 2],
           [3, 4, 3, 4]])
    >>> np.tile(b, (2, 1))
    array([[1, 2],
           [3, 4],
           [1, 2],
           [3, 4]])

>>> c = np.array([1,2,3,4])
    >>> np.tile(c,(4,1))
    array([[1, 2, 3, 4],
           [1, 2, 3, 4],
           [1, 2, 3, 4],
           [1, 2, 3, 4]])
    c�������������s���s���|�]}|d�kV��qdS�)r"���Nr'���)r%���r_���r'���r'���r(���r)������s����ztile.<locals>.<genexpr>T)rD���rE���rF���F)r"���c�������������s���s���|�]\}}||�V��qd�S�)Nr'���)r%����s�tr'���r'���r(���r)������s����r���r"���r#���)�tuplerT���rN����allr2���rI���Zndarrayr
���r*����zipr-����sizer
����repeat)	�AZrepsrJ����d�cZ	shape_out�nZdim_inZnrepr'���r'���r(���r ���:��s$����B
)r���)r���).Z
__future__r���r���r���rA���Znumpy.core.numericZcoreZnumericrI���r���r���r���r���r	���r
���r���Znumpy.core.fromnumericr���r
���r���Znumpy.core.multiarrayr���Z
numpy.corer���r���Znumpy.lib.index_tricksr���Znumpy.matrixlib.defmatrixr����__all__r���r���r���r���r���r���rR���r���r���r���r���r���rc���r!���r���r ���r'���r'���r'���r(����<module>���s8���$

�UI)8
1
M>3-c