Ñò
\ÐKc @ sE d d d d d d d d d d d
d d d
g Z d d k i i Z d d k l Z l Z l Z l Z l Z l
Z
l Z l Z d d k
l Z l Z d d k l Z l Z l Z d „ Z d „ Z d „ Z e Z d „ Z d „ Z d „ Z d d „ Z d d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z! d! „ Z" d" „ Z# d S(# t column_stackt row_stackt dstackt array_splitt splitt hsplitt vsplitt dsplitt apply_over_axest expand_dimst apply_along_axist kront tilet get_array_wrapiÿÿÿÿN( t asarrayt zerost newaxist outert concatenatet isscalart arrayt
asanyarray( t productt reshape( t hstackt vstackt
atleast_3dc G s= t | ƒ } | i } | d j o | | 7} n | | j o t d | | f ƒ ‚ n d g | d } t | d ƒ } t | ƒ } | i | ƒ t d d ƒ | | >> 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 doesn't return a scalar, the number of dimensions in
`outarr` is the same as `arr`.
>>> def new_func(a):
... """Divide elements of a by 2."""
... return a * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> np.apply_along_axis(new_func, 0, b)
array([[ 0.5, 1. , 1.5],
[ 2. , 2.5, 3. ],
[ 3.5, 4. , 4.5]])
i s2 axis must be less than arr.ndim; axis=%d, rank=%d.i t OiÿÿÿÿN( R t ndimt
ValueErrorR t ranget removet slicet Nonet shapet taket putt tuplet tolistR t dtypeR t listt len( t func1dt axist arrt argst ndt indt it indlistt outshapet rest outarrt Ntott kt nt holdshape( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR
sn 7
&
&
c C sÒ t | ƒ } | i } t | ƒ i d j o
| f } n x“ | D]‹ } | d j o | | } n | | f } | | Œ } | i | i j o
| } q? t | | ƒ } | i | i j o
| } q? t d ‚ q? W| S( s
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 : ndarray
Input array.
axes : array_like
Axes over which `func` is applied, the elements must be
integers.
Returns
-------
val : 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.
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]]])
i s3 function is not returning an array of correct shape( R R R R R ( t funct at axest valt NR+ R- R3 ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR { s" 5
c C sW t | ƒ } | i } | d j o | t | ƒ d } n | i | | d | | ƒ S( s
Expand the shape of an array.
Insert a new axis, corresponding to a given position in the array shape.
Parameters
----------
a : array_like
Input array.
axis : int
Position (amongst axes) where new axis is to be inserted.
Returns
-------
res : ndarray
Output array. The number of dimensions is one greater than that of
the input array.
See Also
--------
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
i i ( i ( R R" R) R ( R: R+ R" ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR Ã s
3
c C s g } xh | D]` } t | d t d t ƒ} | i d j o% t | d t d t d d ƒi } n | i | ƒ q
Wt i | d ƒ S( s5
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
Notes
-----
This function is equivalent to ``np.vstack(tup).T``.
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]])
t copyt suboki t ndmini ( R t Falset TrueR t Tt appendt _nxR ( t tupt arrayst vR, ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR þ s % %c C s t i t t | ƒ d ƒ S( sv
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.
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
--------
vstack : Stack along first axis.
hstack : Stack along second axis.
concatenate : Join arrays.
dsplit : Split array along third axis.
Notes
-----
Equivalent to ``np.concatenate(tup, axis=2)``
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]]])
i ( RE R t mapR ( RF ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR + s 0c C s˜ x‘ t t | ƒ ƒ D]} } t t i | | ƒ ƒ d j o t i g ƒ | | >> x = np.arange(8.0)
>>> np.array_split(x, 3)
[array([ 0., 1., 2.]), array([ 3., 4., 5.]), array([ 6., 7.])]
i i s& number sections must be larger than 0.( R" t AttributeErrorR) R( t TypeErrort intR t divmodRE R t cumsumt swapaxesR RD RM ( t aryt indices_or_sectionsR+ t Ntotalt Nsectionst
div_pointst
Neach_sectiont extrast
section_sizesRL t saryR0 t stt end( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR e s0
' c C se y t | ƒ Wn> t j
o2 | } | i | } | | o
t d ‚ qO n Xt | | | ƒ } | S( sK
Split an array into multiple sub-arrays of equal size.
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 arrays together.
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)]
s0 array split does not result in an equal division( R) RO R" R R ( RT RU R+ t sectionsR= R3 ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR ˜ s A
c C sd t t i | ƒ ƒ d j o
t d ‚ n t | i ƒ d j o t | | d ƒ St | | d ƒ Sd S( s¸
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.]]])]
i s3 hsplit only works on arrays of 1 or more dimensionsi N( R) RE R" R R ( RT RU ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR â s
7
c C s9 t t i | ƒ ƒ d j o
t d ‚ n t | | d ƒ S( sI
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.]]])]
i s3 vsplit only works on arrays of 2 or more dimensionsi ( R) RE R" R R ( RT RU ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR s /
c C s9 t t i | ƒ ƒ d j o
t d ‚ n t | | d ƒ S( sƒ
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)]
i s3 vsplit only works on arrays of 3 or more dimensionsi ( R) RE R" R R ( RT RU ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR S s )
c G s| g } t | ƒ D]@ \ } } t | d ƒ o$ | t | d d ƒ | | i f q q ~ } | i ƒ | o
| d d Sd S( s‡ Find the wrapper for the array with the highest priority.
In case of ties, leftmost wins. If no wrapper is found, return None
t __array_prepare__t __array_priority__i iÿÿÿÿN( t enumeratet hasattrt getattrR` t sortR! ( R- t _[1]R0 t xt wrappers( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyt get_array_prepare€ s =
c G s| g } t | ƒ D]@ \ } } t | d ƒ o$ | t | d d ƒ | | i f q q ~ } | i ƒ | o
| d d Sd S( s‡ Find the wrapper for the array with the highest priority.
In case of ties, leftmost wins. If no wrapper is found, return None
t __array_wrap__Ra i iÿÿÿÿN( Rb Rc Rd Rj Re R! ( R- Rf R0 Rg Rh ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR
s =
c C sº t | ƒ } t | d t d t d | i ƒ} | i | i } } | d j p
| d j o t i | | ƒ S| i } | i } | i i p t
| | ƒ } n | i i p t
| | ƒ } n | } | | j o? | | j o d | | | } qd | | | } | } n t | | ƒ i
| | ƒ } | d } x& t | ƒ D] } t
| d | ƒ} qBWt | | ƒ }
|
d j o |
| ƒ } n t | | ƒ }
|
d j o |
| ƒ } n | S(
s
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 dimenensions 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
R> R? R@ i i R+ ( i ( i N( R R RA RB R RE t multiplyR" t flagst
contiguousR R t xrangeR Ri R! R
( R: t bt ndbt ndat as_t bsR. t resultR+ t _t wrapper( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR š s: F !
c C s0 y t | ƒ } Wn t j
o | f } n Xt | ƒ } t i | d t d t d | ƒ} t | i ƒ } t | i
d ƒ } | | i j o d | i | | } n xz t | ƒ D]l \ } } | d j o" | i
d | ƒ i | d ƒ } n | | } | | }
|
| | <| t | d ƒ :} q³ W| i
| ƒ S( sº
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).
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.
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]])
R> R? R@ i iÿÿÿÿi ( i ( R% RO R) RE R RA RB R( R" t maxt sizeR Rb R t repeat( t At repsRF t dt cR" R7 R0 t nrept dim_int dim_out( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyR ÿ s& 8 !
"
($ t __all__t numpy.core.numerict coret numericRE R R R R R R R R t numpy.core.fromnumericR R t
numpy.coreR R R R
R R R R R RM R R R R R Ri R
R R ( ( ( s: /usr/lib64/python2.6/site-packages/numpy/lib/shape_base.pyt s, : p H 9 - 2 3 J > 3 -
e