numpy 1.9.3__zip → 1.10.0__zip

numpy-1.9.3/numpy/lib/arraysetops.py

@@ -1,464 +0,0 @@
-"""
-Set operations for 1D numeric arrays based on sorting.
-
-:Contains:
-  ediff1d,
-  unique,
-  intersect1d,
-  setxor1d,
-  in1d,
-  union1d,
-  setdiff1d
-
-:Notes:
-
-For floating point arrays, inaccurate results may appear due to usual round-off
-and floating point comparison issues.
-
-Speed could be gained in some operations by an implementation of
-sort(), that can provide directly the permutation vectors, avoiding
-thus calls to argsort().
-
-To do: Optionally return indices analogously to unique for all functions.
-
-:Author: Robert Cimrman
-
-"""
-from __future__ import division, absolute_import, print_function
-
-import numpy as np
-
-
-__all__ = [
-    'ediff1d', 'intersect1d', 'setxor1d', 'union1d', 'setdiff1d', 'unique',
-    'in1d'
-    ]
-
-
-def ediff1d(ary, to_end=None, to_begin=None):
-    """
-    The differences between consecutive elements of an array.
-
-    Parameters
-    ----------
-    ary : array_like
-        If necessary, will be flattened before the differences are taken.
-    to_end : array_like, optional
-        Number(s) to append at the end of the returned differences.
-    to_begin : array_like, optional
-        Number(s) to prepend at the beginning of the returned differences.
-
-    Returns
-    -------
-    ediff1d : ndarray
-        The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.
-
-    See Also
-    --------
-    diff, gradient
-
-    Notes
-    -----
-    When applied to masked arrays, this function drops the mask information
-    if the `to_begin` and/or `to_end` parameters are used.
-
-    Examples
-    --------
-    >>> x = np.array([1, 2, 4, 7, 0])
-    >>> np.ediff1d(x)
-    array([ 1,  2,  3, -7])
-
-    >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
-    array([-99,   1,   2,   3,  -7,  88,  99])
-
-    The returned array is always 1D.
-
-    >>> y = [[1, 2, 4], [1, 6, 24]]
-    >>> np.ediff1d(y)
-    array([ 1,  2, -3,  5, 18])
-
-    """
-    ary = np.asanyarray(ary).flat
-    ed = ary[1:] - ary[:-1]
-    arrays = [ed]
-    if to_begin is not None:
-        arrays.insert(0, to_begin)
-    if to_end is not None:
-        arrays.append(to_end)
-
-    if len(arrays) != 1:
-        # We'll save ourselves a copy of a potentially large array in
-        # the common case where neither to_begin or to_end was given.
-        ed = np.hstack(arrays)
-
-    return ed
-
-def unique(ar, return_index=False, return_inverse=False, return_counts=False):
-    """
-    Find the unique elements of an array.
-
-    Returns the sorted unique elements of an array. There are three optional
-    outputs in addition to the unique elements: the indices of the input array
-    that give the unique values, the indices of the unique array that
-    reconstruct the input array, and the number of times each unique value
-    comes up in the input array.
-
-    Parameters
-    ----------
-    ar : array_like
-        Input array. This will be flattened if it is not already 1-D.
-    return_index : bool, optional
-        If True, also return the indices of `ar` that result in the unique
-        array.
-    return_inverse : bool, optional
-        If True, also return the indices of the unique array that can be used
-        to reconstruct `ar`.
-    return_counts : bool, optional
-        .. versionadded:: 1.9.0
-        If True, also return the number of times each unique value comes up
-        in `ar`.
-
-    Returns
-    -------
-    unique : ndarray
-        The sorted unique values.
-    unique_indices : ndarray, optional
-        The indices of the first occurrences of the unique values in the
-        (flattened) original array. Only provided if `return_index` is True.
-    unique_inverse : ndarray, optional
-        The indices to reconstruct the (flattened) original array from the
-        unique array. Only provided if `return_inverse` is True.
-    unique_counts : ndarray, optional
-        .. versionadded:: 1.9.0
-        The number of times each of the unique values comes up in the
-        original array. Only provided if `return_counts` is True.
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Examples
-    --------
-    >>> np.unique([1, 1, 2, 2, 3, 3])
-    array([1, 2, 3])
-    >>> a = np.array([[1, 1], [2, 3]])
-    >>> np.unique(a)
-    array([1, 2, 3])
-
-    Return the indices of the original array that give the unique values:
-
-    >>> a = np.array(['a', 'b', 'b', 'c', 'a'])
-    >>> u, indices = np.unique(a, return_index=True)
-    >>> u
-    array(['a', 'b', 'c'],
-           dtype='|S1')
-    >>> indices
-    array([0, 1, 3])
-    >>> a[indices]
-    array(['a', 'b', 'c'],
-           dtype='|S1')
-
-    Reconstruct the input array from the unique values:
-
-    >>> a = np.array([1, 2, 6, 4, 2, 3, 2])
-    >>> u, indices = np.unique(a, return_inverse=True)
-    >>> u
-    array([1, 2, 3, 4, 6])
-    >>> indices
-    array([0, 1, 4, 3, 1, 2, 1])
-    >>> u[indices]
-    array([1, 2, 6, 4, 2, 3, 2])
-
-    """
-    ar = np.asanyarray(ar).flatten()
-
-    optional_indices = return_index or return_inverse
-    optional_returns = optional_indices or return_counts
-
-    if ar.size == 0:
-        if not optional_returns:
-            ret = ar
-        else:
-            ret = (ar,)
-            if return_index:
-                ret += (np.empty(0, np.bool),)
-            if return_inverse:
-                ret += (np.empty(0, np.bool),)
-            if return_counts:
-                ret += (np.empty(0, np.intp),)
-        return ret
-
-    if optional_indices:
-        perm = ar.argsort(kind='mergesort' if return_index else 'quicksort')
-        aux = ar[perm]
-    else:
-        ar.sort()
-        aux = ar
-    flag = np.concatenate(([True], aux[1:] != aux[:-1]))
-
-    if not optional_returns:
-        ret = aux[flag]
-    else:
-        ret = (aux[flag],)
-        if return_index:
-            ret += (perm[flag],)
-        if return_inverse:
-            iflag = np.cumsum(flag) - 1
-            iperm = perm.argsort()
-            ret += (np.take(iflag, iperm),)
-        if return_counts:
-            idx = np.concatenate(np.nonzero(flag) + ([ar.size],))
-            ret += (np.diff(idx),)
-    return ret
-
-def intersect1d(ar1, ar2, assume_unique=False):
-    """
-    Find the intersection of two arrays.
-
-    Return the sorted, unique values that are in both of the input arrays.
-
-    Parameters
-    ----------
-    ar1, ar2 : array_like
-        Input arrays.
-    assume_unique : bool
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-
-    Returns
-    -------
-    intersect1d : ndarray
-        Sorted 1D array of common and unique elements.
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Examples
-    --------
-    >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
-    array([1, 3])
-
-    """
-    if not assume_unique:
-        # Might be faster than unique( intersect1d( ar1, ar2 ) )?
-        ar1 = unique(ar1)
-        ar2 = unique(ar2)
-    aux = np.concatenate((ar1, ar2))
-    aux.sort()
-    return aux[:-1][aux[1:] == aux[:-1]]
-
-def setxor1d(ar1, ar2, assume_unique=False):
-    """
-    Find the set exclusive-or of two arrays.
-
-    Return the sorted, unique values that are in only one (not both) of the
-    input arrays.
-
-    Parameters
-    ----------
-    ar1, ar2 : array_like
-        Input arrays.
-    assume_unique : bool
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-
-    Returns
-    -------
-    setxor1d : ndarray
-        Sorted 1D array of unique values that are in only one of the input
-        arrays.
-
-    Examples
-    --------
-    >>> a = np.array([1, 2, 3, 2, 4])
-    >>> b = np.array([2, 3, 5, 7, 5])
-    >>> np.setxor1d(a,b)
-    array([1, 4, 5, 7])
-
-    """
-    if not assume_unique:
-        ar1 = unique(ar1)
-        ar2 = unique(ar2)
-
-    aux = np.concatenate((ar1, ar2))
-    if aux.size == 0:
-        return aux
-
-    aux.sort()
-#    flag = ediff1d( aux, to_end = 1, to_begin = 1 ) == 0
-    flag = np.concatenate(([True], aux[1:] != aux[:-1], [True]))
-#    flag2 = ediff1d( flag ) == 0
-    flag2 = flag[1:] == flag[:-1]
-    return aux[flag2]
-
-def in1d(ar1, ar2, assume_unique=False, invert=False):
-    """
-    Test whether each element of a 1-D array is also present in a second array.
-
-    Returns a boolean array the same length as `ar1` that is True
-    where an element of `ar1` is in `ar2` and False otherwise.
-
-    Parameters
-    ----------
-    ar1 : (M,) array_like
-        Input array.
-    ar2 : array_like
-        The values against which to test each value of `ar1`.
-    assume_unique : bool, optional
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-    invert : bool, optional
-        If True, the values in the returned array are inverted (that is,
-        False where an element of `ar1` is in `ar2` and True otherwise).
-        Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
-        to (but is faster than) ``np.invert(in1d(a, b))``.
-
-        .. versionadded:: 1.8.0
-
-    Returns
-    -------
-    in1d : (M,) ndarray, bool
-        The values `ar1[in1d]` are in `ar2`.
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Notes
-    -----
-    `in1d` can be considered as an element-wise function version of the
-    python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
-    equivalent to ``np.array([item in b for item in a])``.
-
-    .. versionadded:: 1.4.0
-
-    Examples
-    --------
-    >>> test = np.array([0, 1, 2, 5, 0])
-    >>> states = [0, 2]
-    >>> mask = np.in1d(test, states)
-    >>> mask
-    array([ True, False,  True, False,  True], dtype=bool)
-    >>> test[mask]
-    array([0, 2, 0])
-    >>> mask = np.in1d(test, states, invert=True)
-    >>> mask
-    array([False,  True, False,  True, False], dtype=bool)
-    >>> test[mask]
-    array([1, 5])
-    """
-    # Ravel both arrays, behavior for the first array could be different
-    ar1 = np.asarray(ar1).ravel()
-    ar2 = np.asarray(ar2).ravel()
-
-    # This code is significantly faster when the condition is satisfied.
-    if len(ar2) < 10 * len(ar1) ** 0.145:
-        if invert:
-            mask = np.ones(len(ar1), dtype=np.bool)
-            for a in ar2:
-                mask &= (ar1 != a)
-        else:
-            mask = np.zeros(len(ar1), dtype=np.bool)
-            for a in ar2:
-                mask |= (ar1 == a)
-        return mask
-
-    # Otherwise use sorting
-    if not assume_unique:
-        ar1, rev_idx = np.unique(ar1, return_inverse=True)
-        ar2 = np.unique(ar2)
-
-    ar = np.concatenate((ar1, ar2))
-    # We need this to be a stable sort, so always use 'mergesort'
-    # here. The values from the first array should always come before
-    # the values from the second array.
-    order = ar.argsort(kind='mergesort')
-    sar = ar[order]
-    if invert:
-        bool_ar = (sar[1:] != sar[:-1])
-    else:
-        bool_ar = (sar[1:] == sar[:-1])
-    flag = np.concatenate((bool_ar, [invert]))
-    indx = order.argsort(kind='mergesort')[:len(ar1)]
-
-    if assume_unique:
-        return flag[indx]
-    else:
-        return flag[indx][rev_idx]
-
-def union1d(ar1, ar2):
-    """
-    Find the union of two arrays.
-
-    Return the unique, sorted array of values that are in either of the two
-    input arrays.
-
-    Parameters
-    ----------
-    ar1, ar2 : array_like
-        Input arrays. They are flattened if they are not already 1D.
-
-    Returns
-    -------
-    union1d : ndarray
-        Unique, sorted union of the input arrays.
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Examples
-    --------
-    >>> np.union1d([-1, 0, 1], [-2, 0, 2])
-    array([-2, -1,  0,  1,  2])
-
-    """
-    return unique(np.concatenate((ar1, ar2)))
-
-def setdiff1d(ar1, ar2, assume_unique=False):
-    """
-    Find the set difference of two arrays.
-
-    Return the sorted, unique values in `ar1` that are not in `ar2`.
-
-    Parameters
-    ----------
-    ar1 : array_like
-        Input array.
-    ar2 : array_like
-        Input comparison array.
-    assume_unique : bool
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-
-    Returns
-    -------
-    setdiff1d : ndarray
-        Sorted 1D array of values in `ar1` that are not in `ar2`.
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Examples
-    --------
-    >>> a = np.array([1, 2, 3, 2, 4, 1])
-    >>> b = np.array([3, 4, 5, 6])
-    >>> np.setdiff1d(a, b)
-    array([1, 2])
-
-    """
-    if not assume_unique:
-        ar1 = unique(ar1)
-        ar2 = unique(ar2)
-    aux = in1d(ar1, ar2, assume_unique=True)
-    if aux.size == 0:
-        return aux
-    else:
-        return np.asarray(ar1)[aux == 0]

