Your IP : 216.73.216.213
(��^�k � @ s� d d l m Z m Z m Z d d l Z d d l j j Z d d l m Z m
Z
m Z m Z m
Z
m Z m Z d d l m Z m Z m Z d d l m Z d d l m Z m Z d d l m Z d d l m Z d d
d d d
d d d d d d d d d g Z d d � Z d d � Z d d � Z e Z! d d � Z" d d � Z# d d � Z$ d d d � Z% d d d
� Z& d d � Z' d! d � Z( d" d � Z) d# d$ � Z* d% d � Z+ d& d � Z, d' d � Z- d S)(� )�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 | | � } t t | � � } t | | d | � | | d d � | g � } t | j d d � � } d d � | D� } y t | � } Wn t k
r� t
d � � Yn Xt | | | | | � � }
t | j d d � |
j |
j � } t t | j � � } | d | � | | j |
j | j � | | | j |
j � }
t
|
t � s}|
j | � } |
| | <x. | D]& } t | | | | | � � | | <q�Wt
|
t � s�|
j | � } t | |
� St | |
� } |
j | � Sd S) 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 Vq d S)N)�Ellipsis)�.0�ind� r& �G/opt/alt/python35/lib64/python3.5/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) )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_dimsZ buff_permuter% Zout_arrr& r& r' r s4 K 2
&(
$
c C s� t | � } | j } t | � j d k r3 | f } x� | D]� } | d k rV | | } | | f } | | � } | j | j k r� | } q: t | | � } | j | j k r� | } q: t d � � 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 s� t | � } | j } | | j k s8 | | j d k rN t j d t d d �| d k rk | | j d } | j | 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.�
stacklevel� r N)r" )r r- r* �warnings�warn�DeprecationWarningr
)r< r5 r- r& r& r' r � s ; #
c C s| g } xc | D][ } t | d d d d �} | j d k r[ t | d d d d d d �j } | j | � q
Wt j | 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]])
�copyF�subokTr@ �ndminr" )r
r* �T�append�_nxr )�tupZarrays�vr6 r& r& r' r : s !
!c C s t j d d � | 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 | � � q Sr& )r )r$ �_mr& r& r' �
<listcomp>� s zdstack.<locals>.<listcomp>r@ )rI r )rJ r& r& r' r c s 6c C s� x� t t | � � D]� } t j | | � d k rU t j d d | | j �| | <q t j t j t j | | � d � � r t j d d | | j �| | <q W| S)Nr r1 ) r, �lenrI r* �emptyr1 Zsometrue�equalr- )�sub_arys�ir& r& r' �_replace_zero_by_x_arrays� s #($rS c C s^ y | j | } Wn t k
r1 t | � } Yn Xy. t | � d } d g t | � | g } Wn� t k
r� t | � } | d k r� t d � � t | | � \ } } d g | | d g | | | g } t j | � j
� } Yn Xg } t j | | d � }
xR t | � D]D } | | } | | d }
| j
t j |
| |
� | d � � qW| 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_section�extrasZ
section_sizesrQ ZsaryrR �st�endr& r& r' r � s,
*c C sb y t | � Wn; t k
rK | } | j | } | | rG t d � � Yn Xt | | | � } | 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 rU r- r0 r )rX rY r5 �sectionsr> r: r& r& r' r � s B
c C sT t j | � d k r! t d � � | j d k r@ t | | d � St | | d � Sd S)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 )rX rY r& r& r' r ! s
7 c C s1 t j | � d k r! t d � � 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 )rX rY r& r& r' r _ s / c C s1 t j | � d k r! t d � � 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 )rX rY r& r& r' r � s ) c G s5 t d d � t | � D� � } | r1 | d d Sd S)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 sC | ]9 \ } } t | d � r t | d d � | | j f Vq d S)r3 �__array_priority__r N)�hasattr�getattrr3 )r$ rR �xr& r& r' r( � s z$get_array_prepare.<locals>.<genexpr>r" Nr) r) )�sorted� enumerate)r7 �wrappersr& r& r' �get_array_prepare� s
rf c G s5 t d d � t | � D� � } | r1 | d d Sd S)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 sC | ]9 \ } } t | d � r t | d d � | | j f Vq d S)r4 r_ r N)r` ra r4 )r$ rR rb r& r& r' r( � s z!get_array_wrap.<locals>.<genexpr>r" Nr) r) )rc rd )r7 re r& r& r' r! � s
c C s� t | � } t | d d d d d | j �} | j | j } } | d k sX | d k rh t j | | � S| j } | j } | j j s� t | | � } | j j s� t | | � } | } | | k r� | | k r� d
| | | } n d | | | } | } t | | � j | | � } | d } x& t
| � D] } t | d | �} q.Wt | | � }
|
d k rq|
| � } t
| | � }
|
d k 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
rD FrE TrF r r" r5 N)r" )r" )r r
r* rI �multiplyr- �flags�
contiguousr
r r, r rf r! ) r< �bZndbZndaZas_�bsr9 �resultr5 �_�wrapperr& r& r' r � s8 D !
c C sg y t | � } Wn t k
r- | f } Yn Xt | � } t d d � | D� � r� t | t j � r� t j | d d d d d | �St j | d d d d d | �} | | j k r� d | j | | } t d d � t | j
| � D� � } | j } | d
k rZxT t | j
| � D]@ \ } } | d k rL| j d | � j
| d
� } | | } qW| j | � 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 k Vq d S)r" Nr& )r$ rb r& r& r' r( � s ztile.<locals>.<genexpr>rD TrE rF Fr" c s s | ] \ } } | | Vq d S)Nr& )r$ �s�tr& r& r' r( � s r )r" r) )�tuplerU rN �allr2 rI Zndarrayr
r* �zipr- �sizer
�repeat) �A�repsrJ �d�cZ shape_out�nZdim_inZnrepr& r& r' r : s$ B
+ !% ).�
__future__r r r rA Znumpy.core.numeric�core�numericrI 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 rS r r r r r rf r! r r r& r& r& r' �<module> s6 4 � U I ) 8 1M > 3 - c