272 lines
6.5 KiB
Python
272 lines
6.5 KiB
Python
__all__ = ['atleast_1d','atleast_2d','atleast_3d','vstack','hstack']
|
|
|
|
import numeric as _nx
|
|
from numeric import array, asanyarray, newaxis
|
|
|
|
def atleast_1d(*arys):
|
|
"""
|
|
Convert inputs to arrays with at least one dimension.
|
|
|
|
Scalar inputs are converted to 1-dimensional arrays, whilst
|
|
higher-dimensional inputs are preserved.
|
|
|
|
Parameters
|
|
----------
|
|
array1, array2, ... : array_like
|
|
One or more input arrays.
|
|
|
|
Returns
|
|
-------
|
|
ret : ndarray
|
|
An array, or sequence of arrays, each with ``a.ndim >= 1``.
|
|
Copies are made only if necessary.
|
|
|
|
See Also
|
|
--------
|
|
atleast_2d, atleast_3d
|
|
|
|
Examples
|
|
--------
|
|
>>> np.atleast_1d(1.0)
|
|
array([ 1.])
|
|
|
|
>>> x = np.arange(9.0).reshape(3,3)
|
|
>>> np.atleast_1d(x)
|
|
array([[ 0., 1., 2.],
|
|
[ 3., 4., 5.],
|
|
[ 6., 7., 8.]])
|
|
>>> np.atleast_1d(x) is x
|
|
True
|
|
|
|
>>> np.atleast_1d(1, [3, 4])
|
|
[array([1]), array([3, 4])]
|
|
|
|
"""
|
|
res = []
|
|
for ary in arys:
|
|
ary = asanyarray(ary)
|
|
if len(ary.shape) == 0 :
|
|
result = ary.reshape(1)
|
|
else :
|
|
result = ary
|
|
res.append(result)
|
|
if len(res) == 1:
|
|
return res[0]
|
|
else:
|
|
return res
|
|
|
|
def atleast_2d(*arys):
|
|
"""
|
|
View inputs as arrays with at least two dimensions.
|
|
|
|
Parameters
|
|
----------
|
|
array1, array2, ... : array_like
|
|
One or more array-like sequences. Non-array inputs are converted
|
|
to arrays. Arrays that already have two or more dimensions are
|
|
preserved.
|
|
|
|
Returns
|
|
-------
|
|
res, res2, ... : ndarray
|
|
An array, or tuple of arrays, each with ``a.ndim >= 2``.
|
|
Copies are avoided where possible, and views with two or more
|
|
dimensions are returned.
|
|
|
|
See Also
|
|
--------
|
|
atleast_1d, atleast_3d
|
|
|
|
Examples
|
|
--------
|
|
>>> np.atleast_2d(3.0)
|
|
array([[ 3.]])
|
|
|
|
>>> x = np.arange(3.0)
|
|
>>> np.atleast_2d(x)
|
|
array([[ 0., 1., 2.]])
|
|
>>> np.atleast_2d(x).base is x
|
|
True
|
|
|
|
>>> np.atleast_2d(1, [1, 2], [[1, 2]])
|
|
[array([[1]]), array([[1, 2]]), array([[1, 2]])]
|
|
|
|
"""
|
|
res = []
|
|
for ary in arys:
|
|
ary = asanyarray(ary)
|
|
if len(ary.shape) == 0 :
|
|
result = ary.reshape(1, 1)
|
|
elif len(ary.shape) == 1 :
|
|
result = ary[newaxis, :]
|
|
else :
|
|
result = ary
|
|
res.append(result)
|
|
if len(res) == 1:
|
|
return res[0]
|
|
else:
|
|
return res
|
|
|
|
def atleast_3d(*arys):
|
|
"""
|
|
View inputs as arrays with at least three dimensions.
|
|
|
|
Parameters
|
|
----------
|
|
array1, array2, ... : array_like
|
|
One or more array-like sequences. Non-array inputs are converted to
|
|
arrays. Arrays that already have three or more dimensions are
|
|
preserved.
|
|
|
|
Returns
|
|
-------
|
|
res1, res2, ... : ndarray
|
|
An array, or tuple of arrays, each with ``a.ndim >= 3``. Copies are
|
|
avoided where possible, and views with three or more dimensions are
|
|
returned. For example, a 1-D array of shape ``(N,)`` becomes a view
|
|
of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
|
|
view of shape ``(M, N, 1)``.
|
|
|
|
See Also
|
|
--------
|
|
atleast_1d, atleast_2d
|
|
|
|
Examples
|
|
--------
|
|
>>> np.atleast_3d(3.0)
|
|
array([[[ 3.]]])
|
|
|
|
>>> x = np.arange(3.0)
|
|
>>> np.atleast_3d(x).shape
|
|
(1, 3, 1)
|
|
|
|
>>> x = np.arange(12.0).reshape(4,3)
|
|
>>> np.atleast_3d(x).shape
|
|
(4, 3, 1)
|
|
>>> np.atleast_3d(x).base is x
|
|
True
|
|
|
|
>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
|
|
... print arr, arr.shape
|
|
...
|
|
[[[1]
|
|
[2]]] (1, 2, 1)
|
|
[[[1]
|
|
[2]]] (1, 2, 1)
|
|
[[[1 2]]] (1, 1, 2)
|
|
|
|
"""
|
|
res = []
|
|
for ary in arys:
|
|
ary = asanyarray(ary)
|
|
if len(ary.shape) == 0:
|
|
result = ary.reshape(1,1,1)
|
|
elif len(ary.shape) == 1:
|
|
result = ary[newaxis,:,newaxis]
|
|
elif len(ary.shape) == 2:
|
|
result = ary[:,:,newaxis]
|
|
else:
|
|
result = ary
|
|
res.append(result)
|
|
if len(res) == 1:
|
|
return res[0]
|
|
else:
|
|
return res
|
|
|
|
|
|
def vstack(tup):
|
|
"""
|
|
Stack arrays in sequence vertically (row wise).
|
|
|
|
Take a sequence of arrays and stack them vertically to make a single
|
|
array. Rebuild arrays divided by `vsplit`.
|
|
|
|
Parameters
|
|
----------
|
|
tup : sequence of ndarrays
|
|
Tuple containing arrays to be stacked. The arrays must have the same
|
|
shape along all but the first axis.
|
|
|
|
Returns
|
|
-------
|
|
stacked : ndarray
|
|
The array formed by stacking the given arrays.
|
|
|
|
See Also
|
|
--------
|
|
hstack : Stack arrays in sequence horizontally (column wise).
|
|
dstack : Stack arrays in sequence depth wise (along third dimension).
|
|
concatenate : Join a sequence of arrays together.
|
|
vsplit : Split array into a list of multiple sub-arrays vertically.
|
|
|
|
Notes
|
|
-----
|
|
Equivalent to ``np.concatenate(tup, axis=0)`` if `tup` contains arrays that
|
|
are at least 2-dimensional.
|
|
|
|
Examples
|
|
--------
|
|
>>> a = np.array([1, 2, 3])
|
|
>>> b = np.array([2, 3, 4])
|
|
>>> np.vstack((a,b))
|
|
array([[1, 2, 3],
|
|
[2, 3, 4]])
|
|
|
|
>>> a = np.array([[1], [2], [3]])
|
|
>>> b = np.array([[2], [3], [4]])
|
|
>>> np.vstack((a,b))
|
|
array([[1],
|
|
[2],
|
|
[3],
|
|
[2],
|
|
[3],
|
|
[4]])
|
|
|
|
"""
|
|
return _nx.concatenate(map(atleast_2d,tup),0)
|
|
|
|
def hstack(tup):
|
|
"""
|
|
Stack arrays in sequence horizontally (column wise).
|
|
|
|
Take a sequence of arrays and stack them horizontally to make
|
|
a single array. Rebuild arrays divided by `hsplit`.
|
|
|
|
Parameters
|
|
----------
|
|
tup : sequence of ndarrays
|
|
All arrays must have the same shape along all but the second axis.
|
|
|
|
Returns
|
|
-------
|
|
stacked : ndarray
|
|
The array formed by stacking the given arrays.
|
|
|
|
See Also
|
|
--------
|
|
vstack : Stack arrays in sequence vertically (row wise).
|
|
dstack : Stack arrays in sequence depth wise (along third axis).
|
|
concatenate : Join a sequence of arrays together.
|
|
hsplit : Split array along second axis.
|
|
|
|
Notes
|
|
-----
|
|
Equivalent to ``np.concatenate(tup, axis=1)``
|
|
|
|
Examples
|
|
--------
|
|
>>> a = np.array((1,2,3))
|
|
>>> b = np.array((2,3,4))
|
|
>>> np.hstack((a,b))
|
|
array([1, 2, 3, 2, 3, 4])
|
|
>>> a = np.array([[1],[2],[3]])
|
|
>>> b = np.array([[2],[3],[4]])
|
|
>>> np.hstack((a,b))
|
|
array([[1, 2],
|
|
[2, 3],
|
|
[3, 4]])
|
|
|
|
"""
|
|
return _nx.concatenate(map(atleast_1d,tup),1)
|
|
|