DEP: Remove deprecated modules numarray and oldnumeric.

They were deprecated in 1.8 and scheduled for removal in 1.9.

Closes #3637.

1 files changed, 0 insertions, 500 deletions

diff --git a/numpy/numarray/functions.py b/numpy/numarray/functions.py
deleted file mode 100644
index f37e0f054..000000000
--- a/numpy/numarray/functions.py
+++ /dev/null
@@ -1,500 +0,0 @@
-from __future__ import division, absolute_import, print_function
-
-# missing Numarray defined names (in from numarray import *)
-
-__all__ = ['asarray', 'ones', 'zeros', 'array', 'where']
-__all__ += ['vdot', 'dot', 'matrixmultiply', 'ravel', 'indices',
-            'arange', 'concatenate', 'all', 'allclose', 'alltrue', 'and_',
-            'any', 'argmax', 'argmin', 'argsort', 'around', 'array_equal',
-            'array_equiv', 'arrayrange', 'array_str', 'array_repr',
-            'array2list', 'average', 'choose', 'CLIP', 'RAISE', 'WRAP',
-            'clip', 'compress', 'copy', 'copy_reg',
-            'diagonal', 'divide_remainder', 'e', 'explicit_type', 'pi',
-            'flush_caches', 'fromfile', 'os', 'sys', 'STRICT',
-            'SLOPPY', 'WARN', 'EarlyEOFError', 'SizeMismatchError',
-            'SizeMismatchWarning', 'FileSeekWarning', 'fromstring',
-            'fromfunction', 'fromlist', 'getShape', 'getTypeObject',
-            'identity', 'info', 'innerproduct', 'inputarray',
-            'isBigEndian', 'kroneckerproduct', 'lexsort', 'math',
-            'operator', 'outerproduct', 'put', 'putmask', 'rank',
-            'repeat', 'reshape', 'resize', 'round', 'searchsorted',
-            'shape', 'size', 'sometrue', 'sort', 'swapaxes', 'take',
-            'tcode', 'tname', 'tensormultiply', 'trace', 'transpose',
-            'types', 'value', 'cumsum', 'cumproduct', 'nonzero', 'newobj',
-            'togglebyteorder'
-            ]
-
-import copy
-import types
-import os
-import sys
-import math
-import operator
-
-import numpy as np
-from numpy import dot as matrixmultiply, dot, vdot, ravel, concatenate, all,\
-     allclose, any, argsort, array_equal, array_equiv,\
-     array_str, array_repr, CLIP, RAISE, WRAP, clip, concatenate, \
-     diagonal, e, pi, inner as innerproduct, nonzero, \
-     outer as outerproduct, kron as kroneckerproduct, lexsort, putmask, rank, \
-     resize, searchsorted, shape, size, sort, swapaxes, trace, transpose
-from numpy.compat import long
-from .numerictypes import typefrom
-
-if sys.version_info[0] >= 3:
-    import copyreg as copy_reg
-else:
-    import copy_reg
-
-isBigEndian = sys.byteorder != 'little'
-value = tcode = 'f'
-tname = 'Float32'
-
-#  If dtype is not None, then it is used
-#  If type is not None, then it is used
-#  If typecode is not None then it is used
-#  If use_default is True, then the default
-#   data-type is returned if all are None
-def type2dtype(typecode, type, dtype, use_default=True):
-    if dtype is None:
-        if type is None:
-            if use_default or typecode is not None:
-                dtype = np.dtype(typecode)
-        else:
-            dtype = np.dtype(type)
-    if use_default and dtype is None:
-        dtype = np.dtype('int')
-    return dtype
-
-def fromfunction(shape, dimensions, type=None, typecode=None, dtype=None):
-    dtype = type2dtype(typecode, type, dtype, 1)
-    return np.fromfunction(shape, dimensions, dtype=dtype)
-def ones(shape, type=None, typecode=None, dtype=None):
-    dtype = type2dtype(typecode, type, dtype, 1)
-    return np.ones(shape, dtype)
-
-def zeros(shape, type=None, typecode=None, dtype=None):
-    dtype = type2dtype(typecode, type, dtype, 1)
-    return np.zeros(shape, dtype)
-
-def where(condition, x=None, y=None, out=None):
-    if x is None and y is None:
-        arr = np.where(condition)
-    else:
-        arr = np.where(condition, x, y)
-    if out is not None:
-        out[...] = arr
-        return out
-    return arr
-
-def indices(shape, type=None):
-    return np.indices(shape, type)
-
-def arange(a1, a2=None, stride=1, type=None, shape=None,
-           typecode=None, dtype=None):
-    dtype = type2dtype(typecode, type, dtype, 0)
-    return np.arange(a1, a2, stride, dtype)
-
-arrayrange = arange
-
-def alltrue(x, axis=0):
-    return np.alltrue(x, axis)
-
-def and_(a, b):
-    """Same as a & b
-    """
-    return a & b
-
-def divide_remainder(a, b):
-    a, b = asarray(a), asarray(b)
-    return (a/b, a%b)
-
-def around(array, digits=0, output=None):
-    ret = np.around(array, digits, output)
-    if output is None:
-        return ret
-    return
-
-def array2list(arr):
-    return arr.tolist()
-
-
-def choose(selector, population, outarr=None, clipmode=RAISE):
-    a = np.asarray(selector)
-    ret = a.choose(population, out=outarr, mode=clipmode)
-    if outarr is None:
-        return ret
-    return
-
-def compress(condition, a, axis=0):
-    return np.compress(condition, a, axis)
-
-# only returns a view
-def explicit_type(a):
-    x = a.view()
-    return x
-
-# stub
-def flush_caches():
-    pass
-
-
-class EarlyEOFError(Exception):
-    "Raised in fromfile() if EOF unexpectedly occurs."
-    pass
-
-class SizeMismatchError(Exception):
-    "Raised in fromfile() if file size does not match shape."
-    pass
-
-class SizeMismatchWarning(Warning):
-    "Issued in fromfile() if file size does not match shape."
-    pass
-
-class FileSeekWarning(Warning):
-    "Issued in fromfile() if there is unused data and seek() fails"
-    pass
-
-
-STRICT, SLOPPY, WARN = list(range(3))
-
-_BLOCKSIZE=1024
-
-# taken and adapted directly from numarray
-def fromfile(infile, type=None, shape=None, sizing=STRICT,
-             typecode=None, dtype=None):
-    if isinstance(infile, (str, unicode)):
-        infile = open(infile, 'rb')
-    dtype = type2dtype(typecode, type, dtype, True)
-    if shape is None:
-        shape = (-1,)
-    if not isinstance(shape, tuple):
-        shape = (shape,)
-
-    if (list(shape).count(-1)>1):
-        raise ValueError("At most one unspecified dimension in shape")
-
-    if -1 not in shape:
-        if sizing != STRICT:
-            raise ValueError("sizing must be STRICT if size complete")
-        arr = np.empty(shape, dtype)
-        bytesleft=arr.nbytes
-        bytesread=0
-        while(bytesleft > _BLOCKSIZE):
-            data = infile.read(_BLOCKSIZE)
-            if len(data) != _BLOCKSIZE:
-                raise EarlyEOFError("Unexpected EOF reading data for size complete array")
-            arr.data[bytesread:bytesread+_BLOCKSIZE]=data
-            bytesread += _BLOCKSIZE
-            bytesleft -= _BLOCKSIZE
-        if bytesleft > 0:
-            data = infile.read(bytesleft)
-            if len(data) != bytesleft:
-                raise EarlyEOFError("Unexpected EOF reading data for size complete array")
-            arr.data[bytesread:bytesread+bytesleft]=data
-        return arr
-
-
-    ##shape is incompletely specified
-    ##read until EOF
-    ##implementation 1: naively use memory blocks
-    ##problematic because memory allocation can be double what is
-    ##necessary (!)
-
-    ##the most common case, namely reading in data from an unchanging
-    ##file whose size may be determined before allocation, should be
-    ##quick -- only one allocation will be needed.
-
-    recsize = int(dtype.itemsize * np.product([i for i in shape if i != -1]))
-    blocksize = max(_BLOCKSIZE//recsize, 1)*recsize
-
-    ##try to estimate file size
-    try:
-        curpos=infile.tell()
-        infile.seek(0, 2)
-        endpos=infile.tell()
-        infile.seek(curpos)
-    except (AttributeError, IOError):
-        initsize=blocksize
-    else:
-        initsize=max(1, (endpos-curpos)//recsize)*recsize
-
-    buf = np.newbuffer(initsize)
-
-    bytesread=0
-    while True:
-        data=infile.read(blocksize)
-        if len(data) != blocksize: ##eof
-            break
-        ##do we have space?
-        if len(buf) < bytesread+blocksize:
-            buf=_resizebuf(buf, len(buf)+blocksize)
-            ## or rather a=resizebuf(a,2*len(a)) ?
-        assert len(buf) >= bytesread+blocksize
-        buf[bytesread:bytesread+blocksize]=data
-        bytesread += blocksize
-
-    if len(data) % recsize != 0:
-        if sizing == STRICT:
-            raise SizeMismatchError("Filesize does not match specified shape")
-        if sizing == WARN:
-            _warnings.warn("Filesize does not match specified shape",
-                           SizeMismatchWarning)
-        try:
-            infile.seek(-(len(data) % recsize), 1)
-        except AttributeError:
-            _warnings.warn("Could not rewind (no seek support)",
-                           FileSeekWarning)
-        except IOError:
-            _warnings.warn("Could not rewind (IOError in seek)",
-                           FileSeekWarning)
-    datasize = (len(data)//recsize) * recsize
-    if len(buf) != bytesread+datasize:
-        buf=_resizebuf(buf, bytesread+datasize)
-    buf[bytesread:bytesread+datasize]=data[:datasize]
-    ##deduce shape from len(buf)
-    shape = list(shape)
-    uidx = shape.index(-1)
-    shape[uidx]=len(buf) // recsize
-
-    a = np.ndarray(shape=shape, dtype=type, buffer=buf)
-    if a.dtype.char == '?':
-        np.not_equal(a, 0, a)
-    return a
-
-
-# this function is referenced in the code above but not defined.  adding
-# it back. - phensley
-def _resizebuf(buf, newsize):
-    "Return a copy of BUF of size NEWSIZE."
-    newbuf = np.newbuffer(newsize)
-    if newsize > len(buf):
-        newbuf[:len(buf)]=buf
-    else:
-        newbuf[:]=buf[:len(newbuf)]
-    return newbuf
-
-
-def fromstring(datastring, type=None, shape=None, typecode=None, dtype=None):
-    dtype = type2dtype(typecode, type, dtype, True)
-    if shape is None:
-        count = -1
-    else:
-        count = np.product(shape)
-    res = np.fromstring(datastring, dtype=dtype, count=count)
-    if shape is not None:
-        res.shape = shape
-    return res
-
-
-# check_overflow is ignored
-def fromlist(seq, type=None, shape=None, check_overflow=0, typecode=None, dtype=None):
-    dtype = type2dtype(typecode, type, dtype, False)
-    return np.array(seq, dtype)
-
-def array(sequence=None, typecode=None, copy=1, savespace=0,
-          type=None, shape=None, dtype=None):
-    dtype = type2dtype(typecode, type, dtype, 0)
-    if sequence is None:
-        if shape is None:
-            return None
-        if dtype is None:
-            dtype = 'l'
-        return np.empty(shape, dtype)
-    if isinstance(sequence, file):
-        return fromfile(sequence, dtype=dtype, shape=shape)
-    if isinstance(sequence, str):
-        return fromstring(sequence, dtype=dtype, shape=shape)
-    if isinstance(sequence, buffer):
-        arr = np.frombuffer(sequence, dtype=dtype)
-    else:
-        arr = np.array(sequence, dtype, copy=copy)
-    if shape is not None:
-        arr.shape = shape
-    return arr
-
-def asarray(seq, type=None, typecode=None, dtype=None):
-    if isinstance(seq, np.ndarray) and type is None and \
-           typecode is None and dtype is None:
-        return seq
-    return array(seq, type=type, typecode=typecode, copy=0, dtype=dtype)
-
-inputarray = asarray
-
-
-def getTypeObject(sequence, type):
-    if type is not None:
-        return type
-    try:
-        return typefrom(np.array(sequence))
-    except:
-        raise TypeError("Can't determine a reasonable type from sequence")
-
-def getShape(shape, *args):
-    try:
-        if shape is () and not args:
-            return ()
-        if len(args) > 0:
-            shape = (shape, ) + args
-        else:
-            shape = tuple(shape)
-        dummy = np.array(shape)
-        if not issubclass(dummy.dtype.type, np.integer):
-            raise TypeError
-        if len(dummy) > np.MAXDIMS:
-            raise TypeError
-    except:
-        raise TypeError("Shape must be a sequence of integers")
-    return shape
-
-
-def identity(n, type=None, typecode=None, dtype=None):
-    dtype = type2dtype(typecode, type, dtype, True)
-    return np.identity(n, dtype)
-
-def info(obj, output=sys.stdout, numpy=0):
-    if numpy:
-        bp = lambda x: x
-    else:
-        bp = lambda x: int(x)
-    cls = getattr(obj, '__class__', type(obj))
-    if numpy:
-        nm = getattr(cls, '__name__', cls)
-    else:
-        nm = cls
-    print("class: ", nm, file=output)
-    print("shape: ", obj.shape, file=output)
-    strides = obj.strides
-    print("strides: ", strides, file=output)
-    if not numpy:
-        print("byteoffset: 0", file=output)
-        if len(strides) > 0:
-            bs = obj.strides[0]
-        else:
-            bs = obj.itemsize
-        print("bytestride: ", bs, file=output)
-    print("itemsize: ", obj.itemsize, file=output)
-    print("aligned: ", bp(obj.flags.aligned), file=output)
-    print("contiguous: ", bp(obj.flags.contiguous), file=output)
-    if numpy:
-        print("fortran: ", obj.flags.fortran, file=output)
-    if not numpy:
-        print("buffer: ", repr(obj.data), file=output)
-    if not numpy:
-        extra = " (DEBUG ONLY)"
-        tic = "'"
-    else:
-        extra = ""
-        tic = ""
-    print("data pointer: %s%s" % (hex(obj.ctypes._as_parameter_.value), extra), file=output)
-    print("byteorder: ", end=' ', file=output)
-    endian = obj.dtype.byteorder
-    if endian in ['|', '=']:
-        print("%s%s%s" % (tic, sys.byteorder, tic), file=output)
-        byteswap = False
-    elif endian == '>':
-        print("%sbig%s" % (tic, tic), file=output)
-        byteswap = sys.byteorder != "big"
-    else:
-        print("%slittle%s" % (tic, tic), file=output)
-        byteswap = sys.byteorder != "little"
-    print("byteswap: ", bp(byteswap), file=output)
-    if not numpy:
-        print("type: ", typefrom(obj).name, file=output)
-    else:
-        print("type: %s" % obj.dtype, file=output)
-
-#clipmode is ignored if axis is not 0 and array is not 1d
-def put(array, indices, values, axis=0, clipmode=RAISE):
-    if not isinstance(array, np.ndarray):
-        raise TypeError("put only works on subclass of ndarray")
-    work = asarray(array)
-    if axis == 0:
-        if array.ndim == 1:
-            work.put(indices, values, clipmode)
-        else:
-            work[indices] = values
-    elif isinstance(axis, (int, long, np.integer)):
-        work = work.swapaxes(0, axis)
-        work[indices] = values
-        work = work.swapaxes(0, axis)
-    else:
-        def_axes = list(range(work.ndim))
-        for x in axis:
-            def_axes.remove(x)
-        axis = list(axis)+def_axes
-        work = work.transpose(axis)
-        work[indices] = values
-        work = work.transpose(axis)
-
-def repeat(array, repeats, axis=0):
-    return np.repeat(array, repeats, axis)
-
-
-def reshape(array, shape, *args):
-    if len(args) > 0:
-        shape = (shape,) + args
-    return np.reshape(array, shape)
-
-
-import warnings as _warnings
-def round(*args, **keys):
-    _warnings.warn("round() is deprecated. Switch to around()",
-                   DeprecationWarning)
-    return around(*args, **keys)
-
-def sometrue(array, axis=0):
-    return np.sometrue(array, axis)
-
-#clipmode is ignored if axis is not an integer
-def take(array, indices, axis=0, outarr=None, clipmode=RAISE):
-    array = np.asarray(array)
-    if isinstance(axis, (int, long, np.integer)):
-        res = array.take(indices, axis, outarr, clipmode)
-        if outarr is None:
-            return res
-        return
-    else:
-        def_axes = list(range(array.ndim))
-        for x in axis:
-            def_axes.remove(x)
-        axis = list(axis) + def_axes
-        work = array.transpose(axis)
-        res = work[indices]
-        if outarr is None:
-            return res
-        outarr[...] = res
-        return
-
-def tensormultiply(a1, a2):
-    a1, a2 = np.asarray(a1), np.asarray(a2)
-    if (a1.shape[-1] != a2.shape[0]):
-        raise ValueError("Unmatched dimensions")
-    shape = a1.shape[:-1] + a2.shape[1:]
-    return np.reshape(dot(np.reshape(a1, (-1, a1.shape[-1])),
-                          np.reshape(a2, (a2.shape[0], -1))),
-                      shape)
-
-def cumsum(a1, axis=0, out=None, type=None, dim=0):
-    return np.asarray(a1).cumsum(axis, dtype=type, out=out)
-
-def cumproduct(a1, axis=0, out=None, type=None, dim=0):
-    return np.asarray(a1).cumprod(axis, dtype=type, out=out)
-
-def argmax(x, axis=-1):
-    return np.argmax(x, axis)
-
-def argmin(x, axis=-1):
-    return np.argmin(x, axis)
-
-def newobj(self, type):
-    if type is None:
-        return np.empty_like(self)
-    else:
-        return np.empty(self.shape, type)
-
-def togglebyteorder(self):
-    self.dtype=self.dtype.newbyteorder()
-
-def average(a, axis=0, weights=None, returned=0):
-    return np.average(a, axis, weights, returned)