Fix imports in the numpy/oldnumeric/mlab.py module.  The problem was
that the module used imports of the form

from . import compat

which do not work as '.' is apparently undefined when the module import
is attempted. The fix is ugly, but it works and the oldnumeric module is
going away in 1.9.

Closes #3803.

Run the 2to3 ws_comma fixer on *.py files. Some lines are now too long
and will need to be broken at some point. OTOH, some lines were already
too long and need to be broken at some point. Now seems as good a time
as any to do this with open PRs at a minimum.

Now is as good a time as any with open PR's at a low.

The numarray and oldnumeric modules are deprecated. This is a bit tricky
as raising a DeprecationWarning on import causes an error when tests are
run. To deal with that, a ModuleDeprecationWarning class is added to
numpy and NoseTester is modified to ignore that warning during testing.

Closes #2905

The idioms fixer makes the following replacements.

1) int <- bool
2) comparison or identity of types <- isinstance
3) a.sort() <- sorted(a)

There were two problems that needed to be dealt with after the
application of the fixer. First, the replacement of comparison or
identity of types by isinstance was not always correct.  The isinstance
function returns true for subtypes whereas many of the places where the
fixer made a substitution needed to check for exact type equality.
Second, the sorted function was applied to arrays, but because it treats
them as iterators and constructs a sorted list from the result, that is
the wrong thing to do.

Closes #3062.

Python 3 removes the builtin types from the types module. The types
fixer replaces such references with the builtin types where possible
and also takes care of some special cases:

    types.TypeNone           <- type(None)
    types.NotImplementedType <- type(NotImplemented)
    types.EllipsisType       <- type(Ellipsis)

The only two tricky substitutions are

    types.StringType         <- bytes
    types.LongType           <- int

These are fixed up to support both Python 3 and Python 2 code by
importing the long and bytes types from numpy.compat.

Closes #3240.

2to3: Apply nonzero fixer.

In Python 3 the `__nonzero__` class method is replaced by `__bool__`.
This only affects the MaskedArray class in numpy/oldnumeric/ma.py file
and the simplest solution is to provide both methods. I have my doubts
that the fixed up Python 3 version was correct or even tested, but I
think the current solution should work for as long as oldnumeric stays
in numpy.

Closes #3073.

Rename sys.maxint to sys.maxsize when the Python version is >= 3.  This
change was made in Python 3 because all integers are 'long' integers and
their maximum value bears no relationship to the C type that int used to
represent. The new sys.maxsize value is the maximum value of Py_ssize_t.
This change has not led to any reported problems since the numpy 1.5
release.

Closes #3082

In Python 3 `map` is an iterator while in Python 2 it returns a list.
The simple fix applied by the fixer is to inclose all instances of map
with `list(...)`. This is not needed in all cases, and even where
appropriate list comprehensions may be preferred for their clarity.
Consequently, this patch attempts to use list comprehensions where it
makes sense.

When the mapped function has two arguments there is another problem that
can arise. In Python 3 map stops execution when the shortest argument
list is exhausted, while in Python 2 it stops when the longest argument
list is exhausted. Consequently the two argument case might need special
care. However, we have been running Python3 converted versions of numpy
since 1.5 without problems, so it is probably not something that affects
us.

Closes #3068