numpy-1.9.3/numpy/lib/arrayterator.py

@@ -1,226 +0,0 @@
-"""
-A buffered iterator for big arrays.
-
-This module solves the problem of iterating over a big file-based array
-without having to read it into memory. The `Arrayterator` class wraps
-an array object, and when iterated it will return sub-arrays with at most
-a user-specified number of elements.
-
-"""
-from __future__ import division, absolute_import, print_function
-
-from operator import mul
-from functools import reduce
-
-from numpy.compat import long
-
-__all__ = ['Arrayterator']
-
-
-class Arrayterator(object):
-    """
-    Buffered iterator for big arrays.
-
-    `Arrayterator` creates a buffered iterator for reading big arrays in small
-    contiguous blocks. The class is useful for objects stored in the
-    file system. It allows iteration over the object *without* reading
-    everything in memory; instead, small blocks are read and iterated over.
-
-    `Arrayterator` can be used with any object that supports multidimensional
-    slices. This includes NumPy arrays, but also variables from
-    Scientific.IO.NetCDF or pynetcdf for example.
-
-    Parameters
-    ----------
-    var : array_like
-        The object to iterate over.
-    buf_size : int, optional
-        The buffer size. If `buf_size` is supplied, the maximum amount of
-        data that will be read into memory is `buf_size` elements.
-        Default is None, which will read as many element as possible
-        into memory.
-
-    Attributes
-    ----------
-    var
-    buf_size
-    start
-    stop
-    step
-    shape
-    flat
-
-    See Also
-    --------
-    ndenumerate : Multidimensional array iterator.
-    flatiter : Flat array iterator.
-    memmap : Create a memory-map to an array stored in a binary file on disk.
-
-    Notes
-    -----
-    The algorithm works by first finding a "running dimension", along which
-    the blocks will be extracted. Given an array of dimensions
-    ``(d1, d2, ..., dn)``, e.g. if `buf_size` is smaller than ``d1``, the
-    first dimension will be used. If, on the other hand,
-    ``d1 < buf_size < d1*d2`` the second dimension will be used, and so on.
-    Blocks are extracted along this dimension, and when the last block is
-    returned the process continues from the next dimension, until all
-    elements have been read.
-
-    Examples
-    --------
-    >>> import numpy as np
-    >>> a = np.arange(3 * 4 * 5 * 6).reshape(3, 4, 5, 6)
-    >>> a_itor = np.lib.arrayterator.Arrayterator(a, 2)
-    >>> a_itor.shape
-    (3, 4, 5, 6)
-
-    Now we can iterate over ``a_itor``, and it will return arrays of size
-    two. Since `buf_size` was smaller than any dimension, the first
-    dimension will be iterated over first:
-
-    >>> for subarr in a_itor:
-    ...     if not subarr.all():
-    ...         print subarr, subarr.shape
-    ...
-    [[[[0 1]]]] (1, 1, 1, 2)
-
-    """
-
-    def __init__(self, var, buf_size=None):
-        self.var = var
-        self.buf_size = buf_size
-
-        self.start = [0 for dim in var.shape]
-        self.stop = [dim for dim in var.shape]
-        self.step = [1 for dim in var.shape]
-
-    def __getattr__(self, attr):
-        return getattr(self.var, attr)
-
-    def __getitem__(self, index):
-        """
-        Return a new arrayterator.
-
-        """
-        # Fix index, handling ellipsis and incomplete slices.
-        if not isinstance(index, tuple):
-            index = (index,)
-        fixed = []
-        length, dims = len(index), len(self.shape)
-        for slice_ in index:
-            if slice_ is Ellipsis:
-                fixed.extend([slice(None)] * (dims-length+1))
-                length = len(fixed)
-            elif isinstance(slice_, (int, long)):
-                fixed.append(slice(slice_, slice_+1, 1))
-            else:
-                fixed.append(slice_)
-        index = tuple(fixed)
-        if len(index) < dims:
-            index += (slice(None),) * (dims-len(index))
-
-        # Return a new arrayterator object.
-        out = self.__class__(self.var, self.buf_size)
-        for i, (start, stop, step, slice_) in enumerate(
-                zip(self.start, self.stop, self.step, index)):
-            out.start[i] = start + (slice_.start or 0)
-            out.step[i] = step * (slice_.step or 1)
-            out.stop[i] = start + (slice_.stop or stop-start)
-            out.stop[i] = min(stop, out.stop[i])
-        return out
-
-    def __array__(self):
-        """
-        Return corresponding data.
-
-        """
-        slice_ = tuple(slice(*t) for t in zip(
-                self.start, self.stop, self.step))
-        return self.var[slice_]
-
-    @property
-    def flat(self):
-        """
-        A 1-D flat iterator for Arrayterator objects.
-
-        This iterator returns elements of the array to be iterated over in
-        `Arrayterator` one by one. It is similar to `flatiter`.
-
-        See Also
-        --------
-        `Arrayterator`
-        flatiter
-
-        Examples
-        --------
-        >>> a = np.arange(3 * 4 * 5 * 6).reshape(3, 4, 5, 6)
-        >>> a_itor = np.lib.arrayterator.Arrayterator(a, 2)
-
-        >>> for subarr in a_itor.flat:
-        ...     if not subarr:
-        ...         print subarr, type(subarr)
-        ...
-        0 <type 'numpy.int32'>
-
-        """
-        for block in self:
-            for value in block.flat:
-                yield value
-
-    @property
-    def shape(self):
-        """
-        The shape of the array to be iterated over.
-
-        For an example, see `Arrayterator`.
-
-        """
-        return tuple(((stop-start-1)//step+1) for start, stop, step in
-                zip(self.start, self.stop, self.step))
-
-    def __iter__(self):
-        # Skip arrays with degenerate dimensions
-        if [dim for dim in self.shape if dim <= 0]:
-            raise StopIteration
-
-        start = self.start[:]
-        stop = self.stop[:]
-        step = self.step[:]
-        ndims = len(self.var.shape)
-
-        while True:
-            count = self.buf_size or reduce(mul, self.shape)
-
-            # iterate over each dimension, looking for the
-            # running dimension (ie, the dimension along which
-            # the blocks will be built from)
-            rundim = 0
-            for i in range(ndims-1, -1, -1):
-                # if count is zero we ran out of elements to read
-                # along higher dimensions, so we read only a single position
-                if count == 0:
-                    stop[i] = start[i]+1
-                elif count <= self.shape[i]:
-                    # limit along this dimension
-                    stop[i] = start[i] + count*step[i]
-                    rundim = i
-                else:
-                    # read everything along this dimension
-                    stop[i] = self.stop[i]
-                stop[i] = min(self.stop[i], stop[i])
-                count = count//self.shape[i]
-
-            # yield a block
-            slice_ = tuple(slice(*t) for t in zip(start, stop, step))
-            yield self.var[slice_]
-
-            # Update start position, taking care of overflow to
-            # other dimensions
-            start[rundim] = stop[rundim]  # start where we stopped
-            for i in range(ndims-1, 0, -1):
-                if start[i] >= self.stop[i]:
-                    start[i] = self.start[i]
-                    start[i-1] += self.step[i-1]
-            if start[0] >= self.stop[0]:
-                raise StopIteration