summaryrefslogtreecommitdiff
path: root/numpy/oldnumeric
diff options
context:
space:
mode:
Diffstat (limited to 'numpy/oldnumeric')
-rw-r--r--numpy/oldnumeric/__init__.py41
-rw-r--r--numpy/oldnumeric/alter_code1.py240
-rw-r--r--numpy/oldnumeric/alter_code2.py146
-rw-r--r--numpy/oldnumeric/array_printer.py16
-rw-r--r--numpy/oldnumeric/arrayfns.py98
-rw-r--r--numpy/oldnumeric/compat.py66
-rw-r--r--numpy/oldnumeric/fft.py21
-rw-r--r--numpy/oldnumeric/fix_default_axis.py291
-rw-r--r--numpy/oldnumeric/functions.py124
-rw-r--r--numpy/oldnumeric/linear_algebra.py83
-rw-r--r--numpy/oldnumeric/ma.py15
-rw-r--r--numpy/oldnumeric/matrix.py68
-rw-r--r--numpy/oldnumeric/misc.py42
-rw-r--r--numpy/oldnumeric/mlab.py122
-rw-r--r--numpy/oldnumeric/precision.py169
-rw-r--r--numpy/oldnumeric/random_array.py268
-rw-r--r--numpy/oldnumeric/rng.py135
-rw-r--r--numpy/oldnumeric/rng_stats.py35
-rw-r--r--numpy/oldnumeric/setup.py8
-rw-r--r--numpy/oldnumeric/tests/test_oldnumeric.py86
-rw-r--r--numpy/oldnumeric/typeconv.py60
-rw-r--r--numpy/oldnumeric/ufuncs.py19
-rw-r--r--numpy/oldnumeric/user_array.py9
23 files changed, 2162 insertions, 0 deletions
diff --git a/numpy/oldnumeric/__init__.py b/numpy/oldnumeric/__init__.py
new file mode 100644
index 000000000..83819ad04
--- /dev/null
+++ b/numpy/oldnumeric/__init__.py
@@ -0,0 +1,41 @@
+# Don't add these to the __all__ variable though
+from numpy import *
+
+def _move_axis_to_0(a, axis):
+ if axis == 0:
+ return a
+ n = len(a.shape)
+ if axis < 0:
+ axis += n
+ axes = range(1, axis+1) + [0,] + range(axis+1, n)
+ return transpose(a, axes)
+
+# Add these
+from compat import *
+from functions import *
+from precision import *
+from ufuncs import *
+from misc import *
+
+import compat
+import precision
+import functions
+import misc
+import ufuncs
+
+import numpy
+__version__ = numpy.__version__
+del numpy
+
+__all__ = ['__version__']
+__all__ += compat.__all__
+__all__ += precision.__all__
+__all__ += functions.__all__
+__all__ += ufuncs.__all__
+__all__ += misc.__all__
+
+del compat
+del functions
+del precision
+del ufuncs
+del misc
diff --git a/numpy/oldnumeric/alter_code1.py b/numpy/oldnumeric/alter_code1.py
new file mode 100644
index 000000000..87538a855
--- /dev/null
+++ b/numpy/oldnumeric/alter_code1.py
@@ -0,0 +1,240 @@
+"""
+This module converts code written for Numeric to run with numpy
+
+Makes the following changes:
+ * Changes import statements (warns of use of from Numeric import *)
+ * Changes import statements (using numerix) ...
+ * Makes search and replace changes to:
+ - .typecode()
+ - .iscontiguous()
+ - .byteswapped()
+ - .itemsize()
+ - .toscalar()
+ * Converts .flat to .ravel() except for .flat = xxx or .flat[xxx]
+ * Replace xxx.spacesaver() with True
+ * Convert xx.savespace(?) to pass + ## xx.savespace(?)
+
+ * Converts uses of 'b' to 'B' in the typecode-position of
+ functions:
+ eye, tri (in position 4)
+ ones, zeros, identity, empty, array, asarray, arange,
+ fromstring, indices, array_constructor (in position 2)
+
+ and methods:
+ astype --- only argument
+ -- converts uses of '1', 's', 'w', and 'u' to
+ -- 'b', 'h', 'H', and 'I'
+
+ * Converts uses of type(...) is <type>
+ isinstance(..., <type>)
+"""
+__all__ = ['convertfile', 'convertall', 'converttree', 'convertsrc']
+
+import sys
+import os
+import re
+import glob
+
+
+_func4 = ['eye', 'tri']
+_meth1 = ['astype']
+_func2 = ['ones', 'zeros', 'identity', 'fromstring', 'indices',
+ 'empty', 'array', 'asarray', 'arange', 'array_constructor']
+
+_chars = {'1':'b','s':'h','w':'H','u':'I'}
+
+func_re = {}
+meth_re = {}
+
+for name in _func2:
+ _astr = r"""(%s\s*[(][^,]*?[,][^'"]*?['"])b(['"][^)]*?[)])"""%name
+ func_re[name] = re.compile(_astr, re.DOTALL)
+
+for name in _func4:
+ _astr = r"""(%s\s*[(][^,]*?[,][^,]*?[,][^,]*?[,][^'"]*?['"])b(['"][^)]*?[)])"""%name
+ func_re[name] = re.compile(_astr, re.DOTALL)
+
+for name in _meth1:
+ _astr = r"""(.%s\s*[(][^'"]*?['"])b(['"][^)]*?[)])"""%name
+ func_re[name] = re.compile(_astr, re.DOTALL)
+
+for char in _chars.keys():
+ _astr = r"""(.astype\s*[(][^'"]*?['"])%s(['"][^)]*?[)])"""%char
+ meth_re[char] = re.compile(_astr, re.DOTALL)
+
+def fixtypechars(fstr):
+ for name in _func2 + _func4 + _meth1:
+ fstr = func_re[name].sub('\\1B\\2',fstr)
+ for char in _chars.keys():
+ fstr = meth_re[char].sub('\\1%s\\2'%_chars[char], fstr)
+ return fstr
+
+flatindex_re = re.compile('([.]flat(\s*?[[=]))')
+
+def changeimports(fstr, name, newname):
+ importstr = 'import %s' % name
+ importasstr = 'import %s as ' % name
+ fromstr = 'from %s import ' % name
+ fromall=0
+
+ fstr = re.sub(r'(import\s+[^,\n\r]+,\s*)(%s)' % name,
+ "\\1%s as %s" % (newname, name), fstr)
+ fstr = fstr.replace(importasstr, 'import %s as ' % newname)
+ fstr = fstr.replace(importstr, 'import %s as %s' % (newname,name))
+
+ ind = 0
+ Nlen = len(fromstr)
+ Nlen2 = len("from %s import " % newname)
+ while 1:
+ found = fstr.find(fromstr,ind)
+ if (found < 0):
+ break
+ ind = found + Nlen
+ if fstr[ind] == '*':
+ continue
+ fstr = "%sfrom %s import %s" % (fstr[:found], newname, fstr[ind:])
+ ind += Nlen2 - Nlen
+ return fstr, fromall
+
+istest_re = {}
+_types = ['float', 'int', 'complex', 'ArrayType', 'FloatType',
+ 'IntType', 'ComplexType']
+for name in _types:
+ _astr = r'type\s*[(]([^)]*)[)]\s+(?:is|==)\s+(.*?%s)'%name
+ istest_re[name] = re.compile(_astr)
+def fixistesting(astr):
+ for name in _types:
+ astr = istest_re[name].sub('isinstance(\\1, \\2)', astr)
+ return astr
+
+def replaceattr(astr):
+ astr = astr.replace(".typecode()",".dtype.char")
+ astr = astr.replace(".iscontiguous()",".flags.contiguous")
+ astr = astr.replace(".byteswapped()",".byteswap()")
+ astr = astr.replace(".toscalar()", ".item()")
+ astr = astr.replace(".itemsize()",".itemsize")
+ # preserve uses of flat that should be o.k.
+ tmpstr = flatindex_re.sub(r"@@@@\2",astr)
+ # replace other uses of flat
+ tmpstr = tmpstr.replace(".flat",".ravel()")
+ # put back .flat where it was valid
+ astr = tmpstr.replace("@@@@", ".flat")
+ return astr
+
+svspc2 = re.compile(r'([^,(\s]+[.]spacesaver[(][)])')
+svspc3 = re.compile(r'(\S+[.]savespace[(].*[)])')
+#shpe = re.compile(r'(\S+\s*)[.]shape\s*=[^=]\s*(.+)')
+def replaceother(astr):
+ astr = svspc2.sub('True',astr)
+ astr = svspc3.sub(r'pass ## \1', astr)
+ #astr = shpe.sub('\\1=\\1.reshape(\\2)', astr)
+ return astr
+
+import datetime
+def fromstr(filestr):
+ savestr = filestr[:]
+ filestr = fixtypechars(filestr)
+ filestr = fixistesting(filestr)
+ filestr, fromall1 = changeimports(filestr, 'Numeric', 'numpy.oldnumeric')
+ filestr, fromall1 = changeimports(filestr, 'multiarray','numpy.oldnumeric')
+ filestr, fromall1 = changeimports(filestr, 'umath', 'numpy.oldnumeric')
+ filestr, fromall1 = changeimports(filestr, 'Precision', 'numpy.oldnumeric.precision')
+ filestr, fromall1 = changeimports(filestr, 'UserArray', 'numpy.oldnumeric.user_array')
+ filestr, fromall1 = changeimports(filestr, 'ArrayPrinter', 'numpy.oldnumeric.array_printer')
+ filestr, fromall2 = changeimports(filestr, 'numerix', 'numpy.oldnumeric')
+ filestr, fromall3 = changeimports(filestr, 'scipy_base', 'numpy.oldnumeric')
+ filestr, fromall3 = changeimports(filestr, 'Matrix', 'numpy.oldnumeric.matrix')
+ filestr, fromall3 = changeimports(filestr, 'MLab', 'numpy.oldnumeric.mlab')
+ filestr, fromall3 = changeimports(filestr, 'LinearAlgebra', 'numpy.oldnumeric.linear_algebra')
+ filestr, fromall3 = changeimports(filestr, 'RNG', 'numpy.oldnumeric.rng')
+ filestr, fromall3 = changeimports(filestr, 'RNG.Statistics', 'numpy.oldnumeric.rng_stats')
+ filestr, fromall3 = changeimports(filestr, 'RandomArray', 'numpy.oldnumeric.random_array')
+ filestr, fromall3 = changeimports(filestr, 'FFT', 'numpy.oldnumeric.fft')
+ filestr, fromall3 = changeimports(filestr, 'MA', 'numpy.oldnumeric.ma')
+ fromall = fromall1 or fromall2 or fromall3
+ filestr = replaceattr(filestr)
+ filestr = replaceother(filestr)
+ if savestr != filestr:
+ today = datetime.date.today().strftime('%b %d, %Y')
+ name = os.path.split(sys.argv[0])[-1]
+ filestr = '## Automatically adapted for '\
+ 'numpy.oldnumeric %s by %s\n\n%s' % (today, name, filestr)
+ return filestr, 1
+ return filestr, 0
+
+def makenewfile(name, filestr):
+ fid = file(name, 'w')
+ fid.write(filestr)
+ fid.close()
+
+def convertfile(filename, orig=1):
+ """Convert the filename given from using Numeric to using NumPy
+
+ Copies the file to filename.orig and then over-writes the file
+ with the updated code
+ """
+ fid = open(filename)
+ filestr = fid.read()
+ fid.close()
+ filestr, changed = fromstr(filestr)
+ if changed:
+ if orig:
+ base, ext = os.path.splitext(filename)
+ os.rename(filename, base+".orig")
+ else:
+ os.remove(filename)
+ makenewfile(filename, filestr)
+
+def fromargs(args):
+ filename = args[1]
+ converttree(filename)
+
+def convertall(direc=os.path.curdir, orig=1):
+ """Convert all .py files to use numpy.oldnumeric (from Numeric) in the directory given
+
+ For each changed file, a backup of <usesnumeric>.py is made as
+ <usesnumeric>.py.orig. A new file named <usesnumeric>.py
+ is then written with the updated code.
+ """
+ files = glob.glob(os.path.join(direc,'*.py'))
+ for afile in files:
+ if afile[-8:] == 'setup.py': continue # skip these
+ convertfile(afile, orig)
+
+header_re = re.compile(r'(Numeric/arrayobject.h)')
+
+def convertsrc(direc=os.path.curdir, ext=None, orig=1):
+ """Replace Numeric/arrayobject.h with numpy/oldnumeric.h in all files in the
+ directory with extension give by list ext (if ext is None, then all files are
+ replaced)."""
+ if ext is None:
+ files = glob.glob(os.path.join(direc,'*'))
+ else:
+ files = []
+ for aext in ext:
+ files.extend(glob.glob(os.path.join(direc,"*.%s" % aext)))
+ for afile in files:
+ fid = open(afile)
+ fstr = fid.read()
+ fid.close()
+ fstr, n = header_re.subn(r'numpy/oldnumeric.h',fstr)
+ if n > 0:
+ if orig:
+ base, ext = os.path.splitext(afile)
+ os.rename(afile, base+".orig")
+ else:
+ os.remove(afile)
+ makenewfile(afile, fstr)
+
+def _func(arg, dirname, fnames):
+ convertall(dirname, orig=0)
+ convertsrc(dirname, ext=['h','c'], orig=0)
+
+def converttree(direc=os.path.curdir):
+ """Convert all .py files and source code files in the tree given
+ """
+ os.path.walk(direc, _func, None)
+
+
+if __name__ == '__main__':
+ fromargs(sys.argv)
diff --git a/numpy/oldnumeric/alter_code2.py b/numpy/oldnumeric/alter_code2.py
new file mode 100644
index 000000000..baa6b9d26
--- /dev/null
+++ b/numpy/oldnumeric/alter_code2.py
@@ -0,0 +1,146 @@
+"""
+This module converts code written for numpy.oldnumeric to work
+with numpy
+
+FIXME: Flesh this out.
+
+Makes the following changes:
+ * Converts typecharacters '1swu' to 'bhHI' respectively
+ when used as typecodes
+ * Changes import statements
+ * Change typecode= to dtype=
+ * Eliminates savespace=xxx keyword arguments
+ * Removes it when keyword is not given as well
+ * replaces matrixmultiply with dot
+ * converts functions that don't give axis= keyword that have changed
+ * converts functions that don't give typecode= keyword that have changed
+ * converts use of capitalized type-names
+ * converts old function names in oldnumeric.linear_algebra,
+ oldnumeric.random_array, and oldnumeric.fft
+
+"""
+#__all__ = ['convertfile', 'convertall', 'converttree']
+__all__ = []
+
+import warnings
+warnings.warn("numpy.oldnumeric.alter_code2 is not working yet.")
+
+import sys
+import os
+import re
+import glob
+
+# To convert typecharacters we need to
+# Not very safe. Disabled for now..
+def replacetypechars(astr):
+ astr = astr.replace("'s'","'h'")
+ astr = astr.replace("'b'","'B'")
+ astr = astr.replace("'1'","'b'")
+ astr = astr.replace("'w'","'H'")
+ astr = astr.replace("'u'","'I'")
+ return astr
+
+def changeimports(fstr, name, newname):
+ importstr = 'import %s' % name
+ importasstr = 'import %s as ' % name
+ fromstr = 'from %s import ' % name
+ fromall=0
+
+ fstr = fstr.replace(importasstr, 'import %s as ' % newname)
+ fstr = fstr.replace(importstr, 'import %s as %s' % (newname,name))
+
+ ind = 0
+ Nlen = len(fromstr)
+ Nlen2 = len("from %s import " % newname)
+ while 1:
+ found = fstr.find(fromstr,ind)
+ if (found < 0):
+ break
+ ind = found + Nlen
+ if fstr[ind] == '*':
+ continue
+ fstr = "%sfrom %s import %s" % (fstr[:found], newname, fstr[ind:])
+ ind += Nlen2 - Nlen
+ return fstr, fromall
+
+def replaceattr(astr):
+ astr = astr.replace("matrixmultiply","dot")
+ return astr
+
+def replaceother(astr):
+ astr = re.sub(r'typecode\s*=', 'dtype=', astr)
+ astr = astr.replace('ArrayType', 'ndarray')
+ astr = astr.replace('NewAxis', 'newaxis')
+ return astr
+
+import datetime
+def fromstr(filestr):
+ #filestr = replacetypechars(filestr)
+ filestr, fromall1 = changeimports(filestr, 'numpy.oldnumeric', 'numpy')
+ filestr, fromall1 = changeimports(filestr, 'numpy.core.multiarray', 'numpy')
+ filestr, fromall1 = changeimports(filestr, 'numpy.core.umath', 'numpy')
+ filestr, fromall3 = changeimports(filestr, 'LinearAlgebra',
+ 'numpy.linalg.old')
+ filestr, fromall3 = changeimports(filestr, 'RNG', 'numpy.random.oldrng')
+ filestr, fromall3 = changeimports(filestr, 'RNG.Statistics', 'numpy.random.oldrngstats')
+ filestr, fromall3 = changeimports(filestr, 'RandomArray', 'numpy.random.oldrandomarray')
+ filestr, fromall3 = changeimports(filestr, 'FFT', 'numpy.fft.old')
+ filestr, fromall3 = changeimports(filestr, 'MA', 'numpy.core.ma')
+ fromall = fromall1 or fromall2 or fromall3
+ filestr = replaceattr(filestr)
+ filestr = replaceother(filestr)
+ today = datetime.date.today().strftime('%b %d, %Y')
+ name = os.path.split(sys.argv[0])[-1]
+ filestr = '## Automatically adapted for '\
+ 'numpy %s by %s\n\n%s' % (today, name, filestr)
+ return filestr
+
+def makenewfile(name, filestr):
+ fid = file(name, 'w')
+ fid.write(filestr)
+ fid.close()
+
+def getandcopy(name):
+ fid = file(name)
+ filestr = fid.read()
+ fid.close()
+ base, ext = os.path.splitext(name)
+ makenewfile(base+'.orig', filestr)
+ return filestr
+
+def convertfile(filename):
+ """Convert the filename given from using Numeric to using NumPy
+
+ Copies the file to filename.orig and then over-writes the file
+ with the updated code
+ """
+ filestr = getandcopy(filename)
+ filestr = fromstr(filestr)
+ makenewfile(filename, filestr)
+
+def fromargs(args):
+ filename = args[1]
+ convertfile(filename)
+
+def convertall(direc=os.path.curdir):
+ """Convert all .py files to use NumPy (from Numeric) in the directory given
+
+ For each file, a backup of <usesnumeric>.py is made as
+ <usesnumeric>.py.orig. A new file named <usesnumeric>.py
+ is then written with the updated code.
+ """
+ files = glob.glob(os.path.join(direc,'*.py'))
+ for afile in files:
+ convertfile(afile)
+
+def _func(arg, dirname, fnames):
+ convertall(dirname)
+
+def converttree(direc=os.path.curdir):
+ """Convert all .py files in the tree given
+
+ """
+ os.path.walk(direc, _func, None)
+
+if __name__ == '__main__':
+ fromargs(sys.argv)
diff --git a/numpy/oldnumeric/array_printer.py b/numpy/oldnumeric/array_printer.py
new file mode 100644
index 000000000..95f3f42c7
--- /dev/null
+++ b/numpy/oldnumeric/array_printer.py
@@ -0,0 +1,16 @@
+
+__all__ = ['array2string']
+
+from numpy import array2string as _array2string
+
+def array2string(a, max_line_width=None, precision=None,
+ suppress_small=None, separator=' ',
+ array_output=0):
+ if array_output:
+ prefix="array("
+ style=repr
+ else:
+ prefix = ""
+ style=str
+ return _array2string(a, max_line_width, precision,
+ suppress_small, separator, prefix, style)
diff --git a/numpy/oldnumeric/arrayfns.py b/numpy/oldnumeric/arrayfns.py
new file mode 100644
index 000000000..e80246a57
--- /dev/null
+++ b/numpy/oldnumeric/arrayfns.py
@@ -0,0 +1,98 @@
+"""Backward compatible with arrayfns from Numeric
+"""
+
+__all__ = ['array_set', 'construct3', 'digitize', 'error', 'find_mask', 'histogram', 'index_sort',
+ 'interp', 'nz', 'reverse', 'span', 'to_corners', 'zmin_zmax']
+
+import numpy as nx
+from numpy import asarray
+
+class error(Exception):
+ pass
+
+def array_set(vals1, indices, vals2):
+ indices = asarray(indices)
+ if indices.ndim != 1:
+ raise ValueError, "index array must be 1-d"
+ if not isinstance(vals1, ndarray):
+ raise TypeError, "vals1 must be an ndarray"
+ vals1 = asarray(vals1)
+ vals2 = asarray(vals2)
+ if vals1.ndim != vals2.ndim or vals1.ndim < 1:
+ raise error, "vals1 and vals2 must have same number of dimensions (>=1)"
+ vals1[indices] = vals2
+
+from numpy import digitize
+from numpy import bincount as histogram
+
+def index_sort(arr):
+ return asarray(arr).argsort(kind='heap')
+
+def interp(y, x, z, typ=None):
+ """y(z) interpolated by treating y(x) as piecewise function
+ """
+ res = numpy.interp(z, x, y)
+ if typ is None or typ == 'd':
+ return res
+ if typ == 'f':
+ return res.astype('f')
+
+ raise error, "incompatible typecode"
+
+def nz(x):
+ x = asarray(x,dtype=nx.ubyte)
+ if x.ndim != 1:
+ raise TypeError, "intput must have 1 dimension."
+ indxs = nx.flatnonzero(x != 0)
+ return indxs[-1].item()+1
+
+def reverse(x, n):
+ x = asarray(x,dtype='d')
+ if x.ndim != 2:
+ raise ValueError, "input must be 2-d"
+ y = nx.empty_like(x)
+ if n == 0:
+ y[...] = x[::-1,:]
+ elif n == 1:
+ y[...] = x[:,::-1]
+ return y
+
+def span(lo, hi, num, d2=0):
+ x = linspace(lo, hi, num)
+ if d2 <= 0:
+ return x
+ else:
+ ret = empty((d2,num),x.dtype)
+ ret[...] = x
+ return ret
+
+def zmin_zmax(z, ireg):
+ z = asarray(z, dtype=float)
+ ireg = asarray(ireg, dtype=int)
+ if z.shape != ireg.shape or z.ndim != 2:
+ raise ValueError, "z and ireg must be the same shape and 2-d"
+ ix, iy = nx.nonzero(ireg)
+ # Now, add more indices
+ x1m = ix - 1
+ y1m = iy-1
+ i1 = x1m>=0
+ i2 = y1m>=0
+ i3 = i1 & i2
+ nix = nx.r_[ix, x1m[i1], x1m[i1], ix[i2] ]
+ niy = nx.r_[iy, iy[i1], y1m[i3], y1m[i2]]
+ # remove any negative indices
+ zres = z[nix,niy]
+ return zres.min().item(), zres.max().item()
+
+
+def find_mask(fs, node_edges):
+ raise NotImplementedError
+
+def to_corners(arr, nv, nvsum):
+ raise NotImplementedError
+
+
+def construct3(mask, itype):
+ raise NotImplementedError
+
+
diff --git a/numpy/oldnumeric/compat.py b/numpy/oldnumeric/compat.py
new file mode 100644
index 000000000..369fa5000
--- /dev/null
+++ b/numpy/oldnumeric/compat.py
@@ -0,0 +1,66 @@
+# Compatibility module containing deprecated names
+
+__all__ = ['NewAxis',
+ 'UFuncType', 'UfuncType', 'ArrayType', 'arraytype',
+ 'LittleEndian', 'arrayrange', 'matrixmultiply',
+ 'array_constructor', 'pickle_array',
+ 'DumpArray', 'LoadArray', 'multiarray',
+ # from cPickle
+ 'dump', 'dumps'
+ ]
+
+import numpy.core.multiarray as multiarray
+import numpy.core.umath as um
+from numpy.core.numeric import array, correlate
+import functions
+import sys
+
+from cPickle import dump, dumps
+
+mu = multiarray
+
+#Use this to add a new axis to an array
+#compatibility only
+NewAxis = None
+
+#deprecated
+UFuncType = type(um.sin)
+UfuncType = type(um.sin)
+ArrayType = mu.ndarray
+arraytype = mu.ndarray
+
+LittleEndian = (sys.byteorder == 'little')
+
+from numpy import deprecate
+
+# backward compatibility
+arrayrange = deprecate(functions.arange, 'arrayrange', 'arange')
+
+# deprecated names
+matrixmultiply = deprecate(mu.dot, 'matrixmultiply', 'dot')
+
+def DumpArray(m, fp):
+ m.dump(fp)
+
+def LoadArray(fp):
+ import cPickle
+ return cPickle.load(fp)
+
+def array_constructor(shape, typecode, thestr, Endian=LittleEndian):
+ if typecode == "O":
+ x = array(thestr, "O")
+ else:
+ x = mu.fromstring(thestr, typecode)
+ x.shape = shape
+ if LittleEndian != Endian:
+ return x.byteswap(True)
+ else:
+ return x
+
+def pickle_array(a):
+ if a.dtype.hasobject:
+ return (array_constructor,
+ a.shape, a.dtype.char, a.tolist(), LittleEndian)
+ else:
+ return (array_constructor,
+ (a.shape, a.dtype.char, a.tostring(), LittleEndian))
diff --git a/numpy/oldnumeric/fft.py b/numpy/oldnumeric/fft.py
new file mode 100644
index 000000000..67f30c750
--- /dev/null
+++ b/numpy/oldnumeric/fft.py
@@ -0,0 +1,21 @@
+
+__all__ = ['fft', 'fft2d', 'fftnd', 'hermite_fft', 'inverse_fft',
+ 'inverse_fft2d', 'inverse_fftnd',
+ 'inverse_hermite_fft', 'inverse_real_fft',
+ 'inverse_real_fft2d', 'inverse_real_fftnd',
+ 'real_fft', 'real_fft2d', 'real_fftnd']
+
+from numpy.fft import fft
+from numpy.fft import fft2 as fft2d
+from numpy.fft import fftn as fftnd
+from numpy.fft import hfft as hermite_fft
+from numpy.fft import ifft as inverse_fft
+from numpy.fft import ifft2 as inverse_fft2d
+from numpy.fft import ifftn as inverse_fftnd
+from numpy.fft import ihfft as inverse_hermite_fft
+from numpy.fft import irfft as inverse_real_fft
+from numpy.fft import irfft2 as inverse_real_fft2d
+from numpy.fft import irfftn as inverse_real_fftnd
+from numpy.fft import rfft as real_fft
+from numpy.fft import rfft2 as real_fft2d
+from numpy.fft import rfftn as real_fftnd
diff --git a/numpy/oldnumeric/fix_default_axis.py b/numpy/oldnumeric/fix_default_axis.py
new file mode 100644
index 000000000..8483de85e
--- /dev/null
+++ b/numpy/oldnumeric/fix_default_axis.py
@@ -0,0 +1,291 @@
+"""
+This module adds the default axis argument to code which did not specify it
+for the functions where the default was changed in NumPy.
+
+The functions changed are
+
+add -1 ( all second argument)
+======
+nansum
+nanmax
+nanmin
+nanargmax
+nanargmin
+argmax
+argmin
+compress 3
+
+
+add 0
+======
+take 3
+repeat 3
+sum # might cause problems with builtin.
+product
+sometrue
+alltrue
+cumsum
+cumproduct
+average
+ptp
+cumprod
+prod
+std
+mean
+"""
+__all__ = ['convertfile', 'convertall', 'converttree']
+
+import sys
+import os
+import re
+import glob
+
+
+_args3 = ['compress', 'take', 'repeat']
+_funcm1 = ['nansum', 'nanmax', 'nanmin', 'nanargmax', 'nanargmin',
+ 'argmax', 'argmin', 'compress']
+_func0 = ['take', 'repeat', 'sum', 'product', 'sometrue', 'alltrue',
+ 'cumsum', 'cumproduct', 'average', 'ptp', 'cumprod', 'prod',
+ 'std', 'mean']
+
+_all = _func0 + _funcm1
+func_re = {}
+
+for name in _all:
+ _astr = r"""%s\s*[(]"""%name
+ func_re[name] = re.compile(_astr)
+
+
+import string
+disallowed = '_' + string.uppercase + string.lowercase + string.digits
+
+def _add_axis(fstr, name, repl):
+ alter = 0
+ if name in _args3:
+ allowed_comma = 1
+ else:
+ allowed_comma = 0
+ newcode = ""
+ last = 0
+ for obj in func_re[name].finditer(fstr):
+ nochange = 0
+ start, end = obj.span()
+ if fstr[start-1] in disallowed:
+ continue
+ if fstr[start-1] == '.' \
+ and fstr[start-6:start-1] != 'numpy' \
+ and fstr[start-2:start-1] != 'N' \
+ and fstr[start-9:start-1] != 'numarray' \
+ and fstr[start-8:start-1] != 'numerix' \
+ and fstr[start-8:start-1] != 'Numeric':
+ continue
+ if fstr[start-1] in ['\t',' ']:
+ k = start-2
+ while fstr[k] in ['\t',' ']:
+ k -= 1
+ if fstr[k-2:k+1] == 'def' or \
+ fstr[k-4:k+1] == 'class':
+ continue
+ k = end
+ stack = 1
+ ncommas = 0
+ N = len(fstr)
+ while stack:
+ if k>=N:
+ nochange =1
+ break
+ if fstr[k] == ')':
+ stack -= 1
+ elif fstr[k] == '(':
+ stack += 1
+ elif stack == 1 and fstr[k] == ',':
+ ncommas += 1
+ if ncommas > allowed_comma:
+ nochange = 1
+ break
+ k += 1
+ if nochange:
+ continue
+ alter += 1
+ newcode = "%s%s,%s)" % (newcode, fstr[last:k-1], repl)
+ last = k
+ if not alter:
+ newcode = fstr
+ else:
+ newcode = "%s%s" % (newcode, fstr[last:])
+ return newcode, alter
+
+def _import_change(fstr, names):
+ # Four possibilities
+ # 1.) import numpy with subsequent use of numpy.<name>
+ # change this to import numpy.oldnumeric as numpy
+ # 2.) import numpy as XXXX with subsequent use of
+ # XXXX.<name> ==> import numpy.oldnumeric as XXXX
+ # 3.) from numpy import *
+ # with subsequent use of one of the names
+ # 4.) from numpy import ..., <name>, ... (could span multiple
+ # lines. ==> remove all names from list and
+ # add from numpy.oldnumeric import <name>
+
+ num = 0
+ # case 1
+ importstr = "import numpy"
+ ind = fstr.find(importstr)
+ if (ind > 0):
+ found = 0
+ for name in names:
+ ind2 = fstr.find("numpy.%s" % name, ind)
+ if (ind2 > 0):
+ found = 1
+ break
+ if found:
+ fstr = "%s%s%s" % (fstr[:ind], "import numpy.oldnumeric as numpy",
+ fstr[ind+len(importstr):])
+ num += 1
+
+ # case 2
+ importre = re.compile("""import numpy as ([A-Za-z0-9_]+)""")
+ modules = importre.findall(fstr)
+ if len(modules) > 0:
+ for module in modules:
+ found = 0
+ for name in names:
+ ind2 = fstr.find("%s.%s" % (module, name))
+ if (ind2 > 0):
+ found = 1
+ break
+ if found:
+ importstr = "import numpy as %s" % module
+ ind = fstr.find(importstr)
+ fstr = "%s%s%s" % (fstr[:ind],
+ "import numpy.oldnumeric as %s" % module,
+ fstr[ind+len(importstr):])
+ num += 1
+
+ # case 3
+ importstr = "from numpy import *"
+ ind = fstr.find(importstr)
+ if (ind > 0):
+ found = 0
+ for name in names:
+ ind2 = fstr.find(name, ind)
+ if (ind2 > 0) and fstr[ind2-1] not in disallowed:
+ found = 1
+ break
+ if found:
+ fstr = "%s%s%s" % (fstr[:ind],
+ "from numpy.oldnumeric import *",
+ fstr[ind+len(importstr):])
+ num += 1
+
+ # case 4
+ ind = 0
+ importstr = "from numpy import"
+ N = len(importstr)
+ while 1:
+ ind = fstr.find(importstr, ind)
+ if (ind < 0):
+ break
+ ind += N
+ ptr = ind+1
+ stack = 1
+ while stack:
+ if fstr[ptr] == '\\':
+ stack += 1
+ elif fstr[ptr] == '\n':
+ stack -= 1
+ ptr += 1
+ substr = fstr[ind:ptr]
+ found = 0
+ substr = substr.replace('\n',' ')
+ substr = substr.replace('\\','')
+ importnames = [x.strip() for x in substr.split(',')]
+ # determine if any of names are in importnames
+ addnames = []
+ for name in names:
+ if name in importnames:
+ importnames.remove(name)
+ addnames.append(name)
+ if len(addnames) > 0:
+ fstr = "%s%s\n%s\n%s" % \
+ (fstr[:ind],
+ "from numpy import %s" % \
+ ", ".join(importnames),
+ "from numpy.oldnumeric import %s" % \
+ ", ".join(addnames),
+ fstr[ptr:])
+ num += 1
+
+ return fstr, num
+
+def add_axis(fstr, import_change=False):
+ total = 0
+ if not import_change:
+ for name in _funcm1:
+ fstr, num = _add_axis(fstr, name, 'axis=-1')
+ total += num
+ for name in _func0:
+ fstr, num = _add_axis(fstr, name, 'axis=0')
+ total += num
+ return fstr, total
+ else:
+ fstr, num = _import_change(fstr, _funcm1+_func0)
+ return fstr, num
+
+
+def makenewfile(name, filestr):
+ fid = file(name, 'w')
+ fid.write(filestr)
+ fid.close()
+
+def getfile(name):
+ fid = file(name)
+ filestr = fid.read()
+ fid.close()
+ return filestr
+
+def copyfile(name, fstr):
+ base, ext = os.path.splitext(name)
+ makenewfile(base+'.orig', fstr)
+ return
+
+def convertfile(filename, import_change=False):
+ """Convert the filename given from using Numeric to using NumPy
+
+ Copies the file to filename.orig and then over-writes the file
+ with the updated code
+ """
+ filestr = getfile(filename)
+ newstr, total = add_axis(filestr, import_change)
+ if total > 0:
+ print "Changing ", filename
+ copyfile(filename, filestr)
+ makenewfile(filename, newstr)
+ sys.stdout.flush()
+
+def fromargs(args):
+ filename = args[1]
+ convertfile(filename)
+
+def convertall(direc=os.path.curdir, import_change=False):
+ """Convert all .py files in the directory given
+
+ For each file, a backup of <usesnumeric>.py is made as
+ <usesnumeric>.py.orig. A new file named <usesnumeric>.py
+ is then written with the updated code.
+ """
+ files = glob.glob(os.path.join(direc,'*.py'))
+ for afile in files:
+ convertfile(afile, import_change)
+
+def _func(arg, dirname, fnames):
+ convertall(dirname, import_change=arg)
+
+def converttree(direc=os.path.curdir, import_change=False):
+ """Convert all .py files in the tree given
+
+ """
+ os.path.walk(direc, _func, import_change)
+
+if __name__ == '__main__':
+ fromargs(sys.argv)
diff --git a/numpy/oldnumeric/functions.py b/numpy/oldnumeric/functions.py
new file mode 100644
index 000000000..1f09d8f84
--- /dev/null
+++ b/numpy/oldnumeric/functions.py
@@ -0,0 +1,124 @@
+# Functions that should behave the same as Numeric and need changing
+
+import numpy as N
+import numpy.core.multiarray as mu
+import numpy.core.numeric as nn
+from typeconv import convtypecode, convtypecode2
+
+__all__ = ['take', 'repeat', 'sum', 'product', 'sometrue', 'alltrue',
+ 'cumsum', 'cumproduct', 'compress', 'fromfunction',
+ 'ones', 'empty', 'identity', 'zeros', 'array', 'asarray',
+ 'nonzero', 'reshape', 'arange', 'fromstring', 'ravel', 'trace',
+ 'indices', 'where','sarray','cross_product', 'argmax', 'argmin',
+ 'average']
+
+def take(a, indicies, axis=0):
+ return N.take(a, indicies, axis)
+
+def repeat(a, repeats, axis=0):
+ return N.repeat(a, repeats, axis)
+
+def sum(x, axis=0):
+ return N.sum(x, axis)
+
+def product(x, axis=0):
+ return N.product(x, axis)
+
+def sometrue(x, axis=0):
+ return N.sometrue(x, axis)
+
+def alltrue(x, axis=0):
+ return N.alltrue(x, axis)
+
+def cumsum(x, axis=0):
+ return N.cumsum(x, axis)
+
+def cumproduct(x, axis=0):
+ return N.cumproduct(x, axis)
+
+def argmax(x, axis=-1):
+ return N.argmax(x, axis)
+
+def argmin(x, axis=-1):
+ return N.argmin(x, axis)
+
+def compress(condition, m, axis=-1):
+ return N.compress(condition, m, axis)
+
+def fromfunction(args, dimensions):
+ return N.fromfunction(args, dimensions, dtype=int)
+
+def ones(shape, typecode='l', savespace=0, dtype=None):
+ """ones(shape, dtype=int) returns an array of the given
+ dimensions which is initialized to all ones.
+ """
+ dtype = convtypecode(typecode,dtype)
+ a = mu.empty(shape, dtype)
+ a.fill(1)
+ return a
+
+def zeros(shape, typecode='l', savespace=0, dtype=None):
+ """zeros(shape, dtype=int) returns an array of the given
+ dimensions which is initialized to all zeros
+ """
+ dtype = convtypecode(typecode,dtype)
+ return mu.zeros(shape, dtype)
+
+def identity(n,typecode='l', dtype=None):
+ """identity(n) returns the identity 2-d array of shape n x n.
+ """
+ dtype = convtypecode(typecode, dtype)
+ return nn.identity(n, dtype)
+
+def empty(shape, typecode='l', dtype=None):
+ dtype = convtypecode(typecode, dtype)
+ return mu.empty(shape, dtype)
+
+def array(sequence, typecode=None, copy=1, savespace=0, dtype=None):
+ dtype = convtypecode2(typecode, dtype)
+ return mu.array(sequence, dtype, copy=copy)
+
+def sarray(a, typecode=None, copy=False, dtype=None):
+ dtype = convtypecode2(typecode, dtype)
+ return mu.array(a, dtype, copy)
+
+def asarray(a, typecode=None, dtype=None):
+ dtype = convtypecode2(typecode, dtype)
+ return mu.array(a, dtype, copy=0)
+
+def nonzero(a):
+ res = N.nonzero(a)
+ if len(res) == 1:
+ return res[0]
+ else:
+ raise ValueError, "Input argument must be 1d"
+
+def reshape(a, shape):
+ return N.reshape(a, shape)
+
+def arange(start, stop=None, step=1, typecode=None, dtype=None):
+ dtype = convtypecode2(typecode, dtype)
+ return mu.arange(start, stop, step, dtype)
+
+def fromstring(string, typecode='l', count=-1, dtype=None):
+ dtype = convtypecode(typecode, dtype)
+ return mu.fromstring(string, dtype, count=count)
+
+def ravel(m):
+ return N.ravel(m)
+
+def trace(a, offset=0, axis1=0, axis2=1):
+ return N.trace(a, offset=0, axis1=0, axis2=1)
+
+def indices(dimensions, typecode=None, dtype=None):
+ dtype = convtypecode(typecode, dtype)
+ return N.indices(dimensions, dtype)
+
+def where(condition, x, y):
+ return N.where(condition, x, y)
+
+def cross_product(a, b, axis1=-1, axis2=-1):
+ return N.cross(a, b, axis1, axis2)
+
+def average(a, axis=0, weights=None, returned=False):
+ return N.average(a, axis, weights, returned)
diff --git a/numpy/oldnumeric/linear_algebra.py b/numpy/oldnumeric/linear_algebra.py
new file mode 100644
index 000000000..2e7a264fe
--- /dev/null
+++ b/numpy/oldnumeric/linear_algebra.py
@@ -0,0 +1,83 @@
+"""Backward compatible with LinearAlgebra from Numeric
+"""
+# This module is a lite version of the linalg.py module in SciPy which contains
+# high-level Python interface to the LAPACK library. The lite version
+# only accesses the following LAPACK functions: dgesv, zgesv, dgeev,
+# zgeev, dgesdd, zgesdd, dgelsd, zgelsd, dsyevd, zheevd, dgetrf, dpotrf.
+
+
+__all__ = ['LinAlgError', 'solve_linear_equations',
+ 'inverse', 'cholesky_decomposition', 'eigenvalues',
+ 'Heigenvalues', 'generalized_inverse',
+ 'determinant', 'singular_value_decomposition',
+ 'eigenvectors', 'Heigenvectors',
+ 'linear_least_squares'
+ ]
+
+from numpy.core import transpose
+import numpy.linalg as linalg
+
+# Linear equations
+
+LinAlgError = linalg.LinAlgError
+
+def solve_linear_equations(a, b):
+ return linalg.solve(a,b)
+
+# Matrix inversion
+
+def inverse(a):
+ return linalg.inv(a)
+
+# Cholesky decomposition
+
+def cholesky_decomposition(a):
+ return linalg.cholesky(a)
+
+# Eigenvalues
+
+def eigenvalues(a):
+ return linalg.eigvals(a)
+
+def Heigenvalues(a, UPLO='L'):
+ return linalg.eigvalsh(a,UPLO)
+
+# Eigenvectors
+
+def eigenvectors(A):
+ w, v = linalg.eig(A)
+ return w, transpose(v)
+
+def Heigenvectors(A):
+ w, v = linalg.eigh(A)
+ return w, transpose(v)
+
+# Generalized inverse
+
+def generalized_inverse(a, rcond = 1.e-10):
+ return linalg.pinv(a, rcond)
+
+# Determinant
+
+def determinant(a):
+ return linalg.det(a)
+
+# Linear Least Squares
+
+def linear_least_squares(a, b, rcond=1.e-10):
+ """returns x,resids,rank,s
+where x minimizes 2-norm(|b - Ax|)
+ resids is the sum square residuals
+ rank is the rank of A
+ s is the rank of the singular values of A in descending order
+
+If b is a matrix then x is also a matrix with corresponding columns.
+If the rank of A is less than the number of columns of A or greater than
+the number of rows, then residuals will be returned as an empty array
+otherwise resids = sum((b-dot(A,x)**2).
+Singular values less than s[0]*rcond are treated as zero.
+"""
+ return linalg.lstsq(a,b,rcond)
+
+def singular_value_decomposition(A, full_matrices=0):
+ return linalg.svd(A, full_matrices)
diff --git a/numpy/oldnumeric/ma.py b/numpy/oldnumeric/ma.py
new file mode 100644
index 000000000..857c554ec
--- /dev/null
+++ b/numpy/oldnumeric/ma.py
@@ -0,0 +1,15 @@
+# Incompatibility in that getmask and a.mask returns nomask
+# instead of None
+
+from numpy.core.ma import *
+import numpy.core.ma as nca
+
+def repeat(a, repeats, axis=0):
+ return nca.repeat(a, repeats, axis)
+
+def average(a, axis=0, weights=None, returned=0):
+ return nca.average(a, axis, weights, returned)
+
+def take(a, indices, axis=0):
+ return nca.average(a, indices, axis=0)
+
diff --git a/numpy/oldnumeric/matrix.py b/numpy/oldnumeric/matrix.py
new file mode 100644
index 000000000..7c5b3700c
--- /dev/null
+++ b/numpy/oldnumeric/matrix.py
@@ -0,0 +1,68 @@
+# This module is for compatibility only.
+
+__all__ = ['UserArray', 'squeeze', 'Matrix', 'asarray', 'dot', 'k', 'Numeric', 'LinearAlgebra', 'identity', 'multiply', 'types', 'string']
+
+import string
+import types
+from user_array import UserArray, asarray
+import numpy.oldnumeric as Numeric
+from numpy.oldnumeric import dot, identity, multiply
+import numpy.oldnumeric.linear_algebra as LinearAlgebra
+from numpy import matrix as Matrix, squeeze
+
+# Hidden names that will be the same.
+
+_table = [None]*256
+for k in range(256):
+ _table[k] = chr(k)
+_table = ''.join(_table)
+
+_numchars = string.digits + ".-+jeEL"
+_todelete = []
+for k in _table:
+ if k not in _numchars:
+ _todelete.append(k)
+_todelete = ''.join(_todelete)
+
+
+def _eval(astr):
+ return eval(astr.translate(_table,_todelete))
+
+def _convert_from_string(data):
+ data.find
+ rows = data.split(';')
+ newdata = []
+ count = 0
+ for row in rows:
+ trow = row.split(',')
+ newrow = []
+ for col in trow:
+ temp = col.split()
+ newrow.extend(map(_eval,temp))
+ if count == 0:
+ Ncols = len(newrow)
+ elif len(newrow) != Ncols:
+ raise ValueError, "Rows not the same size."
+ count += 1
+ newdata.append(newrow)
+ return newdata
+
+
+_lkup = {'0':'000',
+ '1':'001',
+ '2':'010',
+ '3':'011',
+ '4':'100',
+ '5':'101',
+ '6':'110',
+ '7':'111'}
+
+def _binary(num):
+ ostr = oct(num)
+ bin = ''
+ for ch in ostr[1:]:
+ bin += _lkup[ch]
+ ind = 0
+ while bin[ind] == '0':
+ ind += 1
+ return bin[ind:]
diff --git a/numpy/oldnumeric/misc.py b/numpy/oldnumeric/misc.py
new file mode 100644
index 000000000..4b43f3985
--- /dev/null
+++ b/numpy/oldnumeric/misc.py
@@ -0,0 +1,42 @@
+# Functions that already have the correct syntax or miscellaneous functions
+
+
+__all__ = ['load', 'sort', 'copy_reg', 'clip', 'Unpickler', 'rank',
+ 'sign', 'shape', 'types', 'allclose', 'size',
+ 'choose', 'swapaxes', 'array_str',
+ 'pi', 'math', 'concatenate', 'putmask', 'put',
+ 'around', 'vdot', 'transpose', 'array2string', 'diagonal',
+ 'searchsorted', 'copy', 'resize',
+ 'array_repr', 'e', 'StringIO', 'pickle',
+ 'argsort', 'convolve', 'loads', 'cross_correlate',
+ 'Pickler', 'dot', 'outerproduct', 'innerproduct', 'insert']
+
+import types
+import StringIO
+import pickle
+import math
+import copy
+import copy_reg
+from pickle import load, loads
+
+from numpy import sort, clip, rank, sign, shape, putmask, allclose, size,\
+ choose, swapaxes, array_str, array_repr, e, pi, put, \
+ resize, around, concatenate, vdot, transpose, \
+ diagonal, searchsorted, argsort, convolve, dot, \
+ outer as outerproduct, inner as innerproduct, correlate as cross_correlate, \
+ place as insert
+
+from array_printer import array2string
+
+
+class Unpickler(pickle.Unpickler):
+ def __init__(self, *args, **kwds):
+ raise NotImplemented
+ def load_array(self):
+ raise NotImplemented
+
+class Pickler(pickle.Pickler):
+ def __init__(self, *args, **kwds):
+ raise NotImplemented
+ def save_array(self, object):
+ raise NotImplemented
diff --git a/numpy/oldnumeric/mlab.py b/numpy/oldnumeric/mlab.py
new file mode 100644
index 000000000..47be89e1b
--- /dev/null
+++ b/numpy/oldnumeric/mlab.py
@@ -0,0 +1,122 @@
+# This module is for compatibility only. All functions are defined elsewhere.
+
+__all__ = ['rand', 'tril', 'trapz', 'hanning', 'rot90', 'triu', 'diff', 'angle', 'roots', 'ptp', 'kaiser', 'randn', 'cumprod', 'diag', 'msort', 'LinearAlgebra', 'RandomArray', 'prod', 'std', 'hamming', 'flipud', 'max', 'blackman', 'corrcoef', 'bartlett', 'eye', 'squeeze', 'sinc', 'tri', 'cov', 'svd', 'min', 'median', 'fliplr', 'eig', 'mean']
+
+import numpy.oldnumeric.linear_algebra as LinearAlgebra
+import numpy.oldnumeric.random_array as RandomArray
+from numpy import tril, trapz as _Ntrapz, hanning, rot90, triu, diff, \
+ angle, roots, ptp as _Nptp, kaiser, cumprod as _Ncumprod, \
+ diag, msort, prod as _Nprod, std as _Nstd, hamming, flipud, \
+ amax as _Nmax, amin as _Nmin, blackman, bartlett, \
+ squeeze, sinc, median, fliplr, mean as _Nmean, transpose
+
+from numpy.linalg import eig, svd
+from numpy.random import rand, randn
+import numpy as nn
+
+from typeconv import convtypecode
+
+def eye(N, M=None, k=0, typecode=None, dtype=None):
+ """ eye returns a N-by-M 2-d array where the k-th diagonal is all ones,
+ and everything else is zeros.
+ """
+ dtype = convtypecode(typecode, dtype)
+ if M is None: M = N
+ m = nn.equal(nn.subtract.outer(nn.arange(N), nn.arange(M)),-k)
+ if m.dtype != dtype:
+ return m.astype(dtype)
+
+def tri(N, M=None, k=0, typecode=None, dtype=None):
+ """ returns a N-by-M array where all the diagonals starting from
+ lower left corner up to the k-th are all ones.
+ """
+ dtype = convtypecode(typecode, dtype)
+ if M is None: M = N
+ m = nn.greater_equal(nn.subtract.outer(nn.arange(N), nn.arange(M)),-k)
+ if m.dtype != dtype:
+ return m.astype(dtype)
+
+def trapz(y, x=None, axis=-1):
+ return _Ntrapz(y, x, axis=axis)
+
+def ptp(x, axis=0):
+ return _Nptp(x, axis)
+
+def cumprod(x, axis=0):
+ return _Ncumprod(x, axis)
+
+def max(x, axis=0):
+ return _Nmax(x, axis)
+
+def min(x, axis=0):
+ return _Nmin(x, axis)
+
+def prod(x, axis=0):
+ return _Nprod(x, axis)
+
+def std(x, axis=0):
+ N = asarray(x).shape[axis]
+ return _Nstd(x, axis)*sqrt(N/(N-1.))
+
+def mean(x, axis=0):
+ return _Nmean(x, axis)
+
+# This is exactly the same cov function as in MLab
+def cov(m, y=None, rowvar=0, bias=0):
+ if y is None:
+ y = m
+ else:
+ y = y
+ if rowvar:
+ m = transpose(m)
+ y = transpose(y)
+ if (m.shape[0] == 1):
+ m = transpose(m)
+ if (y.shape[0] == 1):
+ y = transpose(y)
+ N = m.shape[0]
+ if (y.shape[0] != N):
+ raise ValueError, "x and y must have the same number "\
+ "of observations"
+ m = m - _Nmean(m,axis=0)
+ y = y - _Nmean(y,axis=0)
+ if bias:
+ fact = N*1.0
+ else:
+ fact = N-1.0
+ return squeeze(dot(transpose(m), conjugate(y)) / fact)
+
+from numpy import sqrt, multiply
+def corrcoef(x, y=None):
+ c = cov(x,y)
+ d = diag(c)
+ return c/sqrt(multiply.outer(d,d))
+
+from compat import *
+from functions import *
+from precision import *
+from ufuncs import *
+from misc import *
+
+import compat
+import precision
+import functions
+import misc
+import ufuncs
+
+import numpy
+__version__ = numpy.__version__
+del numpy
+
+__all__ += ['__version__']
+__all__ += compat.__all__
+__all__ += precision.__all__
+__all__ += functions.__all__
+__all__ += ufuncs.__all__
+__all__ += misc.__all__
+
+del compat
+del functions
+del precision
+del ufuncs
+del misc
diff --git a/numpy/oldnumeric/precision.py b/numpy/oldnumeric/precision.py
new file mode 100644
index 000000000..f495992a8
--- /dev/null
+++ b/numpy/oldnumeric/precision.py
@@ -0,0 +1,169 @@
+# Lifted from Precision.py. This is for compatibility only.
+#
+# The character strings are still for "new" NumPy
+# which is the only Incompatibility with Numeric
+
+__all__ = ['Character', 'Complex', 'Float',
+ 'PrecisionError', 'PyObject', 'Int', 'UInt',
+ 'UnsignedInteger', 'string', 'typecodes', 'zeros']
+
+import string
+from functions import zeros
+
+typecodes = {'Character':'c', 'Integer':'bhil', 'UnsignedInteger':'BHI', 'Float':'fd', 'Complex':'FD'}
+
+def _get_precisions(typecodes):
+ lst = []
+ for t in typecodes:
+ lst.append( (zeros( (1,), t ).itemsize*8, t) )
+ return lst
+
+def _fill_table(typecodes, table={}):
+ for key, value in typecodes.items():
+ table[key] = _get_precisions(value)
+ return table
+
+_code_table = _fill_table(typecodes)
+
+class PrecisionError(Exception):
+ pass
+
+def _lookup(table, key, required_bits):
+ lst = table[key]
+ for bits, typecode in lst:
+ if bits >= required_bits:
+ return typecode
+ raise PrecisionError, key+" of "+str(required_bits)+" bits not available on this system"
+
+Character = 'c'
+
+try:
+ UnsignedInt8 = _lookup(_code_table, "UnsignedInteger", 8)
+ UInt8 = UnsignedInt8
+ __all__.extend(['UnsignedInt8', 'UInt8'])
+except(PrecisionError):
+ pass
+try:
+ UnsignedInt16 = _lookup(_code_table, "UnsignedInteger", 16)
+ UInt16 = UnsignedInt16
+ __all__.extend(['UnsignedInt16', 'UInt16'])
+except(PrecisionError):
+ pass
+try:
+ UnsignedInt32 = _lookup(_code_table, "UnsignedInteger", 32)
+ UInt32 = UnsignedInt32
+ __all__.extend(['UnsignedInt32', 'UInt32'])
+except(PrecisionError):
+ pass
+try:
+ UnsignedInt64 = _lookup(_code_table, "UnsignedInteger", 64)
+ UInt64 = UnsignedInt64
+ __all__.extend(['UnsignedInt64', 'UInt64'])
+except(PrecisionError):
+ pass
+try:
+ UnsignedInt128 = _lookup(_code_table, "UnsignedInteger", 128)
+ UInt128 = UnsignedInt128
+ __all__.extend(['UnsignedInt128', 'UInt128'])
+except(PrecisionError):
+ pass
+UnsignedInteger = 'u'
+UInt = UnsignedInteger
+
+try:
+ Int0 = _lookup(_code_table, 'Integer', 0)
+ __all__.append('Int0')
+except(PrecisionError):
+ pass
+try:
+ Int8 = _lookup(_code_table, 'Integer', 8)
+ __all__.append('Int8')
+except(PrecisionError):
+ pass
+try:
+ Int16 = _lookup(_code_table, 'Integer', 16)
+ __all__.append('Int16')
+except(PrecisionError):
+ pass
+try:
+ Int32 = _lookup(_code_table, 'Integer', 32)
+ __all__.append('Int32')
+except(PrecisionError):
+ pass
+try:
+ Int64 = _lookup(_code_table, 'Integer', 64)
+ __all__.append('Int64')
+except(PrecisionError):
+ pass
+try:
+ Int128 = _lookup(_code_table, 'Integer', 128)
+ __all__.append('Int128')
+except(PrecisionError):
+ pass
+Int = 'l'
+
+try:
+ Float0 = _lookup(_code_table, 'Float', 0)
+ __all__.append('Float0')
+except(PrecisionError):
+ pass
+try:
+ Float8 = _lookup(_code_table, 'Float', 8)
+ __all__.append('Float8')
+except(PrecisionError):
+ pass
+try:
+ Float16 = _lookup(_code_table, 'Float', 16)
+ __all__.append('Float16')
+except(PrecisionError):
+ pass
+try:
+ Float32 = _lookup(_code_table, 'Float', 32)
+ __all__.append('Float32')
+except(PrecisionError):
+ pass
+try:
+ Float64 = _lookup(_code_table, 'Float', 64)
+ __all__.append('Float64')
+except(PrecisionError):
+ pass
+try:
+ Float128 = _lookup(_code_table, 'Float', 128)
+ __all__.append('Float128')
+except(PrecisionError):
+ pass
+Float = 'd'
+
+try:
+ Complex0 = _lookup(_code_table, 'Complex', 0)
+ __all__.append('Complex0')
+except(PrecisionError):
+ pass
+try:
+ Complex8 = _lookup(_code_table, 'Complex', 16)
+ __all__.append('Complex8')
+except(PrecisionError):
+ pass
+try:
+ Complex16 = _lookup(_code_table, 'Complex', 32)
+ __all__.append('Complex16')
+except(PrecisionError):
+ pass
+try:
+ Complex32 = _lookup(_code_table, 'Complex', 64)
+ __all__.append('Complex32')
+except(PrecisionError):
+ pass
+try:
+ Complex64 = _lookup(_code_table, 'Complex', 128)
+ __all__.append('Complex64')
+except(PrecisionError):
+ pass
+try:
+ Complex128 = _lookup(_code_table, 'Complex', 256)
+ __all__.append('Complex128')
+except(PrecisionError):
+ pass
+Complex = 'D'
+
+PyObject = 'O'
diff --git a/numpy/oldnumeric/random_array.py b/numpy/oldnumeric/random_array.py
new file mode 100644
index 000000000..0b06ee959
--- /dev/null
+++ b/numpy/oldnumeric/random_array.py
@@ -0,0 +1,268 @@
+# Backward compatible module for RandomArray
+
+__all__ = ['ArgumentError','F','beta','binomial','chi_square', 'exponential',
+ 'gamma', 'get_seed', 'mean_var_test', 'multinomial',
+ 'multivariate_normal', 'negative_binomial', 'noncentral_F',
+ 'noncentral_chi_square', 'normal', 'permutation', 'poisson',
+ 'randint', 'random', 'random_integers', 'seed', 'standard_normal',
+ 'uniform']
+
+ArgumentError = ValueError
+
+import numpy.random.mtrand as mt
+import numpy as Numeric
+
+from types import IntType
+
+def seed(x=0, y=0):
+ if (x == 0 or y == 0):
+ mt.seed()
+ else:
+ mt.seed((x,y))
+
+def get_seed():
+ raise NotImplementedError, \
+ "If you want to save the state of the random number generator.\n"\
+ "Then you should use obj = numpy.random.get_state() followed by.\n"\
+ "numpy.random.set_state(obj)."
+
+def random(shape=[]):
+ "random(n) or random([n, m, ...]) returns array of random numbers"
+ if shape == []:
+ shape = None
+ return mt.random_sample(shape)
+
+def uniform(minimum, maximum, shape=[]):
+ """uniform(minimum, maximum, shape=[]) returns array of given shape of random reals
+ in given range"""
+ if shape == []:
+ shape = None
+ return mt.uniform(minimum, maximum, shape)
+
+def randint(minimum, maximum=None, shape=[]):
+ """randint(min, max, shape=[]) = random integers >=min, < max
+ If max not given, random integers >= 0, <min"""
+ if not isinstance(minimum, IntType):
+ raise ArgumentError, "randint requires first argument integer"
+ if maximum is None:
+ maximum = minimum
+ minimum = 0
+ if not isinstance(maximum, IntType):
+ raise ArgumentError, "randint requires second argument integer"
+ a = ((maximum-minimum)* random(shape))
+ if isinstance(a, Numeric.ArrayType):
+ return minimum + a.astype(Numeric.Int)
+ else:
+ return minimum + int(a)
+
+def random_integers(maximum, minimum=1, shape=[]):
+ """random_integers(max, min=1, shape=[]) = random integers in range min-max inclusive"""
+ return randint(minimum, maximum+1, shape)
+
+def permutation(n):
+ "permutation(n) = a permutation of indices range(n)"
+ return mt.permutation(n)
+
+def standard_normal(shape=[]):
+ """standard_normal(n) or standard_normal([n, m, ...]) returns array of
+ random numbers normally distributed with mean 0 and standard
+ deviation 1"""
+ if shape == []:
+ shape = None
+ return mt.standard_normal(shape)
+
+def normal(mean, std, shape=[]):
+ """normal(mean, std, n) or normal(mean, std, [n, m, ...]) returns
+ array of random numbers randomly distributed with specified mean and
+ standard deviation"""
+ if shape == []:
+ shape = None
+ return mt.normal(mean, std, shape)
+
+def multivariate_normal(mean, cov, shape=[]):
+ """multivariate_normal(mean, cov) or multivariate_normal(mean, cov, [m, n, ...])
+ returns an array containing multivariate normally distributed random numbers
+ with specified mean and covariance.
+
+ mean must be a 1 dimensional array. cov must be a square two dimensional
+ array with the same number of rows and columns as mean has elements.
+
+ The first form returns a single 1-D array containing a multivariate
+ normal.
+
+ The second form returns an array of shape (m, n, ..., cov.shape[0]).
+ In this case, output[i,j,...,:] is a 1-D array containing a multivariate
+ normal."""
+ if shape == []:
+ shape = None
+ return mt.multivariate_normal(mean, cov, shape)
+
+def exponential(mean, shape=[]):
+ """exponential(mean, n) or exponential(mean, [n, m, ...]) returns array
+ of random numbers exponentially distributed with specified mean"""
+ if shape == []:
+ shape = None
+ return mt.exponential(mean, shape)
+
+def beta(a, b, shape=[]):
+ """beta(a, b) or beta(a, b, [n, m, ...]) returns array of beta distributed random numbers."""
+ if shape == []:
+ shape = None
+ return mt.beta(a, b, shape)
+
+def gamma(a, r, shape=[]):
+ """gamma(a, r) or gamma(a, r, [n, m, ...]) returns array of gamma distributed random numbers."""
+ if shape == []:
+ shape = None
+ return mt.gamma(a, r, shape)
+
+def F(dfn, dfd, shape=[]):
+ """F(dfn, dfd) or F(dfn, dfd, [n, m, ...]) returns array of F distributed random numbers with dfn degrees of freedom in the numerator and dfd degrees of freedom in the denominator."""
+ if shape == []:
+ shape == None
+ return mt.f(dfn, dfd, shape)
+
+def noncentral_F(dfn, dfd, nconc, shape=[]):
+ """noncentral_F(dfn, dfd, nonc) or noncentral_F(dfn, dfd, nonc, [n, m, ...]) returns array of noncentral F distributed random numbers with dfn degrees of freedom in the numerator and dfd degrees of freedom in the denominator, and noncentrality parameter nconc."""
+ if shape == []:
+ shape = None
+ return mt.noncentral_f(dfn, dfd, nconc, shape)
+
+def chi_square(df, shape=[]):
+ """chi_square(df) or chi_square(df, [n, m, ...]) returns array of chi squared distributed random numbers with df degrees of freedom."""
+ if shape == []:
+ shape = None
+ return mt.chisquare(df, shape)
+
+def noncentral_chi_square(df, nconc, shape=[]):
+ """noncentral_chi_square(df, nconc) or chi_square(df, nconc, [n, m, ...]) returns array of noncentral chi squared distributed random numbers with df degrees of freedom and noncentrality parameter."""
+ if shape == []:
+ shape = None
+ return mt.noncentral_chisquare(df, nconc, shape)
+
+def binomial(trials, p, shape=[]):
+ """binomial(trials, p) or binomial(trials, p, [n, m, ...]) returns array of binomially distributed random integers.
+
+ trials is the number of trials in the binomial distribution.
+ p is the probability of an event in each trial of the binomial distribution."""
+ if shape == []:
+ shape = None
+ return mt.binomial(trials, p, shape)
+
+def negative_binomial(trials, p, shape=[]):
+ """negative_binomial(trials, p) or negative_binomial(trials, p, [n, m, ...]) returns
+ array of negative binomially distributed random integers.
+
+ trials is the number of trials in the negative binomial distribution.
+ p is the probability of an event in each trial of the negative binomial distribution."""
+ if shape == []:
+ shape = None
+ return mt.negative_binomial(trials, p, shape)
+
+def multinomial(trials, probs, shape=[]):
+ """multinomial(trials, probs) or multinomial(trials, probs, [n, m, ...]) returns
+ array of multinomial distributed integer vectors.
+
+ trials is the number of trials in each multinomial distribution.
+ probs is a one dimensional array. There are len(prob)+1 events.
+ prob[i] is the probability of the i-th event, 0<=i<len(prob).
+ The probability of event len(prob) is 1.-Numeric.sum(prob).
+
+ The first form returns a single 1-D array containing one multinomially
+ distributed vector.
+
+ The second form returns an array of shape (m, n, ..., len(probs)).
+ In this case, output[i,j,...,:] is a 1-D array containing a multinomially
+ distributed integer 1-D array."""
+ if shape == []:
+ shape = None
+ return mt.multinomial(trials, probs, shape)
+
+def poisson(mean, shape=[]):
+ """poisson(mean) or poisson(mean, [n, m, ...]) returns array of poisson
+ distributed random integers with specified mean."""
+ if shape == []:
+ shape = None
+ return mt.poisson(mean, shape)
+
+
+def mean_var_test(x, type, mean, var, skew=[]):
+ n = len(x) * 1.0
+ x_mean = Numeric.sum(x,axis=0)/n
+ x_minus_mean = x - x_mean
+ x_var = Numeric.sum(x_minus_mean*x_minus_mean,axis=0)/(n-1.0)
+ print "\nAverage of ", len(x), type
+ print "(should be about ", mean, "):", x_mean
+ print "Variance of those random numbers (should be about ", var, "):", x_var
+ if skew != []:
+ x_skew = (Numeric.sum(x_minus_mean*x_minus_mean*x_minus_mean,axis=0)/9998.)/x_var**(3./2.)
+ print "Skewness of those random numbers (should be about ", skew, "):", x_skew
+
+def test():
+ obj = mt.get_state()
+ mt.set_state(obj)
+ obj2 = mt.get_state()
+ if (obj2[1] - obj[1]).any():
+ raise SystemExit, "Failed seed test."
+ print "First random number is", random()
+ print "Average of 10000 random numbers is", Numeric.sum(random(10000),axis=0)/10000.
+ x = random([10,1000])
+ if len(x.shape) != 2 or x.shape[0] != 10 or x.shape[1] != 1000:
+ raise SystemExit, "random returned wrong shape"
+ x.shape = (10000,)
+ print "Average of 100 by 100 random numbers is", Numeric.sum(x,axis=0)/10000.
+ y = uniform(0.5,0.6, (1000,10))
+ if len(y.shape) !=2 or y.shape[0] != 1000 or y.shape[1] != 10:
+ raise SystemExit, "uniform returned wrong shape"
+ y.shape = (10000,)
+ if Numeric.minimum.reduce(y) <= 0.5 or Numeric.maximum.reduce(y) >= 0.6:
+ raise SystemExit, "uniform returned out of desired range"
+ print "randint(1, 10, shape=[50])"
+ print randint(1, 10, shape=[50])
+ print "permutation(10)", permutation(10)
+ print "randint(3,9)", randint(3,9)
+ print "random_integers(10, shape=[20])"
+ print random_integers(10, shape=[20])
+ s = 3.0
+ x = normal(2.0, s, [10, 1000])
+ if len(x.shape) != 2 or x.shape[0] != 10 or x.shape[1] != 1000:
+ raise SystemExit, "standard_normal returned wrong shape"
+ x.shape = (10000,)
+ mean_var_test(x, "normally distributed numbers with mean 2 and variance %f"%(s**2,), 2, s**2, 0)
+ x = exponential(3, 10000)
+ mean_var_test(x, "random numbers exponentially distributed with mean %f"%(s,), s, s**2, 2)
+ x = multivariate_normal(Numeric.array([10,20]), Numeric.array(([1,2],[2,4])))
+ print "\nA multivariate normal", x
+ if x.shape != (2,): raise SystemExit, "multivariate_normal returned wrong shape"
+ x = multivariate_normal(Numeric.array([10,20]), Numeric.array([[1,2],[2,4]]), [4,3])
+ print "A 4x3x2 array containing multivariate normals"
+ print x
+ if x.shape != (4,3,2): raise SystemExit, "multivariate_normal returned wrong shape"
+ x = multivariate_normal(Numeric.array([-100,0,100]), Numeric.array([[3,2,1],[2,2,1],[1,1,1]]), 10000)
+ x_mean = Numeric.sum(x,axis=0)/10000.
+ print "Average of 10000 multivariate normals with mean [-100,0,100]"
+ print x_mean
+ x_minus_mean = x - x_mean
+ print "Estimated covariance of 10000 multivariate normals with covariance [[3,2,1],[2,2,1],[1,1,1]]"
+ print Numeric.dot(Numeric.transpose(x_minus_mean),x_minus_mean)/9999.
+ x = beta(5.0, 10.0, 10000)
+ mean_var_test(x, "beta(5.,10.) random numbers", 0.333, 0.014)
+ x = gamma(.01, 2., 10000)
+ mean_var_test(x, "gamma(.01,2.) random numbers", 2*100, 2*100*100)
+ x = chi_square(11., 10000)
+ mean_var_test(x, "chi squared random numbers with 11 degrees of freedom", 11, 22, 2*Numeric.sqrt(2./11.))
+ x = F(5., 10., 10000)
+ mean_var_test(x, "F random numbers with 5 and 10 degrees of freedom", 1.25, 1.35)
+ x = poisson(50., 10000)
+ mean_var_test(x, "poisson random numbers with mean 50", 50, 50, 0.14)
+ print "\nEach element is the result of 16 binomial trials with probability 0.5:"
+ print binomial(16, 0.5, 16)
+ print "\nEach element is the result of 16 negative binomial trials with probability 0.5:"
+ print negative_binomial(16, 0.5, [16,])
+ print "\nEach row is the result of 16 multinomial trials with probabilities [0.1, 0.5, 0.1 0.3]:"
+ x = multinomial(16, [0.1, 0.5, 0.1], 8)
+ print x
+ print "Mean = ", Numeric.sum(x,axis=0)/8.
+
+if __name__ == '__main__':
+ test()
diff --git a/numpy/oldnumeric/rng.py b/numpy/oldnumeric/rng.py
new file mode 100644
index 000000000..fcf08bb37
--- /dev/null
+++ b/numpy/oldnumeric/rng.py
@@ -0,0 +1,135 @@
+# This module re-creates the RNG interface from Numeric
+# Replace import RNG with import numpy.oldnumeric.rng as RNG
+#
+# It is for backwards compatibility only.
+
+
+__all__ = ['CreateGenerator','ExponentialDistribution','LogNormalDistribution','NormalDistribution',
+ 'UniformDistribution', 'error', 'default_distribution', 'random_sample', 'ranf',
+ 'standard_generator']
+
+import numpy.random.mtrand as mt
+import math
+
+class error(Exception):
+ pass
+
+class Distribution(object):
+ def __init__(self, meth, *args):
+ self._meth = meth
+ self._args = args
+
+ def density(self,x):
+ raise NotImplementedError
+
+ def __call__(self, x):
+ return self.density(x)
+
+ def _onesample(self, rng):
+ return getattr(rng, self._meth)(*self._args)
+
+ def _sample(self, rng, n):
+ kwds = {'size' : n}
+ return getattr(rng, self._meth)(*self._args, **kwds)
+
+
+class ExponentialDistribution(Distribution):
+ def __init__(self, lambda_):
+ if (lambda_ <= 0):
+ raise error, "parameter must be positive"
+ Distribution.__init__(self, 'exponential', lambda_)
+
+ def density(x):
+ if x < 0:
+ return 0.0
+ else:
+ lambda_ = self._args[0]
+ return lambda_*exp(-lambda_*x)
+
+class LogNormalDistribution(Distribution):
+ def __init__(self, m, s):
+ m = float(m)
+ s = float(s)
+ if (s <= 0):
+ raise error, "standard deviation must be positive"
+ Distribution.__init__(self, 'lognormal', m, s)
+ sn = math.log(1.0+s*s/(m*m));
+ self._mn = math.log(m)-0.5*sn
+ self._sn = math.sqrt(sn)
+ self._fac = 1.0/math.sqrt(2*math.pi)/self._sn
+
+ def density(x):
+ m,s = self._args
+ y = (math.log(x)-self._mn)/self._sn
+ return self._fac*exp(-0.5*y*y)/x
+
+
+class NormalDistribution(Distribution):
+ def __init__(self, m, s):
+ m = float(m)
+ s = float(s)
+ if (s <= 0):
+ raise error, "standard deviation must be positive"
+ Distribution.__init__(self, 'normal', m, s)
+ self._fac = 1.0/math.sqrt(2*math.pi)/s
+
+ def density(x):
+ m,s = self._args
+ y = (x-m)/s
+ return self._fac*exp(-0.5*y*y)
+
+class UniformDistribution(Distribution):
+ def __init__(self, a, b):
+ a = float(a)
+ b = float(b)
+ width = b-a
+ if (width <=0):
+ raise error, "width of uniform distribution must be > 0"
+ Distribution.__init__(self, 'uniform', a, b)
+ self._fac = 1.0/width
+
+ def density(x):
+ a, b = self._args
+ if (x < a) or (x >= b):
+ return 0.0
+ else:
+ return self._fac
+
+default_distribution = UniformDistribution(0.0,1.0)
+
+class CreateGenerator(object):
+ def __init__(self, seed, dist=None):
+ if seed <= 0:
+ self._rng = mt.RandomState()
+ elif seed > 0:
+ self._rng = mt.RandomState(seed)
+ if dist is None:
+ dist = default_distribution
+ if not isinstance(dist, Distribution):
+ raise error, "Not a distribution object"
+ self._dist = dist
+
+ def ranf(self):
+ return self._dist._onesample(self._rng)
+
+ def sample(self, n):
+ return self._dist._sample(self._rng, n)
+
+
+standard_generator = CreateGenerator(-1)
+
+def ranf():
+ "ranf() = a random number from the standard generator."
+ return standard_generator.ranf()
+
+def random_sample(*n):
+ """random_sample(n) = array of n random numbers;
+
+ random_sample(n1, n2, ...)= random array of shape (n1, n2, ..)"""
+
+ if not n:
+ return standard_generator.ranf()
+ m = 1
+ for i in n:
+ m = m * i
+ return standard_generator.sample(m).reshape(*n)
diff --git a/numpy/oldnumeric/rng_stats.py b/numpy/oldnumeric/rng_stats.py
new file mode 100644
index 000000000..8c7fec433
--- /dev/null
+++ b/numpy/oldnumeric/rng_stats.py
@@ -0,0 +1,35 @@
+
+__all__ = ['average', 'histogram', 'standardDeviation', 'variance']
+
+import numpy.oldnumeric as Numeric
+
+def average(data):
+ data = Numeric.array(data)
+ return Numeric.add.reduce(data)/len(data)
+
+def variance(data):
+ data = Numeric.array(data)
+ return Numeric.add.reduce((data-average(data,axis=0))**2)/(len(data)-1)
+
+def standardDeviation(data):
+ data = Numeric.array(data)
+ return Numeric.sqrt(variance(data))
+
+def histogram(data, nbins, range = None):
+ data = Numeric.array(data, Numeric.Float)
+ if range is None:
+ min = Numeric.minimum.reduce(data)
+ max = Numeric.maximum.reduce(data)
+ else:
+ min, max = range
+ data = Numeric.repeat(data,
+ Numeric.logical_and(Numeric.less_equal(data, max),
+ Numeric.greater_equal(data,
+ min)),axis=0)
+ bin_width = (max-min)/nbins
+ data = Numeric.floor((data - min)/bin_width).astype(Numeric.Int)
+ histo = Numeric.add.reduce(Numeric.equal(
+ Numeric.arange(nbins)[:,Numeric.NewAxis], data), -1)
+ histo[-1] = histo[-1] + Numeric.add.reduce(Numeric.equal(nbins, data))
+ bins = min + bin_width*(Numeric.arange(nbins)+0.5)
+ return Numeric.transpose(Numeric.array([bins, histo]))
diff --git a/numpy/oldnumeric/setup.py b/numpy/oldnumeric/setup.py
new file mode 100644
index 000000000..82e8a6201
--- /dev/null
+++ b/numpy/oldnumeric/setup.py
@@ -0,0 +1,8 @@
+
+def configuration(parent_package='',top_path=None):
+ from numpy.distutils.misc_util import Configuration
+ return Configuration('oldnumeric',parent_package,top_path)
+
+if __name__ == '__main__':
+ from numpy.distutils.core import setup
+ setup(configuration=configuration)
diff --git a/numpy/oldnumeric/tests/test_oldnumeric.py b/numpy/oldnumeric/tests/test_oldnumeric.py
new file mode 100644
index 000000000..628ec231f
--- /dev/null
+++ b/numpy/oldnumeric/tests/test_oldnumeric.py
@@ -0,0 +1,86 @@
+from numpy.testing import *
+
+from numpy import array
+from numpy.oldnumeric import *
+from numpy.core.numeric import float32, float64, complex64, complex128, int8, \
+ int16, int32, int64, uint, uint8, uint16, uint32, uint64
+
+class test_oldtypes(NumPyTestCase):
+ def check_oldtypes(self, level=1):
+ a1 = array([0,1,0], Float)
+ a2 = array([0,1,0], float)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Float8)
+ a2 = array([0,1,0], float)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Float16)
+ a2 = array([0,1,0], float)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Float32)
+ a2 = array([0,1,0], float32)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Float64)
+ a2 = array([0,1,0], float64)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Complex)
+ a2 = array([0,1,0], complex)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Complex8)
+ a2 = array([0,1,0], complex)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Complex16)
+ a2 = array([0,1,0], complex)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Complex32)
+ a2 = array([0,1,0], complex64)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Complex64)
+ a2 = array([0,1,0], complex128)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Int)
+ a2 = array([0,1,0], int)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Int8)
+ a2 = array([0,1,0], int8)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Int16)
+ a2 = array([0,1,0], int16)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Int32)
+ a2 = array([0,1,0], int32)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], Int64)
+ a2 = array([0,1,0], int64)
+ assert_array_equal(a1, a2)
+ a1 = array([0,1,0], UnsignedInt)
+ a2 = array([0,1,0], UnsignedInteger)
+ a3 = array([0,1,0], uint)
+ assert_array_equal(a1, a3)
+ assert_array_equal(a2, a3)
+ a1 = array([0,1,0], UInt8)
+ a2 = array([0,1,0], UnsignedInt8)
+ a3 = array([0,1,0], uint8)
+ assert_array_equal(a1, a3)
+ assert_array_equal(a2, a3)
+ a1 = array([0,1,0], UInt16)
+ a2 = array([0,1,0], UnsignedInt16)
+ a3 = array([0,1,0], uint16)
+ assert_array_equal(a1, a3)
+ assert_array_equal(a2, a3)
+ a1 = array([0,1,0], UInt32)
+ a2 = array([0,1,0], UnsignedInt32)
+ a3 = array([0,1,0], uint32)
+ assert_array_equal(a1, a3)
+ assert_array_equal(a2, a3)
+ a1 = array([0,1,0], UInt64)
+ a2 = array([0,1,0], UnsignedInt64)
+ a3 = array([0,1,0], uint64)
+ assert_array_equal(a1, a3)
+ assert_array_equal(a2, a3)
+ a1 = array([0,1,0], Bool)
+ a2 = array([0,1,0], bool)
+ assert_array_equal(a1, a2)
+
+
+if __name__ == "__main__":
+ NumPyTest().run()
diff --git a/numpy/oldnumeric/typeconv.py b/numpy/oldnumeric/typeconv.py
new file mode 100644
index 000000000..1fbf1e072
--- /dev/null
+++ b/numpy/oldnumeric/typeconv.py
@@ -0,0 +1,60 @@
+__all__ = ['oldtype2dtype', 'convtypecode', 'convtypecode2', 'oldtypecodes']
+
+import numpy as N
+
+oldtype2dtype = {'1': N.dtype(N.byte),
+ 's': N.dtype(N.short),
+# 'i': N.dtype(N.intc),
+# 'l': N.dtype(int),
+# 'b': N.dtype(N.ubyte),
+ 'w': N.dtype(N.ushort),
+ 'u': N.dtype(N.uintc),
+# 'f': N.dtype(N.single),
+# 'd': N.dtype(float),
+# 'F': N.dtype(N.csingle),
+# 'D': N.dtype(complex),
+# 'O': N.dtype(object),
+# 'c': N.dtype('c'),
+ None:N.dtype(int)
+ }
+
+# converts typecode=None to int
+def convtypecode(typecode, dtype=None):
+ if dtype is None:
+ try:
+ return oldtype2dtype[typecode]
+ except:
+ return N.dtype(typecode)
+ else:
+ return dtype
+
+#if both typecode and dtype are None
+# return None
+def convtypecode2(typecode, dtype=None):
+ if dtype is None:
+ if typecode is None:
+ return None
+ else:
+ try:
+ return oldtype2dtype[typecode]
+ except:
+ return N.dtype(typecode)
+ else:
+ return dtype
+
+_changedtypes = {'B': 'b',
+ 'b': '1',
+ 'h': 's',
+ 'H': 'w',
+ 'I': 'u'}
+
+class _oldtypecodes(dict):
+ def __getitem__(self, obj):
+ char = N.dtype(obj).char
+ try:
+ return _changedtypes[char]
+ except KeyError:
+ return char
+
+
+oldtypecodes = _oldtypecodes()
diff --git a/numpy/oldnumeric/ufuncs.py b/numpy/oldnumeric/ufuncs.py
new file mode 100644
index 000000000..c26050f55
--- /dev/null
+++ b/numpy/oldnumeric/ufuncs.py
@@ -0,0 +1,19 @@
+__all__ = ['less', 'cosh', 'arcsinh', 'add', 'ceil', 'arctan2', 'floor_divide',
+ 'fmod', 'hypot', 'logical_and', 'power', 'sinh', 'remainder', 'cos',
+ 'equal', 'arccos', 'less_equal', 'divide', 'bitwise_or',
+ 'bitwise_and', 'logical_xor', 'log', 'subtract', 'invert',
+ 'negative', 'log10', 'arcsin', 'arctanh', 'logical_not',
+ 'not_equal', 'tanh', 'true_divide', 'maximum', 'arccosh',
+ 'logical_or', 'minimum', 'conjugate', 'tan', 'greater',
+ 'bitwise_xor', 'fabs', 'floor', 'sqrt', 'arctan', 'right_shift',
+ 'absolute', 'sin', 'multiply', 'greater_equal', 'left_shift',
+ 'exp', 'divide_safe']
+
+from numpy import less, cosh, arcsinh, add, ceil, arctan2, floor_divide, \
+ fmod, hypot, logical_and, power, sinh, remainder, cos, \
+ equal, arccos, less_equal, divide, bitwise_or, bitwise_and, \
+ logical_xor, log, subtract, invert, negative, log10, arcsin, \
+ arctanh, logical_not, not_equal, tanh, true_divide, maximum, \
+ arccosh, logical_or, minimum, conjugate, tan, greater, bitwise_xor, \
+ fabs, floor, sqrt, arctan, right_shift, absolute, sin, \
+ multiply, greater_equal, left_shift, exp, divide as divide_safe
diff --git a/numpy/oldnumeric/user_array.py b/numpy/oldnumeric/user_array.py
new file mode 100644
index 000000000..375c4013b
--- /dev/null
+++ b/numpy/oldnumeric/user_array.py
@@ -0,0 +1,9 @@
+
+
+from numpy.oldnumeric import *
+from numpy.lib.user_array import container as UserArray
+
+import numpy.oldnumeric as nold
+__all__ = nold.__all__[:]
+__all__ += ['UserArray']
+del nold
View Lorry Controller Status