/lib_pypy/numpypy/core/fromnumeric.py
Python | 2430 lines | 2405 code | 4 blank | 21 comment | 0 complexity | 8e934aa8fc799b8acaadc122af413ee6 MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- ######################################################################
- # This is a copy of numpy/core/fromnumeric.py modified for numpypy
- ######################################################################
- # Each name in __all__ was a function in 'numeric' that is now
- # a method in 'numpy'.
- # When the corresponding method is added to numpypy BaseArray
- # each function should be added as a module function
- # at the applevel
- # This can be as simple as doing the following
- #
- # def func(a, ...):
- # if not hasattr(a, 'func')
- # a = numpypy.array(a)
- # return a.func(...)
- #
- ######################################################################
- import numpypy
- # Module containing non-deprecated functions borrowed from Numeric.
- __docformat__ = "restructuredtext en"
- # functions that are now methods
- __all__ = ['take', 'reshape', 'choose', 'repeat', 'put',
- 'swapaxes', 'transpose', 'sort', 'argsort', 'argmax', 'argmin',
- 'searchsorted', 'alen',
- 'resize', 'diagonal', 'trace', 'ravel', 'nonzero', 'shape',
- 'compress', 'clip', 'sum', 'product', 'prod', 'sometrue', 'alltrue',
- 'any', 'all', 'cumsum', 'cumproduct', 'cumprod', 'ptp', 'ndim',
- 'rank', 'size', 'around', 'round_', 'mean', 'std', 'var', 'squeeze',
- 'amax', 'amin',
- ]
- def take(a, indices, axis=None, out=None, mode='raise'):
- """
- Take elements from an array along an axis.
- This function does the same thing as "fancy" indexing (indexing arrays
- using arrays); however, it can be easier to use if you need elements
- along a given axis.
- Parameters
- ----------
- a : array_like
- The source array.
- indices : array_like
- The indices of the values to extract.
- axis : int, optional
- The axis over which to select values. By default, the flattened
- input array is used.
- out : ndarray, optional
- If provided, the result will be placed in this array. It should
- be of the appropriate shape and dtype.
- mode : {'raise', 'wrap', 'clip'}, optional
- Specifies how out-of-bounds indices will behave.
- * 'raise' -- raise an error (default)
- * 'wrap' -- wrap around
- * 'clip' -- clip to the range
- 'clip' mode means that all indices that are too large are replaced
- by the index that addresses the last element along that axis. Note
- that this disables indexing with negative numbers.
- Returns
- -------
- subarray : ndarray
- The returned array has the same type as `a`.
- See Also
- --------
- ndarray.take : equivalent method
- Examples
- --------
- >>> a = [4, 3, 5, 7, 6, 8]
- >>> indices = [0, 1, 4]
- >>> np.take(a, indices)
- array([4, 3, 6])
- In this example if `a` is an ndarray, "fancy" indexing can be used.
- >>> a = np.array(a)
- >>> a[indices]
- array([4, 3, 6])
- """
- raise NotImplementedError('Waiting on interp level method')
- # not deprecated --- copy if necessary, view otherwise
- def reshape(a, newshape, order='C'):
- """
- Gives a new shape to an array without changing its data.
- Parameters
- ----------
- a : array_like
- Array to be reshaped.
- newshape : int or tuple of ints
- The new shape should be compatible with the original shape. If
- an integer, then the result will be a 1-D array of that length.
- One shape dimension can be -1. In this case, the value is inferred
- from the length of the array and remaining dimensions.
- order : {'C', 'F', 'A'}, optional
- Determines whether the array data should be viewed as in C
- (row-major) order, FORTRAN (column-major) order, or the C/FORTRAN
- order should be preserved.
- Returns
- -------
- reshaped_array : ndarray
- This will be a new view object if possible; otherwise, it will
- be a copy.
- See Also
- --------
- ndarray.reshape : Equivalent method.
- Notes
- -----
- It is not always possible to change the shape of an array without
- copying the data. If you want an error to be raise if the data is copied,
- you should assign the new shape to the shape attribute of the array::
- >>> a = np.zeros((10, 2))
- # A transpose make the array non-contiguous
- >>> b = a.T
- # Taking a view makes it possible to modify the shape without modiying the
- # initial object.
- >>> c = b.view()
- >>> c.shape = (20)
- AttributeError: incompatible shape for a non-contiguous array
- Examples
- --------
- >>> a = np.array([[1,2,3], [4,5,6]])
- >>> np.reshape(a, 6)
- array([1, 2, 3, 4, 5, 6])
- >>> np.reshape(a, 6, order='F')
- array([1, 4, 2, 5, 3, 6])
- >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2
- array([[1, 2],
- [3, 4],
- [5, 6]])
- """
- assert order == 'C'
- if not hasattr(a, 'reshape'):
- a = numpypy.array(a)
- return a.reshape(newshape)
- def choose(a, choices, out=None, mode='raise'):
- """
- Construct an array from an index array and a set of arrays to choose from.
- First of all, if confused or uncertain, definitely look at the Examples -
- in its full generality, this function is less simple than it might
- seem from the following code description (below ndi =
- `numpy.lib.index_tricks`):
- ``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``.
- But this omits some subtleties. Here is a fully general summary:
- Given an "index" array (`a`) of integers and a sequence of `n` arrays
- (`choices`), `a` and each choice array are first broadcast, as necessary,
- to arrays of a common shape; calling these *Ba* and *Bchoices[i], i =
- 0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape``
- for each `i`. Then, a new array with shape ``Ba.shape`` is created as
- follows:
- * if ``mode=raise`` (the default), then, first of all, each element of
- `a` (and thus `Ba`) must be in the range `[0, n-1]`; now, suppose that
- `i` (in that range) is the value at the `(j0, j1, ..., jm)` position
- in `Ba` - then the value at the same position in the new array is the
- value in `Bchoices[i]` at that same position;
- * if ``mode=wrap``, values in `a` (and thus `Ba`) may be any (signed)
- integer; modular arithmetic is used to map integers outside the range
- `[0, n-1]` back into that range; and then the new array is constructed
- as above;
- * if ``mode=clip``, values in `a` (and thus `Ba`) may be any (signed)
- integer; negative integers are mapped to 0; values greater than `n-1`
- are mapped to `n-1`; and then the new array is constructed as above.
- Parameters
- ----------
- a : int array
- This array must contain integers in `[0, n-1]`, where `n` is the number
- of choices, unless ``mode=wrap`` or ``mode=clip``, in which cases any
- integers are permissible.
- choices : sequence of arrays
- Choice arrays. `a` and all of the choices must be broadcastable to the
- same shape. If `choices` is itself an array (not recommended), then
- its outermost dimension (i.e., the one corresponding to
- ``choices.shape[0]``) is taken as defining the "sequence".
- out : array, optional
- If provided, the result will be inserted into this array. It should
- be of the appropriate shape and dtype.
- mode : {'raise' (default), 'wrap', 'clip'}, optional
- Specifies how indices outside `[0, n-1]` will be treated:
- * 'raise' : an exception is raised
- * 'wrap' : value becomes value mod `n`
- * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1
- Returns
- -------
- merged_array : array
- The merged result.
- Raises
- ------
- ValueError: shape mismatch
- If `a` and each choice array are not all broadcastable to the same
- shape.
- See Also
- --------
- ndarray.choose : equivalent method
- Notes
- -----
- To reduce the chance of misinterpretation, even though the following
- "abuse" is nominally supported, `choices` should neither be, nor be
- thought of as, a single array, i.e., the outermost sequence-like container
- should be either a list or a tuple.
- Examples
- --------
- >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
- ... [20, 21, 22, 23], [30, 31, 32, 33]]
- >>> np.choose([2, 3, 1, 0], choices
- ... # the first element of the result will be the first element of the
- ... # third (2+1) "array" in choices, namely, 20; the second element
- ... # will be the second element of the fourth (3+1) choice array, i.e.,
- ... # 31, etc.
- ... )
- array([20, 31, 12, 3])
- >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
- array([20, 31, 12, 3])
- >>> # because there are 4 choice arrays
- >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
- array([20, 1, 12, 3])
- >>> # i.e., 0
- A couple examples illustrating how choose broadcasts:
- >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
- >>> choices = [-10, 10]
- >>> np.choose(a, choices)
- array([[ 10, -10, 10],
- [-10, 10, -10],
- [ 10, -10, 10]])
- >>> # With thanks to Anne Archibald
- >>> a = np.array([0, 1]).reshape((2,1,1))
- >>> c1 = np.array([1, 2, 3]).reshape((1,3,1))
- >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
- >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
- array([[[ 1, 1, 1, 1, 1],
- [ 2, 2, 2, 2, 2],
- [ 3, 3, 3, 3, 3]],
- [[-1, -2, -3, -4, -5],
- [-1, -2, -3, -4, -5],
- [-1, -2, -3, -4, -5]]])
- """
- raise NotImplementedError('Waiting on interp level method')
- def repeat(a, repeats, axis=None):
- """
- Repeat elements of an array.
- Parameters
- ----------
- a : array_like
- Input array.
- repeats : {int, array of ints}
- The number of repetitions for each element. `repeats` is broadcasted
- to fit the shape of the given axis.
- axis : int, optional
- The axis along which to repeat values. By default, use the
- flattened input array, and return a flat output array.
- Returns
- -------
- repeated_array : ndarray
- Output array which has the same shape as `a`, except along
- the given axis.
- See Also
- --------
- tile : Tile an array.
- Examples
- --------
- >>> x = np.array([[1,2],[3,4]])
- >>> np.repeat(x, 2)
- array([1, 1, 2, 2, 3, 3, 4, 4])
- >>> np.repeat(x, 3, axis=1)
- array([[1, 1, 1, 2, 2, 2],
- [3, 3, 3, 4, 4, 4]])
- >>> np.repeat(x, [1, 2], axis=0)
- array([[1, 2],
- [3, 4],
- [3, 4]])
- """
- raise NotImplementedError('Waiting on interp level method')
- def put(a, ind, v, mode='raise'):
- """
- Replaces specified elements of an array with given values.
- The indexing works on the flattened target array. `put` is roughly
- equivalent to:
- ::
- a.flat[ind] = v
- Parameters
- ----------
- a : ndarray
- Target array.
- ind : array_like
- Target indices, interpreted as integers.
- v : array_like
- Values to place in `a` at target indices. If `v` is shorter than
- `ind` it will be repeated as necessary.
- mode : {'raise', 'wrap', 'clip'}, optional
- Specifies how out-of-bounds indices will behave.
- * 'raise' -- raise an error (default)
- * 'wrap' -- wrap around
- * 'clip' -- clip to the range
- 'clip' mode means that all indices that are too large are replaced
- by the index that addresses the last element along that axis. Note
- that this disables indexing with negative numbers.
- See Also
- --------
- putmask, place
- Examples
- --------
- >>> a = np.arange(5)
- >>> np.put(a, [0, 2], [-44, -55])
- >>> a
- array([-44, 1, -55, 3, 4])
- >>> a = np.arange(5)
- >>> np.put(a, 22, -5, mode='clip')
- >>> a
- array([ 0, 1, 2, 3, -5])
- """
- raise NotImplementedError('Waiting on interp level method')
- def swapaxes(a, axis1, axis2):
- """
- Interchange two axes of an array.
- Parameters
- ----------
- a : array_like
- Input array.
- axis1 : int
- First axis.
- axis2 : int
- Second axis.
- Returns
- -------
- a_swapped : ndarray
- If `a` is an ndarray, then a view of `a` is returned; otherwise
- a new array is created.
- Examples
- --------
- >>> x = np.array([[1,2,3]])
- >>> np.swapaxes(x,0,1)
- array([[1],
- [2],
- [3]])
- >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
- >>> x
- array([[[0, 1],
- [2, 3]],
- [[4, 5],
- [6, 7]]])
- >>> np.swapaxes(x,0,2)
- array([[[0, 4],
- [2, 6]],
- [[1, 5],
- [3, 7]]])
- """
- swapaxes = a.swapaxes
- return swapaxes(axis1, axis2)
- def transpose(a, axes=None):
- """
- Permute the dimensions of an array.
- Parameters
- ----------
- a : array_like
- Input array.
- axes : list of ints, optional
- By default, reverse the dimensions, otherwise permute the axes
- according to the values given.
- Returns
- -------
- p : ndarray
- `a` with its axes permuted. A view is returned whenever
- possible.
- See Also
- --------
- rollaxis
- Examples
- --------
- >>> x = np.arange(4).reshape((2,2))
- >>> x
- array([[0, 1],
- [2, 3]])
- >>> np.transpose(x)
- array([[0, 2],
- [1, 3]])
- >>> x = np.ones((1, 2, 3))
- >>> np.transpose(x, (1, 0, 2)).shape
- (2, 1, 3)
- """
- if axes is not None:
- raise NotImplementedError('No "axes" arg yet.')
- if not hasattr(a, 'T'):
- a = numpypy.array(a)
- return a.T
- def sort(a, axis=-1, kind='quicksort', order=None):
- """
- Return a sorted copy of an array.
- Parameters
- ----------
- a : array_like
- Array to be sorted.
- axis : int or None, optional
- Axis along which to sort. If None, the array is flattened before
- sorting. The default is -1, which sorts along the last axis.
- kind : {'quicksort', 'mergesort', 'heapsort'}, optional
- Sorting algorithm. Default is 'quicksort'.
- order : list, optional
- When `a` is a structured array, this argument specifies which fields
- to compare first, second, and so on. This list does not need to
- include all of the fields.
- Returns
- -------
- sorted_array : ndarray
- Array of the same type and shape as `a`.
- See Also
- --------
- ndarray.sort : Method to sort an array in-place.
- argsort : Indirect sort.
- lexsort : Indirect stable sort on multiple keys.
- searchsorted : Find elements in a sorted array.
- Notes
- -----
- The various sorting algorithms are characterized by their average speed,
- worst case performance, work space size, and whether they are stable. A
- stable sort keeps items with the same key in the same relative
- order. The three available algorithms have the following
- properties:
- =========== ======= ============= ============ =======
- kind speed worst case work space stable
- =========== ======= ============= ============ =======
- 'quicksort' 1 O(n^2) 0 no
- 'mergesort' 2 O(n*log(n)) ~n/2 yes
- 'heapsort' 3 O(n*log(n)) 0 no
- =========== ======= ============= ============ =======
- All the sort algorithms make temporary copies of the data when
- sorting along any but the last axis. Consequently, sorting along
- the last axis is faster and uses less space than sorting along
- any other axis.
- The sort order for complex numbers is lexicographic. If both the real
- and imaginary parts are non-nan then the order is determined by the
- real parts except when they are equal, in which case the order is
- determined by the imaginary parts.
- Previous to numpy 1.4.0 sorting real and complex arrays containing nan
- values led to undefined behaviour. In numpy versions >= 1.4.0 nan
- values are sorted to the end. The extended sort order is:
- * Real: [R, nan]
- * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]
- where R is a non-nan real value. Complex values with the same nan
- placements are sorted according to the non-nan part if it exists.
- Non-nan values are sorted as before.
- Examples
- --------
- >>> a = np.array([[1,4],[3,1]])
- >>> np.sort(a) # sort along the last axis
- array([[1, 4],
- [1, 3]])
- >>> np.sort(a, axis=None) # sort the flattened array
- array([1, 1, 3, 4])
- >>> np.sort(a, axis=0) # sort along the first axis
- array([[1, 1],
- [3, 4]])
- Use the `order` keyword to specify a field to use when sorting a
- structured array:
- >>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
- >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
- ... ('Galahad', 1.7, 38)]
- >>> a = np.array(values, dtype=dtype) # create a structured array
- >>> np.sort(a, order='height') # doctest: +SKIP
- array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
- ('Lancelot', 1.8999999999999999, 38)],
- dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])
- Sort by age, then height if ages are equal:
- >>> np.sort(a, order=['age', 'height']) # doctest: +SKIP
- array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
- ('Arthur', 1.8, 41)],
- dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])
- """
- raise NotImplementedError('Waiting on interp level method')
- def argsort(a, axis=-1, kind='quicksort', order=None):
- """
- Returns the indices that would sort an array.
- Perform an indirect sort along the given axis using the algorithm specified
- by the `kind` keyword. It returns an array of indices of the same shape as
- `a` that index data along the given axis in sorted order.
- Parameters
- ----------
- a : array_like
- Array to sort.
- axis : int or None, optional
- Axis along which to sort. The default is -1 (the last axis). If None,
- the flattened array is used.
- kind : {'quicksort', 'mergesort', 'heapsort'}, optional
- Sorting algorithm.
- order : list, optional
- When `a` is an array with fields defined, this argument specifies
- which fields to compare first, second, etc. Not all fields need be
- specified.
- Returns
- -------
- index_array : ndarray, int
- Array of indices that sort `a` along the specified axis.
- In other words, ``a[index_array]`` yields a sorted `a`.
- See Also
- --------
- sort : Describes sorting algorithms used.
- lexsort : Indirect stable sort with multiple keys.
- ndarray.sort : Inplace sort.
- Notes
- -----
- See `sort` for notes on the different sorting algorithms.
- As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
- nan values. The enhanced sort order is documented in `sort`.
- Examples
- --------
- One dimensional array:
- >>> x = np.array([3, 1, 2])
- >>> np.argsort(x)
- array([1, 2, 0])
- Two-dimensional array:
- >>> x = np.array([[0, 3], [2, 2]])
- >>> x
- array([[0, 3],
- [2, 2]])
- >>> np.argsort(x, axis=0)
- array([[0, 1],
- [1, 0]])
- >>> np.argsort(x, axis=1)
- array([[0, 1],
- [0, 1]])
- Sorting with keys:
- >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
- >>> x
- array([(1, 0), (0, 1)],
- dtype=[('x', '<i4'), ('y', '<i4')])
- >>> np.argsort(x, order=('x','y'))
- array([1, 0])
- >>> np.argsort(x, order=('y','x'))
- array([0, 1])
- """
- raise NotImplementedError('Waiting on interp level method')
- def argmax(a, axis=None):
- """
- Indices of the maximum values along an axis.
- Parameters
- ----------
- a : array_like
- Input array.
- axis : int, optional
- By default, the index is into the flattened array, otherwise
- along the specified axis.
- Returns
- -------
- index_array : ndarray of ints
- Array of indices into the array. It has the same shape as `a.shape`
- with the dimension along `axis` removed.
- See Also
- --------
- ndarray.argmax, argmin
- amax : The maximum value along a given axis.
- unravel_index : Convert a flat index into an index tuple.
- Notes
- -----
- In case of multiple occurrences of the maximum values, the indices
- corresponding to the first occurrence are returned.
- Examples
- --------
- >>> a = np.arange(6).reshape(2,3)
- >>> a
- array([[0, 1, 2],
- [3, 4, 5]])
- >>> np.argmax(a)
- 5
- >>> np.argmax(a, axis=0)
- array([1, 1, 1])
- >>> np.argmax(a, axis=1)
- array([2, 2])
- >>> b = np.arange(6)
- >>> b[1] = 5
- >>> b
- array([0, 5, 2, 3, 4, 5])
- >>> np.argmax(b) # Only the first occurrence is returned.
- 1
- """
- assert axis is None
- if not hasattr(a, 'argmax'):
- a = numpypy.array(a)
- return a.argmax()
- def argmin(a, axis=None):
- """
- Return the indices of the minimum values along an axis.
- See Also
- --------
- argmax : Similar function. Please refer to `numpy.argmax` for detailed
- documentation.
- """
- assert axis is None
- if not hasattr(a, 'argmin'):
- a = numpypy.array(a)
- return a.argmin()
- def searchsorted(a, v, side='left'):
- """
- Find indices where elements should be inserted to maintain order.
- Find the indices into a sorted array `a` such that, if the corresponding
- elements in `v` were inserted before the indices, the order of `a` would
- be preserved.
- Parameters
- ----------
- a : 1-D array_like
- Input array, sorted in ascending order.
- v : array_like
- Values to insert into `a`.
- side : {'left', 'right'}, optional
- If 'left', the index of the first suitable location found is given. If
- 'right', return the last such index. If there is no suitable
- index, return either 0 or N (where N is the length of `a`).
- Returns
- -------
- indices : array of ints
- Array of insertion points with the same shape as `v`.
- See Also
- --------
- sort : Return a sorted copy of an array.
- histogram : Produce histogram from 1-D data.
- Notes
- -----
- Binary search is used to find the required insertion points.
- As of Numpy 1.4.0 `searchsorted` works with real/complex arrays containing
- `nan` values. The enhanced sort order is documented in `sort`.
- Examples
- --------
- >>> np.searchsorted([1,2,3,4,5], 3)
- 2
- >>> np.searchsorted([1,2,3,4,5], 3, side='right')
- 3
- >>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
- array([0, 5, 1, 2])
- """
- raise NotImplementedError('Waiting on interp level method')
- def resize(a, new_shape):
- """
- Return a new array with the specified shape.
- If the new array is larger than the original array, then the new
- array is filled with repeated copies of `a`. Note that this behavior
- is different from a.resize(new_shape) which fills with zeros instead
- of repeated copies of `a`.
- Parameters
- ----------
- a : array_like
- Array to be resized.
- new_shape : int or tuple of int
- Shape of resized array.
- Returns
- -------
- reshaped_array : ndarray
- The new array is formed from the data in the old array, repeated
- if necessary to fill out the required number of elements. The
- data are repeated in the order that they are stored in memory.
- See Also
- --------
- ndarray.resize : resize an array in-place.
- Examples
- --------
- >>> a=np.array([[0,1],[2,3]])
- >>> np.resize(a,(1,4))
- array([[0, 1, 2, 3]])
- >>> np.resize(a,(2,4))
- array([[0, 1, 2, 3],
- [0, 1, 2, 3]])
- """
- raise NotImplementedError('Waiting on interp level method')
- def squeeze(a):
- """
- Remove single-dimensional entries from the shape of an array.
- Parameters
- ----------
- a : array_like
- Input data.
- Returns
- -------
- squeezed : ndarray
- The input array, but with with all dimensions of length 1
- removed. Whenever possible, a view on `a` is returned.
- Examples
- --------
- >>> x = np.array([[[0], [1], [2]]])
- >>> x.shape
- (1, 3, 1)
- >>> np.squeeze(x).shape
- (3,)
- """
- raise NotImplementedError('Waiting on interp level method')
- def diagonal(a, offset=0, axis1=0, axis2=1):
- """
- Return specified diagonals.
- If `a` is 2-D, returns the diagonal of `a` with the given offset,
- i.e., the collection of elements of the form ``a[i, i+offset]``. If
- `a` has more than two dimensions, then the axes specified by `axis1`
- and `axis2` are used to determine the 2-D sub-array whose diagonal is
- returned. The shape of the resulting array can be determined by
- removing `axis1` and `axis2` and appending an index to the right equal
- to the size of the resulting diagonals.
- Parameters
- ----------
- a : array_like
- Array from which the diagonals are taken.
- offset : int, optional
- Offset of the diagonal from the main diagonal. Can be positive or
- negative. Defaults to main diagonal (0).
- axis1 : int, optional
- Axis to be used as the first axis of the 2-D sub-arrays from which
- the diagonals should be taken. Defaults to first axis (0).
- axis2 : int, optional
- Axis to be used as the second axis of the 2-D sub-arrays from
- which the diagonals should be taken. Defaults to second axis (1).
- Returns
- -------
- array_of_diagonals : ndarray
- If `a` is 2-D, a 1-D array containing the diagonal is returned.
- If the dimension of `a` is larger, then an array of diagonals is
- returned, "packed" from left-most dimension to right-most (e.g.,
- if `a` is 3-D, then the diagonals are "packed" along rows).
- Raises
- ------
- ValueError
- If the dimension of `a` is less than 2.
- See Also
- --------
- diag : MATLAB work-a-like for 1-D and 2-D arrays.
- diagflat : Create diagonal arrays.
- trace : Sum along diagonals.
- Examples
- --------
- >>> a = np.arange(4).reshape(2,2)
- >>> a
- array([[0, 1],
- [2, 3]])
- >>> a.diagonal()
- array([0, 3])
- >>> a.diagonal(1)
- array([1])
- A 3-D example:
- >>> a = np.arange(8).reshape(2,2,2); a
- array([[[0, 1],
- [2, 3]],
- [[4, 5],
- [6, 7]]])
- >>> a.diagonal(0, # Main diagonals of two arrays created by skipping
- ... 0, # across the outer(left)-most axis last and
- ... 1) # the "middle" (row) axis first.
- array([[0, 6],
- [1, 7]])
- The sub-arrays whose main diagonals we just obtained; note that each
- corresponds to fixing the right-most (column) axis, and that the
- diagonals are "packed" in rows.
- >>> a[:,:,0] # main diagonal is [0 6]
- array([[0, 2],
- [4, 6]])
- >>> a[:,:,1] # main diagonal is [1 7]
- array([[1, 3],
- [5, 7]])
- """
- raise NotImplementedError('Waiting on interp level method')
- def trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None):
- """
- Return the sum along diagonals of the array.
- If `a` is 2-D, the sum along its diagonal with the given offset
- is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i.
- If `a` has more than two dimensions, then the axes specified by axis1 and
- axis2 are used to determine the 2-D sub-arrays whose traces are returned.
- The shape of the resulting array is the same as that of `a` with `axis1`
- and `axis2` removed.
- Parameters
- ----------
- a : array_like
- Input array, from which the diagonals are taken.
- offset : int, optional
- Offset of the diagonal from the main diagonal. Can be both positive
- and negative. Defaults to 0.
- axis1, axis2 : int, optional
- Axes to be used as the first and second axis of the 2-D sub-arrays
- from which the diagonals should be taken. Defaults are the first two
- axes of `a`.
- dtype : dtype, optional
- Determines the data-type of the returned array and of the accumulator
- where the elements are summed. If dtype has the value None and `a` is
- of integer type of precision less than the default integer
- precision, then the default integer precision is used. Otherwise,
- the precision is the same as that of `a`.
- out : ndarray, optional
- Array into which the output is placed. Its type is preserved and
- it must be of the right shape to hold the output.
- Returns
- -------
- sum_along_diagonals : ndarray
- If `a` is 2-D, the sum along the diagonal is returned. If `a` has
- larger dimensions, then an array of sums along diagonals is returned.
- See Also
- --------
- diag, diagonal, diagflat
- Examples
- --------
- >>> np.trace(np.eye(3))
- 3.0
- >>> a = np.arange(8).reshape((2,2,2))
- >>> np.trace(a)
- array([6, 8])
- >>> a = np.arange(24).reshape((2,2,2,3))
- >>> np.trace(a).shape
- (2, 3)
- """
- raise NotImplementedError('Waiting on interp level method')
- def ravel(a, order='C'):
- """
- Return a flattened array.
- A 1-D array, containing the elements of the input, is returned. A copy is
- made only if needed.
- Parameters
- ----------
- a : array_like
- Input array. The elements in ``a`` are read in the order specified by
- `order`, and packed as a 1-D array.
- order : {'C','F', 'A', 'K'}, optional
- The elements of ``a`` are read in this order. 'C' means to view
- the elements in C (row-major) order. 'F' means to view the elements
- in Fortran (column-major) order. 'A' means to view the elements
- in 'F' order if a is Fortran contiguous, 'C' order otherwise.
- 'K' means to view the elements in the order they occur in memory,
- except for reversing the data when strides are negative.
- By default, 'C' order is used.
- Returns
- -------
- 1d_array : ndarray
- Output of the same dtype as `a`, and of shape ``(a.size(),)``.
- See Also
- --------
- ndarray.flat : 1-D iterator over an array.
- ndarray.flatten : 1-D array copy of the elements of an array
- in row-major order.
- Notes
- -----
- In row-major order, the row index varies the slowest, and the column
- index the quickest. This can be generalized to multiple dimensions,
- where row-major order implies that the index along the first axis
- varies slowest, and the index along the last quickest. The opposite holds
- for Fortran-, or column-major, mode.
- Examples
- --------
- It is equivalent to ``reshape(-1, order=order)``.
- >>> x = np.array([[1, 2, 3], [4, 5, 6]])
- >>> print np.ravel(x)
- [1 2 3 4 5 6]
- >>> print x.reshape(-1)
- [1 2 3 4 5 6]
- >>> print np.ravel(x, order='F')
- [1 4 2 5 3 6]
- When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
- >>> print np.ravel(x.T)
- [1 4 2 5 3 6]
- >>> print np.ravel(x.T, order='A')
- [1 2 3 4 5 6]
- When ``order`` is 'K', it will preserve orderings that are neither 'C'
- nor 'F', but won't reverse axes:
- >>> a = np.arange(3)[::-1]; a
- array([2, 1, 0])
- >>> a.ravel(order='C')
- array([2, 1, 0])
- >>> a.ravel(order='K')
- array([2, 1, 0])
- >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
- array([[[ 0, 2, 4],
- [ 1, 3, 5]],
- [[ 6, 8, 10],
- [ 7, 9, 11]]])
- >>> a.ravel(order='C')
- array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11])
- >>> a.ravel(order='K')
- array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
- """
- if not hasattr(a, 'ravel'):
- a = numpypy.array(a)
- return a.ravel(order=order)
- def nonzero(a):
- """
- Return the indices of the elements that are non-zero.
- Returns a tuple of arrays, one for each dimension of `a`, containing
- the indices of the non-zero elements in that dimension. The
- corresponding non-zero values can be obtained with::
- a[nonzero(a)]
- To group the indices by element, rather than dimension, use::
- transpose(nonzero(a))
- The result of this is always a 2-D array, with a row for
- each non-zero element.
- Parameters
- ----------
- a : array_like
- Input array.
- Returns
- -------
- tuple_of_arrays : tuple
- Indices of elements that are non-zero.
- See Also
- --------
- flatnonzero :
- Return indices that are non-zero in the flattened version of the input
- array.
- ndarray.nonzero :
- Equivalent ndarray method.
- count_nonzero :
- Counts the number of non-zero elements in the input array.
- Examples
- --------
- >>> x = np.eye(3)
- >>> x
- array([[ 1., 0., 0.],
- [ 0., 1., 0.],
- [ 0., 0., 1.]])
- >>> np.nonzero(x)
- (array([0, 1, 2]), array([0, 1, 2]))
- >>> x[np.nonzero(x)]
- array([ 1., 1., 1.])
- >>> np.transpose(np.nonzero(x))
- array([[0, 0],
- [1, 1],
- [2, 2]])
- A common use for ``nonzero`` is to find the indices of an array, where
- a condition is True. Given an array `a`, the condition `a` > 3 is a
- boolean array and since False is interpreted as 0, np.nonzero(a > 3)
- yields the indices of the `a` where the condition is true.
- >>> a = np.array([[1,2,3],[4,5,6],[7,8,9]])
- >>> a > 3
- array([[False, False, False],
- [ True, True, True],
- [ True, True, True]], dtype=bool)
- >>> np.nonzero(a > 3)
- (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
- The ``nonzero`` method of the boolean array can also be called.
- >>> (a > 3).nonzero()
- (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
- """
- raise NotImplementedError('Waiting on interp level method')
- def shape(a):
- """
- Return the shape of an array.
- Parameters
- ----------
- a : array_like
- Input array.
- Returns
- -------
- shape : tuple of ints
- The elements of the shape tuple give the lengths of the
- corresponding array dimensions.
- See Also
- --------
- alen
- ndarray.shape : Equivalent array method.
- Examples
- --------
- >>> np.shape(np.eye(3))
- (3, 3)
- >>> np.shape([[1, 2]])
- (1, 2)
- >>> np.shape([0])
- (1,)
- >>> np.shape(0)
- ()
- >>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
- >>> np.shape(a)
- (2,)
- >>> a.shape
- (2,)
- """
- if not hasattr(a, 'shape'):
- a = numpypy.array(a)
- return a.shape
- def compress(condition, a, axis=None, out=None):
- """
- Return selected slices of an array along given axis.
- When working along a given axis, a slice along that axis is returned in
- `output` for each index where `condition` evaluates to True. When
- working on a 1-D array, `compress` is equivalent to `extract`.
- Parameters
- ----------
- condition : 1-D array of bools
- Array that selects which entries to return. If len(condition)
- is less than the size of `a` along the given axis, then output is
- truncated to the length of the condition array.
- a : array_like
- Array from which to extract a part.
- axis : int, optional
- Axis along which to take slices. If None (default), work on the
- flattened array.
- out : ndarray, optional
- Output array. Its type is preserved and it must be of the right
- shape to hold the output.
- Returns
- -------
- compressed_array : ndarray
- A copy of `a` without the slices along axis for which `condition`
- is false.
- See Also
- --------
- take, choose, diag, diagonal, select
- ndarray.compress : Equivalent method.
- numpy.doc.ufuncs : Section "Output arguments"
- Examples
- --------
- >>> a = np.array([[1, 2], [3, 4], [5, 6]])
- >>> a
- array([[1, 2],
- [3, 4],
- [5, 6]])
- >>> np.compress([0, 1], a, axis=0)
- array([[3, 4]])
- >>> np.compress([False, True, True], a, axis=0)
- array([[3, 4],
- [5, 6]])
- >>> np.compress([False, True], a, axis=1)
- array([[2],
- [4],
- [6]])
- Working on the flattened array does not return slices along an axis but
- selects elements.
- >>> np.compress([False, True], a)
- array([2])
- """
- raise NotImplementedError('Waiting on interp level method')
- def clip(a, a_min, a_max, out=None):
- """
- Clip (limit) the values in an array.
- Given an interval, values outside the interval are clipped to
- the interval edges. For example, if an interval of ``[0, 1]``
- is specified, values smaller than 0 become 0, and values larger
- than 1 become 1.
- Parameters
- ----------
- a : array_like
- Array containing elements to clip.
- a_min : scalar or array_like
- Minimum value.
- a_max : scalar or array_like
- Maximum value. If `a_min` or `a_max` are array_like, then they will
- be broadcasted to the shape of `a`.
- out : ndarray, optional
- The results will be placed in this array. It may be the input
- array for in-place clipping. `out` must be of the right shape
- to hold the output. Its type is preserved.
- Returns
- -------
- clipped_array : ndarray
- An array with the elements of `a`, but where values
- < `a_min` are replaced with `a_min`, and those > `a_max`
- with `a_max`.
- See Also
- --------
- numpy.doc.ufuncs : Section "Output arguments"
- Examples
- --------
- >>> a = np.arange(10)
- >>> np.clip(a, 1, 8)
- array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
- >>> a
- array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
- >>> np.clip(a, 3, 6, out=a)
- array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
- >>> a = np.arange(10)
- >>> a
- array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
- >>> np.clip(a, [3,4,1,1,1,4,4,4,4,4], 8)
- array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
- """
- raise NotImplementedError('Waiting on interp level method')
- def sum(a, axis=None, dtype=None, out=None):
- """
- Sum of array elements over a given axis.
- Parameters
- ----------
- a : array_like
- Elements to sum.
- axis : integer, optional
- Axis over which the sum is taken. By default `axis` is None,
- and all elements are summed.
- dtype : dtype, optional
- The type of the returned array and of the accumulator in which
- the elements are summed. By default, the dtype of `a` is used.
- An exception is when `a` has an integer type with less precision
- than the default platform integer. In that case, the default
- platform integer is used instead.
- out : ndarray, optional
- Array into which the output is placed. By default, a new array is
- created. If `out` is given, it must be of the appropriate shape
- (the shape of `a` with `axis` removed, i.e.,
- ``numpy.delete(a.shape, axis)``). Its type is preserved. See
- `doc.ufuncs` (Section "Output arguments") for more details.
- Returns
- -------
- sum_along_axis : ndarray
- An array with the same shape as `a`, with the specified
- axis removed. If `a` is a 0-d array, or if `axis` is None, a scalar
- is returned. If an output array is specified, a reference to
- `out` is returned.
- See Also
- --------
- ndarray.sum : Equivalent method.
- cumsum : Cumulative sum of array elements.
- trapz : Integration of array values using the composite trapezoidal rule.
- mean, average
- Notes
- -----
- Arithmetic is modular when using integer types, and no error is
- raised on overflow.
- Examples
- --------
- >>> np.sum([0.5, 1.5])
- 2.0
- >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
- 1
- >>> np.sum([[0, 1], [0, 5]])
- 6
- >>> np.sum([[0, 1], [0, 5]], axis=0)
- array([0, 6])
- >>> np.sum([[0, 1], [0, 5]], axis=1)
- array([1, 5])
- If the accumulator is too small, overflow occurs:
- >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)
- -128
- """
- assert dtype is None
- assert out is None
- if not hasattr(a, "sum"):
- a = numpypy.array(a)
- return a.sum(axis=axis)
- def product (a, axis=None, dtype=None, out=None):
- """
- Return the product of array elements over a given axis.
- See Also
- --------
- prod : equivalent function; see for details.
- """
- raise NotImplementedError('Waiting on interp level method')
- def sometrue(a, axis=None, out=None):
- """
- Check whether some values are true.
- Refer to `any` for full documentation.
- See Also
- --------
- any : equivalent function
- """
- assert axis is None
- assert out is None
- if not hasattr(a, 'any'):
- a = numpypy.array(a)
- return a.any()
- def alltrue (a, axis=None, out=None):
- """
- Check if all elements of input array are true.
- See Also
- --------
- numpy.all : Equivalent function; see for details.
- """
- assert axis is None
- assert out is None
- if not hasattr(a, 'all'):
- a = numpypy.array(a)
- return a.all()
- def any(a,axis=None, out=None):
- """
- Test whether any array element along a given axis evaluates to True.
- Returns single boolean unless `axis` is not ``None``
- Parameters
- ----------
- a : array_like
- Input array or object that can be converted to an array.
- axis : int, optional
- Axis along which a logical OR is performed. The default
- (`axis` = `None`) is to perform a logical OR over a flattened
- input array. `axis` may be negative, in which case it counts
- from the last to the first axis.
- out : ndarray, optional
- Alternate output array in which to place the result. It must have
- the same shape as the expected output and its type is preserved
- (e.g., if it is of type float, then it will remain so, returning
- 1.0 for True and 0.0 for False, regardless of the type of `a`).
- See `doc.ufuncs` (Section "Output arguments") for details.
- Returns
- -------
- any : bool or ndarray
- A new boolean or `ndarray` is returned unless `out` is specified,
- in which case a reference to `out` is returned.
- See Also
- --------
- ndarray.any : equivalent method
- all : Test whether all elements along a given axis evaluate to True.
- Notes
- -----
- Not a Number (NaN), positive infinity and negative infinity evaluate
- to `True` because these are not equal to zero.
- Examples
- --------
- >>> np.any([[True, False], [True, True]])
- True
- >>> np.any([[True, False], [False, False]], axis=0)
- array([ True, False], dtype=bool)
- >>> np.any([-1, 0, 5])
- True
- >>> np.any(np.nan)
- True
- >>> o=np.array([False])
- >>> z=np.any([-1, 4, 5], out=o)
- >>> z, o
- (array([ True], dtype=bool), array([ True], dtype=bool))
- >>> # Check now that z is a reference to o
- >>> z is o
- True
- >>> id(z), id(o) # identity of z and o # doctest: +SKIP
- (191614240, 191614240)
- """
- assert axis is None
- assert out is None
- if not hasattr(a, 'any'):
- a = numpypy.array(a)
- return a.any()
- def all(a,axis=None, out=None):
- """
- Test whether all array elements along a given axis evaluate to True.
- Parameters
- ----------
- a : array_like
- Input array or object that can be converted to an array.
- axis : int, optional
- Axis along which a logical AND is performed.
- The default (`axis` = `None`) is to perform a logical AND
- over a flattened input array. `axis` may be negative, in which
- case it counts from the last to the first axis.
- out : ndarray, optional
- Alternate output array in which to place the result.
- It must have the same shape as the expected output and its
- type is preserved (e.g., if ``dtype(out)`` is float, the result
- will consist of 0.0's and 1.0's). See `doc.ufuncs` (Section
- "Output arguments") for more details.
- Returns
- -------
- all : ndarray, bool
- A new boolean or array is returned unless `out` is specified,
- in which case a reference to `out` is returned.
- See Also
- --------
- ndarray.all : equivalent method
- any : Test whether any element along a given axis evaluates to True.
- Notes
- -----
- Not a Number (NaN), positive infinity and negative infinity
- evaluate to `True` because these are not equal to zero.
- Examples
- --------
- >>> np.all([[True,False],[True,True]])
- False
- >>> np.all([[True,False],[True,True]], axis=0)
- array([ True, False], dtype=bool)
- >>> np.all([-1, 4, 5])
- True
- >>> np.all([1.0, np.nan])
- True
- >>> o=np.array([False])
- >>> z=np.all([-1, 4, 5], out=o)
- >>> id(z), id(o), z # doctest: +SKIP
- (28293632, 28293632, array([ True], dtype=bool))
- """
- assert axis is None
- assert out is None
- if not hasattr(a, 'all'):
- a = numpypy.array(a)
- return a.all()
- def cumsum (a, axis=None, dtype=None, out=None):
- """
- Return the cumulative sum of the elements along a given axis.
- Parameters
- ----------
- a : array_like
- Input array.
- axis : int, optional
- Axis along which the cumulative sum is computed. The default
- (None) is to compute the cumsum over the flattened array.
- dtype : dtype, optional
- Type of the returned array and of the accumulator in which the
- elements are summed. If `dtype` is not specified, it defaults
- to the dtype of `a`, unless `a` has an integer dtype with a
- precision less than that of the default platform integer. In
- that case, the default platform integer is used.
- out : ndarray, optional
- Alternative output array in which to place the result. It must
- have the same shape and buffer length as the expected output
- but the type will be cast if necessary. See `doc.ufuncs`
- (Section "Output arguments") for more details.
- Returns
- -------
- cumsum_along_axis : ndarray.
- A new array holding the result is returned unless `out` is
- specified, in which case a reference to `out` is returned. The
- result has the same size as `a`, and the same shape as `a` if
- `axis` is not None or `a` is a 1-d array.
- See Also
- --------
- sum : Sum array elements.
- trapz : Integration of array values using the composite trapezoidal rule.
- Notes
- -----
- Arithmetic is modular when using integer types, and no error is
- raised on overflow.
- Examples
- --------
- >>> a = np.array([[1,2,3], [4,5,6]])
- >>> a
- array([[1, 2, 3],
- [4, 5, 6]])
- >>> np.cumsum(a)
- array([ 1, 3, 6, 10, 15, 21])
- >>> np.cumsum(a, dtype=float) # specifies type of output value(s)
- array([ 1., 3., 6., 10., 15., 21.])
- >>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns
- array([[1, 2, 3],
- [5, 7, 9]])
- >>> np.cumsum(a,axis=1) # sum over columns for each of the 2 rows
- array([[ 1, 3, 6],
- [ 4, 9, 15]])
- """
- raise NotImplementedError('Waiting on interp level method')
- def cumproduct(a, axis=None, dtype=None, out=None):
- """
- Return the cumulative product over the given axis.
- See Also
- --------
- cumprod : equivalent function; see for details.
- """
- raise NotImplementedError('Waiting on interp level method')
- def ptp(a, axis=None, out=None):
- """
- Range of values (maximum - minimum) along an axis.
- The name of the function comes from the acronym for 'peak to peak'.
- Parameters
- ----------
- a : array_like
- Input values.
- axis : int, optional
- Axis along which to find the peaks. By default, flatten the
- array.
- out : array_like
- Alternative output array in which to place the result. It must
- have the same shape and buffer length as the expected output,
- but the type of the output values will be cast if necessary.
- Returns
- -------
- ptp : ndarray
- A new array holding the result, unless `out` was
- specified, in which case a reference to `out` is returned.
- Examples
- --------
- >>> x = np.arange(4).reshape((2,2))
- >>> x
- array([[0, 1],
- [2, 3]])
- >>> np.ptp(x, axis=0)
- array([2, 2])
- >>> np.ptp(x, axis=1)
- array([1, 1])
- """
- raise NotImplementedError('Waiting on interp level method')
- def amax(a, axis=None, out=None):
- """
- Return the maximum of an array or maximum along an axis.
- Parameters
- ----------
- a : array_like
- Input data.
- axis : int, optional
- Axis along which to operate. By default flattened input is used.
- out : ndarray, optional
- Alternate output array in which to place the result. Must be of
- the same shape and buffer length as the expected output. See
- `doc.ufuncs` (Section "Output arguments") for more details.
- Returns
- -------
- amax : ndarray or scalar
- Maximum of `a`. If `axis` is None, the result is a scalar value.
- If `axis` is given, the result is an array of dimension
- ``a.ndim - 1``.
- See Also
- --------
- nanmax : NaN values are ignored instead of being propagated.
- fmax : same behavior as the C99 fmax function.
- argmax : indices of the maximum values.
- Notes
- -----
- …
Large files files are truncated, but you can click here to view the full file