From numpy-svn at scipy.org  Fri Feb  1 06:18:01 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  1 Feb 2008 05:18:01 -0600 (CST)
Subject: [Numpy-svn] r4766 - trunk/numpy/core/tests
Message-ID: <20080201111801.2E04839C442@new.scipy.org>

Author: stefan
Date: 2008-02-01 05:17:39 -0600 (Fri, 01 Feb 2008)
New Revision: 4766

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Add regression test for searchsorted on variable-length arrays.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2008-01-31 19:19:26 UTC (rev 4765)
+++ trunk/numpy/core/tests/test_regression.py	2008-02-01 11:17:39 UTC (rev 4766)
@@ -775,5 +775,10 @@
         assert_equal(np.fromstring("12:09:09", dtype=int, sep=":"),
                      [12,9,9])
 
+    def check_searchsorted_variable_length(self, level=rlevel):
+        x = np.array(['a','aa','b'])
+        y = np.array(['d','e'])
+        assert_equal(x.searchsorted(y), [3,3])
+
 if __name__ == "__main__":
     NumpyTest().run()



From numpy-svn at scipy.org  Fri Feb  1 18:40:40 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  1 Feb 2008 17:40:40 -0600 (CST)
Subject: [Numpy-svn] r4767 - in branches/maskedarray/numpy/ma: . tests
Message-ID: <20080201234040.70CB239C013@new.scipy.org>

Author: pierregm
Date: 2008-02-01 17:40:35 -0600 (Fri, 01 Feb 2008)
New Revision: 4767

Modified:
   branches/maskedarray/numpy/ma/core.py
   branches/maskedarray/numpy/ma/mrecords.py
   branches/maskedarray/numpy/ma/tests/test_core.py
   branches/maskedarray/numpy/ma/tests/test_mrecords.py
Log:
maskedarray.core:
tolist : make sure that a masked record is output as a tuple of None

maskedarray.mrecords:
* introduced mrecarray as the equivalent of recarray w/ fieldmask
* simplified fromarrays/fromrecords

Modified: branches/maskedarray/numpy/ma/core.py
===================================================================
--- branches/maskedarray/numpy/ma/core.py	2008-02-01 11:17:39 UTC (rev 4766)
+++ branches/maskedarray/numpy/ma/core.py	2008-02-01 23:40:35 UTC (rev 4767)
@@ -191,8 +191,8 @@
         else:
             fill_value = default_fill_value(dtype)
     else:
-        fval = numpy.resize(narray(fill_value,copy=False,dtype=object_),
-                            len(descr))
+        fill_value = narray(fill_value).tolist() 
+        fval = numpy.resize(fill_value, len(descr))
         if len(descr) > 1:
             fill_value = [numpy.asarray(f).astype(d[1]).item()
                           for (f,d) in zip(fval, descr)]
@@ -2491,15 +2491,23 @@
         if fill_value is not None:
             return self.filled(fill_value).tolist()
         result = self.filled().tolist()
-        if self._mask is nomask:
+        # Set temps to save time when dealing w/ mrecarrays...
+        _mask = self._mask
+        if _mask is nomask:
             return result
-        if self.ndim == 0:
-            return [None]
-        elif self.ndim == 1:
-            maskedidx = self._mask.nonzero()[0].tolist()
-            [operator.setitem(result,i,None) for i in maskedidx]
+        nbdims = self.ndim
+        dtypesize = len(self.dtype)
+        if nbdims == 0:
+            return tuple([None]*dtypesize)
+        elif nbdims == 1:
+            maskedidx = _mask.nonzero()[0].tolist()
+            if dtypesize:
+                nodata = tuple([None]*dtypesize)
+            else:
+                nodata = None
+            [operator.setitem(result,i,nodata) for i in maskedidx]
         else:
-            for idx in zip(*[i.tolist() for i in self._mask.nonzero()]):
+            for idx in zip(*[i.tolist() for i in _mask.nonzero()]):
                 tmp = result
                 for i in idx[:-1]:
                     tmp = tmp[i]

Modified: branches/maskedarray/numpy/ma/mrecords.py
===================================================================
--- branches/maskedarray/numpy/ma/mrecords.py	2008-02-01 11:17:39 UTC (rev 4766)
+++ branches/maskedarray/numpy/ma/mrecords.py	2008-02-01 23:40:35 UTC (rev 4767)
@@ -1,35 +1,49 @@
 """mrecords
-Defines a class of record arrays supporting masked arrays.
 
+Defines the equivalent of recarrays for maskedarray.
+Masked arrays already support named fields, but masking works only by records.
+By comparison, mrecarrays support masking individual fields.
+
 :author: Pierre Gerard-Marchant
 """
+#TODO: We should make sure that no field is called '_mask','mask','_fieldmask',
+#TODO: ...or whatever restricted keywords.
+#TODO: An idea would be to no bother in the first place, and then rename the
+#TODO: invalid fields with a trailing underscore...
+#TODO: Maybe we could just overload the parser function ?
+
+
 __author__ = "Pierre GF Gerard-Marchant"
 
 import sys
 import types
 
 import numpy
-from numpy import bool_, complex_, float_, int_, str_, object_
+from numpy import bool_, complex_, float_, int_, str_, object_, dtype
 from numpy import array as narray
 import numpy.core.numeric as numeric
 import numpy.core.numerictypes as ntypes
 from numpy.core.defchararray import chararray
-from numpy.core.records import find_duplicate
-
-from numpy.core.records import format_parser, record, recarray
+from numpy.core.records import find_duplicate, format_parser, record, recarray
 from numpy.core.records import fromarrays as recfromarrays
+from numpy.core.records import fromrecords as recfromrecords
 
 ndarray = numeric.ndarray
 _byteorderconv = numpy.core.records._byteorderconv
 _typestr = ntypes._typestr
 
 import numpy.ma
-from numpy.ma import MaskedArray, masked, nomask, masked_array,\
-    make_mask, mask_or, getmask, getmaskarray, filled
+from numpy.ma import MAError, MaskedArray, masked, nomask, masked_array,\
+    make_mask, mask_or, getdata, getmask, getmaskarray, filled
 from numpy.ma.core import default_fill_value, masked_print_option
+_check_fill_value = numpy.ma.core._check_fill_value
 
 import warnings
 
+__all__ = ['MaskedRecords','mrecarray',
+           'fromarrays','fromrecords','fromtextfile','addfield',
+           ]
+
 reserved_fields = ['_data','_mask','_fieldmask', 'dtype']
 
 def _getformats(data):
@@ -80,7 +94,13 @@
     return numeric.dtype(ndescr)
 
 
+def _get_fieldmask(self):
+    mdescr = [(n,'|b1') for n in self.dtype.names]
+    fdmask = numpy.empty(self.shape, dtype=mdescr)
+    fdmask.flat = tuple([False]*len(mdescr))
+    return fdmask
 
+
 class MaskedRecords(MaskedArray, object):
     """
 
@@ -96,89 +116,131 @@
     """
     _defaultfieldmask = nomask
     _defaulthardmask = False
-    def __new__(cls, data, mask=nomask, dtype=None,
-                hard_mask=False, fill_value=None,
-#                offset=0, strides=None,
+    #............................................
+    def __new__(cls, shape, dtype=None, buf=None, offset=0, strides=None,
                 formats=None, names=None, titles=None,
-                byteorder=None, aligned=False):
-        # Get the new descriptor ................
-        if dtype is not None:
-            descr = numeric.dtype(dtype)
+                byteorder=None, aligned=False,
+                mask=nomask, hard_mask=False, fill_value=None, keep_mask=True,
+                copy=False,
+                **options):
+        #
+        self = recarray.__new__(cls, shape, dtype=dtype, buf=buf, offset=offset,
+                                strides=strides, formats=formats,
+                                byteorder=byteorder, aligned=aligned,)
+#        self = self.view(cls)
+        #
+        mdtype = [(k,'|b1') for (k,_) in self.dtype.descr]
+        if mask is nomask or not numpy.size(mask):
+            if not keep_mask:
+                self._fieldmask = tuple([False]*len(mdtype))
         else:
-            if formats is None:
-                formats = _getformats(data)
-            parsed = format_parser(formats, names, titles, aligned, byteorder)
-            descr = parsed._descr
-        if names is not None:
-            descr = _checknames(descr,names)
-        _names = descr.names
-        mdescr = [(n,'|b1') for n in _names]
-        # get the shape .........................
-        try:
-            shape = numeric.asarray(data[0]).shape
-        except IndexError:
-            shape = len(data.dtype)
-        if isinstance(shape, int):
-            shape = (shape,)
-        # Construct the _data recarray ..........
-        if isinstance(data, record):
-            _data = numeric.asarray(data).view(recarray)
-            _fieldmask = mask
-        elif isinstance(data, MaskedRecords):
-            _data = data._data
-            _fieldmask = data._fieldmask
-        elif isinstance(data, recarray):
-            _data = data
-            if mask is nomask:
-                _fieldmask = data.astype(mdescr)
-                _fieldmask.flat = tuple([False]*len(mdescr))
+            mask = narray(mask, copy=copy)
+            if mask.shape != self.shape:
+                (nd, nm) = (self.size, mask.size)
+                if nm == 1:
+                    mask = numpy.resize(mask, self.shape)
+                elif nm == nd:
+                    mask = numpy.reshape(mask, self.shape)
+                else:
+                    msg = "Mask and data not compatible: data size is %i, "+\
+                          "mask size is %i."
+                    raise MAError(msg % (nd, nm))
+                copy = True        
+            if not keep_mask:
+                self.__setmask__(mask)
+                self._sharedmask = True
             else:
-                _fieldmask = mask
-        elif (isinstance(data, (tuple, numpy.void)) or\
-              hasattr(data,'__len__') and isinstance(data[0], (tuple, numpy.void))):
-            data = numeric.array(data, dtype=descr).view(recarray)
-            _data = data
-            if mask is nomask:
-                _fieldmask = data.astype(mdescr)
-                _fieldmask.flat = tuple([False]*len(mdescr))
-            else:
-                _fieldmask = mask
-        else:
-            _data = recarray(shape, dtype=descr)
-            _fieldmask = recarray(shape, dtype=mdescr)
-            for (n,v) in zip(_names, data):
-                _data[n] = numeric.asarray(v).view(ndarray)
-                _fieldmask[n] = getmaskarray(v)
-        #........................................
-        _data = _data.view(cls)
-        _data._fieldmask = _fieldmask
-        _data._hardmask = hard_mask
-        if fill_value is None:
-            _data._fill_value = [default_fill_value(numeric.dtype(d[1]))
-                                 for d in descr.descr]
-        else:
-            _data._fill_value = fill_value
-        return _data
-
+                if mask.dtype == mdtype:
+                    _fieldmask = mask
+                else:
+                    _fieldmask = narray([tuple([m]*len(mdtype)) for m in mask],
+                                        dtype=mdtype)
+                self._fieldmask = _fieldmask
+        return self
+    #......................................................
     def __array_finalize__(self,obj):
-        if isinstance(obj, MaskedRecords):
-            self.__dict__.update(_fieldmask=obj._fieldmask,
-                                 _hardmask=obj._hardmask,
-                                 _fill_value=obj._fill_value
-                                 )
-        else:
-            self.__dict__.update(_fieldmask = nomask,
-                                 _hardmask = False,
-                                 fill_value = None
-                                )
+        # Make sure we have a _fieldmask by default ..
+        _fieldmask = getattr(obj, '_fieldmask', None)
+        if _fieldmask is None:
+            mdescr = [(n,'|b1') for (n,_) in self.dtype.descr]
+            _fieldmask = numpy.empty(self.shape, dtype=mdescr).view(recarray)
+            _fieldmask.flat = tuple([False]*len(mdescr))
+        # Update some of the attributes
+        attrdict = dict(_fieldmask=_fieldmask,
+                        _hardmask=getattr(obj,'_hardmask',False),
+                        _fill_value=getattr(obj,'_fill_value',None))
+        self.__dict__.update(attrdict)
+        # Finalize as a regular maskedarray .....
+        # Note: we can't call MaskedArray.__array_finalize__, it chokes pickling
+        self._update_from(obj)
+        # Update special attributes ...
+        self._basedict = getattr(obj, '_basedict', getattr(obj, '__dict__', None))
+        if self._basedict is not None:
+            self.__dict__.update(self._basedict)
         return
-
+    #......................................................
     def _getdata(self):
         "Returns the data as a recarray."
         return self.view(recarray)
     _data = property(fget=_getdata)
+    #......................................................
+    def __setmask__(self, mask):
+        "Sets the mask and update the fieldmask."
+        names = self.dtype.names
+        fmask = self.__dict__['_fieldmask']
+        newmask = make_mask(mask, copy=False)
+        if names is not None:
+            if self._hardmask:
+                for n in names:
+                    fmask[n].__ior__(newmask)
+            else:
+                for n in names:
+                    fmask[n].flat = newmask
+        return
+    _setmask = __setmask__
+    #
+    def _getmask(self):
+        """Return the mask of the mrecord.
+    A record is masked when all the fields are masked.
+        
+        """
+        if self.size > 1:
+            return self._fieldmask.view((bool_, len(self.dtype))).all(1)
+        else:
+            return self._fieldmask.view((bool_, len(self.dtype))).all()
+    _mask = property(fget=_getmask, fset=_setmask)
+    #......................................................
+    def get_fill_value(self):
+        """Return the filling value.
 
+        """
+        if self._fill_value is None:
+            ddtype = self.dtype
+            fillval = _check_fill_value(None, ddtype)
+            self._fill_value = narray(tuple(fillval), dtype=ddtype)
+        return self._fill_value
+
+    def set_fill_value(self, value=None):
+        """Set the filling value to value.
+
+        If value is None, use a default based on the data type.
+
+        """
+        ddtype = self.dtype
+        fillval = _check_fill_value(value, ddtype)
+        self._fill_value = narray(tuple(fillval), dtype=ddtype)
+
+    fill_value = property(fget=get_fill_value, fset=set_fill_value,
+                          doc="Filling value.")
     #......................................................
+    def __len__(self):
+        "Returns the length"
+        # We have more than one record
+        if self.ndim:
+            return len(self._data)
+        # We have only one record: return the nb of fields
+        return len(self.dtype)
+    #......................................................
     def __getattribute__(self, attr):
         "Returns the given attribute."
         try:
@@ -215,7 +277,15 @@
                 exctype, value = sys.exc_info()[:2]
                 raise exctype, value
         else:
-            if attr not in list(self.dtype.names) + ['_mask','mask']:
+            # Get the list of names ......
+            _names = self.dtype.names
+            if _names is None:
+                _names = []
+            else:
+                _names = list(_names)
+            _names += ['_mask','mask']
+            # Check the attribute
+            if attr not in _names:
                 return ret
             if newattr:         # We just added this one
                 try:            #  or this setattr worked on an internal
@@ -227,14 +297,26 @@
         base_fmask = self._fieldmask
         _names = self.dtype.names
         if attr in _names:
-            fval = filled(val)
-            mval = getmaskarray(val)
+            if val is masked:
+                fval = self.fill_value[attr]
+                mval = True
+            else:
+                fval = filled(val)
+                mval = getmaskarray(val)
             if self._hardmask:
                 mval = mask_or(mval, base_fmask.__getattr__(attr))
             self._data.__setattr__(attr, fval)
             base_fmask.__setattr__(attr, mval)
             return
         elif attr == '_mask':
+            #FIXME: We should check for self._harmask over there.
+#            if self._hardmask:
+#                val = make_mask(val)
+#                if val is not nomask:
+##                    mval = getmaskarray(val)
+#                    for k in _names:
+#                        m = mask_or(val, base_fmask.__getattr__(k))
+#                        base_fmask.__setattr__(k, m)
             self.__setmask__(val)
             return
     #............................................
@@ -242,30 +324,29 @@
         """Returns all the fields sharing the same fieldname base.
 The fieldname base is either `_data` or `_mask`."""
         _localdict = self.__dict__
+        _fieldmask = _localdict['_fieldmask']
         _data = self._data
         # We want a field ........
         if isinstance(indx, basestring):
             obj = _data[indx].view(MaskedArray)
-            obj._set_mask(_localdict['_fieldmask'][indx])
+            obj._set_mask(_fieldmask[indx])
             # Force to nomask if the mask is empty
             if not obj._mask.any():
                 obj._mask = nomask
+            # Force to masked if the mask is True
+            if not obj.ndim and obj._mask:
+                return masked
             return obj
         # We want some elements ..
         # First, the data ........
-        obj = ndarray.__getitem__(self, indx)
-        if isinstance(obj, numpy.void):
-            obj = self.__class__(obj, dtype=self.dtype)
-        else:
-            obj = obj.view(type(self))
-        obj._fieldmask = numpy.asarray(_localdict['_fieldmask'][indx]).view(recarray)
+        obj = narray(_data[indx], copy=False).view(mrecarray)
+        obj._fieldmask = narray(_fieldmask[indx], copy=False).view(recarray)
         return obj
-    #............................................
+    #....
     def __setitem__(self, indx, value):
         "Sets the given record to value."
         MaskedArray.__setitem__(self, indx, value)
-
-
+    #............................................
     def __setslice__(self, i, j, value):
         "Sets the slice described by [i,j] to `value`."
         _localdict = self.__dict__
@@ -295,31 +376,6 @@
                     d[n][i:j][~mval] = dval[~mval]
                     m[n][i:j] = mask_or(m[n][i:j], mval)
         self._fieldmask = m
-
-    #.....................................................
-    def __setmask__(self, mask):
-        "Sets the mask."
-        names = self.dtype.names
-        fmask = self.__dict__['_fieldmask']
-        newmask = make_mask(mask, copy=False)
-#        self.unshare_mask()
-        if self._hardmask:
-            for n in names:
-                fmask[n].__ior__(newmask)
-        else:
-            for n in names:
-                fmask[n].flat = newmask
-        return
-
-    def _getmask(self):
-        """Returns the mask of the mrecord: a record is masked when all the fields
-are masked."""
-        if self.size > 1:
-            return self._fieldmask.view((bool_, len(self.dtype))).all(1)
-
-    _setmask = __setmask__
-    _mask = property(fget=_getmask, fset=_setmask)
-
     #......................................................
     def __str__(self):
         "Calculates the string representation."
@@ -331,14 +387,14 @@
             mstr = ["%s" % ",".join([str(i) for i in s])
                     for s in zip([getattr(self,f) for f in self.dtype.names])]
             return "(%s)" % ", ".join(mstr)
-
+    #
     def __repr__(self):
         "Calculates the repr representation."
         _names = self.dtype.names
         fmt = "%%%is : %%s" % (max([len(n) for n in _names])+4,)
         reprstr = [fmt % (f,getattr(self,f)) for f in self.dtype.names]
         reprstr.insert(0,'masked_records(')
-        reprstr.extend([fmt % ('    fill_value', self._fill_value),
+        reprstr.extend([fmt % ('    fill_value', self.fill_value),
                          '              )'])
         return str("\n".join(reprstr))
     #......................................................
@@ -355,11 +411,11 @@
         return ndarray.view(self, obj)
     #......................................................
     def filled(self, fill_value=None):
-        """Returns an array of the same class as ``_data``, with masked values
-filled with ``fill_value``. If ``fill_value`` is None, ``self.fill_value`` is
-used instead.
+        """Returns an array of the same class as the _data part, where masked 
+    values are filled with fill_value.
+    If fill_value is None, self.fill_value is used instead.
 
-Subclassing is preserved.
+    Subclassing is preserved.
 
         """
         _localdict = self.__dict__
@@ -369,7 +425,7 @@
             return d
         #
         if fill_value is None:
-            value = _localdict['_fill_value']
+            value = _check_fill_value(_localdict['_fill_value'],self.dtype)
         else:
             value = fill_value
             if numeric.size(value) == 1:
@@ -383,168 +439,213 @@
                 numpy.putmask(numeric.asarray(result[n]),
                               numeric.asarray(fm[n]), v)
         return result
-    #............................................
+    #......................................................
     def harden_mask(self):
         "Forces the mask to hard"
         self._hardmask = True
     def soften_mask(self):
         "Forces the mask to soft"
         self._hardmask = False
-    #.............................................
+    #......................................................
     def copy(self):
         """Returns a copy of the masked record."""
         _localdict = self.__dict__
-        return MaskedRecords(self._data.copy(),
-                        mask=_localdict['_fieldmask'].copy(),
-                       dtype=self.dtype)
-    #.............................................
+        copied = self._data.copy().view(type(self))
+        copied._fieldmask = self._fieldmask.copy()
+        return copied
+    #......................................................
+    def tolist(self, fill_value=None):
+        """Copy the data portion of the array to a hierarchical python
+        list and returns that list.
 
+        Data items are converted to the nearest compatible Python
+        type.  Masked values are converted to fill_value. If
+        fill_value is None, the corresponding entries in the output
+        list will be ``None``.
 
+        """
+        if fill_value is not None:
+            return self.filled(fill_value).tolist()
+        result = narray(self.filled().tolist(), dtype=object)
+        mask = narray(self._fieldmask.tolist())
+        result[mask] = None
+        return [tuple(r) for r in result]
+    #--------------------------------------------
+    # Pickling
+    def __getstate__(self):
+        """Return the internal state of the masked array, for pickling purposes.
+
+        """
+        state = (1,
+                 self.shape,
+                 self.dtype,
+                 self.flags.fnc,
+                 self._data.tostring(),
+                 self._fieldmask.tostring(),
+                 self._fill_value,
+                 )
+        return state  
+    #
+    def __setstate__(self, state):
+        """Restore the internal state of the masked array, for pickling purposes.  
+    ``state`` is typically the output of the ``__getstate__`` output, and is a 
+    5-tuple:
+
+        - class name
+        - a tuple giving the shape of the data
+        - a typecode for the data
+        - a binary string for the data
+        - a binary string for the mask.
+
+        """
+        (ver, shp, typ, isf, raw, msk, flv) = state
+        ndarray.__setstate__(self, (shp, typ, isf, raw))
+        mdtype = dtype([(k,bool_) for (k,_) in self.dtype.descr])
+        self._fieldmask.__setstate__((shp, mdtype, isf, msk))
+        self.fill_value = flv
+    #
+    def __reduce__(self):
+        """Return a 3-tuple for pickling a MaskedArray.
+
+        """
+        return (_mrreconstruct,
+                (self.__class__, self._baseclass, (0,), 'b', ),
+                self.__getstate__())
+
+def _mrreconstruct(subtype, baseclass, baseshape, basetype,):
+    """Internal function that builds a new MaskedArray from the
+    information stored in a pickle.
+
+    """
+    _data = ndarray.__new__(baseclass, baseshape, basetype).view(subtype)
+#    _data._mask = ndarray.__new__(ndarray, baseshape, 'b1')
+#    return _data
+    _mask = ndarray.__new__(ndarray, baseshape, 'b1')
+    return subtype.__new__(subtype, _data, mask=_mask, dtype=basetype,)
+
+
+mrecarray = MaskedRecords
+
 #####---------------------------------------------------------------------------
 #---- --- Constructors ---
 #####---------------------------------------------------------------------------
 
 def fromarrays(arraylist, dtype=None, shape=None, formats=None,
-               names=None, titles=None, aligned=False, byteorder=None):
+               names=None, titles=None, aligned=False, byteorder=None,
+               fill_value=None):
     """Creates a mrecarray from a (flat) list of masked arrays.
 
-*Parameters*:
-    arraylist : {sequence}
+    Parameters
+    ----------
+    arraylist : sequence
         A list of (masked) arrays. Each element of the sequence is first converted
         to a masked array if needed. If a 2D array is passed as argument, it is
         processed line by line
-    dtype : {numeric.dtype}
+    dtype : numeric.dtype
         Data type descriptor.
-    {shape} : {integer}
-        Number of records. If None, ``shape`` is defined from the shape of the
+    shape : integer
+        Number of records. If None, shape is defined from the shape of the
         first array in the list.
-    formats : {sequence}
+    formats : sequence
         Sequence of formats for each individual field. If None, the formats will
         be autodetected by inspecting the fields and selecting the highest dtype
         possible.
-    names : {sequence}
+    names : sequence
         Sequence of the names of each field.
-    -titles : {sequence}
+    titles : sequence
       (Description to write)
-    aligned : {boolean}
+    aligned : boolean
       (Description to write, not used anyway)
-    byteorder: {boolean}
+    byteorder: boolean
       (Description to write, not used anyway)
+    fill_value : sequence
+        Sequence of data to be used as filling values.
 
-*Notes*:
+    Notes
+    -----
     Lists of tuples should be preferred over lists of lists for faster processing.
     """
-    arraylist = [masked_array(x) for x in arraylist]
-    # Define/check the shape.....................
-    if shape is None or shape == 0:
-        shape = arraylist[0].shape
-    if isinstance(shape, int):
-        shape = (shape,)
-    # Define formats from scratch ...............
-    if formats is None and dtype is None:
-        formats = _getformats(arraylist)
-    # Define the dtype ..........................
-    if dtype is not None:
-        descr = numeric.dtype(dtype)
-        _names = descr.names
-    else:
-        parsed = format_parser(formats, names, titles, aligned, byteorder)
-        _names = parsed._names
-        descr = parsed._descr
-    # Determine shape from data-type.............
-    if len(descr) != len(arraylist):
-        msg = "Mismatch between the number of fields (%i) and the number of "\
-              "arrays (%i)"
-        raise ValueError, msg % (len(descr), len(arraylist))
-    d0 = descr[0].shape
-    nn = len(d0)
-    if nn > 0:
-        shape = shape[:-nn]
-    # Make sure the shape is the correct one ....
-    for k, obj in enumerate(arraylist):
-        nn = len(descr[k].shape)
-        testshape = obj.shape[:len(obj.shape)-nn]
-        if testshape != shape:
-            raise ValueError, "Array-shape mismatch in array %d" % k
-    # Reconstruct the descriptor, by creating a _data and _mask version
-    return MaskedRecords(arraylist, dtype=descr)
+    datalist = [getdata(x) for x in arraylist]
+    masklist = [getmaskarray(x) for x in arraylist]
+    _array = recfromarrays(datalist, 
+                           dtype=dtype, shape=shape, formats=formats, 
+                           names=names, titles=titles, aligned=aligned,
+                           byteorder=byteorder).view(mrecarray)
+    _array._fieldmask[:] = zip(*masklist)
+    if fill_value is not None:
+        _array.fill_value = fill_value
+    return _array
+
+
 #..............................................................................
 def fromrecords(reclist, dtype=None, shape=None, formats=None, names=None,
-                titles=None, aligned=False, byteorder=None):
+                titles=None, aligned=False, byteorder=None,
+                fill_value=None, mask=nomask):
     """Creates a MaskedRecords from a list of records.
 
-*Parameters*:
-    arraylist : {sequence}
+    Parameters
+    ----------
+    arraylist : sequence
         A list of (masked) arrays. Each element of the sequence is first converted
         to a masked array if needed. If a 2D array is passed as argument, it is
         processed line by line
-    dtype : {numeric.dtype}
+    dtype : numeric.dtype
         Data type descriptor.
-    {shape} : {integer}
+    shape : integer
         Number of records. If None, ``shape`` is defined from the shape of the
         first array in the list.
-    formats : {sequence}
+    formats : sequence
         Sequence of formats for each individual field. If None, the formats will
         be autodetected by inspecting the fields and selecting the highest dtype
         possible.
-    names : {sequence}
+    names : sequence
         Sequence of the names of each field.
-    -titles : {sequence}
+    titles : sequence
       (Description to write)
-    aligned : {boolean}
+    aligned : boolean
       (Description to write, not used anyway)
-    byteorder: {boolean}
+    byteorder: boolean
       (Description to write, not used anyway)
+    fill_value : sequence
+        Sequence of data to be used as filling values.
+    mask : sequence or boolean.
+        External mask to apply on the data.
 
 *Notes*:
     Lists of tuples should be preferred over lists of lists for faster processing.
     """
-    # reclist is in fact a mrecarray .................
-    if isinstance(reclist, MaskedRecords):
-        mdescr = reclist.dtype
-        shape = reclist.shape
-        return MaskedRecords(reclist, dtype=mdescr)
-    # No format, no dtype: create from to arrays .....
+    # Grab the initial _fieldmask, if needed:
+    _fieldmask = getattr(reclist, '_fieldmask', None)
+    # Get the list of records.....
     nfields = len(reclist[0])
-    if formats is None and dtype is None:  # slower
-        if isinstance(reclist, recarray):
-            arrlist = [reclist.field(i) for i in range(len(reclist.dtype))]
-            if names is None:
-                names = reclist.dtype.names
+    if isinstance(reclist, ndarray):
+        # Make sure we don't have some hidden mask
+        if isinstance(reclist,MaskedArray):
+            reclist = reclist.filled().view(ndarray)
+        # Grab the initial dtype, just in case
+        if dtype is None:
+            dtype = reclist.dtype
+        reclist = reclist.tolist()
+    mrec = recfromrecords(reclist, dtype=dtype, shape=shape, formats=formats, 
+                          names=names, titles=titles, 
+                          aligned=aligned, byteorder=byteorder).view(mrecarray)
+    # Set the fill_value if needed
+    if fill_value is not None:
+        mrec.fill_value = fill_value
+    # Now, let's deal w/ the mask
+    if mask is not nomask:
+        mask = narray(mask, copy=False)
+        maskrecordlength = len(mask.dtype)
+        if maskrecordlength:
+            mrec._fieldmask.flat = mask
+        elif len(mask.shape) == 2:
+            mrec._fieldmask.flat = [tuple(m) for m in mask]
         else:
-            obj = numeric.array(reclist,dtype=object)
-            arrlist = [numeric.array(obj[...,i].tolist())
-                               for i in xrange(nfields)]
-        return MaskedRecords(arrlist, formats=formats, names=names,
-                             titles=titles, aligned=aligned, byteorder=byteorder)
-    # Construct the descriptor .......................
-    if dtype is not None:
-        descr = numeric.dtype(dtype)
-        _names = descr.names
-    else:
-        parsed = format_parser(formats, names, titles, aligned, byteorder)
-        _names = parsed._names
-        descr = parsed._descr
+            mrec._mask = mask
+    if _fieldmask is not None:
+        mrec._fieldmask[:] = _fieldmask
+    return mrec
 
-    try:
-        retval = numeric.array(reclist, dtype = descr).view(recarray)
-    except TypeError:  # list of lists instead of list of tuples
-        if (shape is None or shape == 0):
-            shape = len(reclist)*2
-        if isinstance(shape, (int, long)):
-            shape = (shape*2,)
-        if len(shape) > 1:
-            raise ValueError, "Can only deal with 1-d array."
-        retval = recarray(shape, mdescr)
-        for k in xrange(retval.size):
-            retval[k] = tuple(reclist[k])
-        return MaskedRecords(retval, dtype=descr)
-    else:
-        if shape is not None and retval.shape != shape:
-            retval.shape = shape
-    #
-    return MaskedRecords(retval, dtype=descr)
-
 def _guessvartypes(arr):
     """Tries to guess the dtypes of the str_ ndarray `arr`, by testing element-wise
 conversion. Returns a list of dtypes.
@@ -648,7 +749,7 @@
     _mask = (_variables.T == missingchar)
     _datalist = [masked_array(a,mask=m,dtype=t)
                      for (a,m,t) in zip(_variables.T, _mask, vartypes)]
-    return MaskedRecords(_datalist, dtype=mdescr)
+    return fromarrays(_datalist, dtype=mdescr)
 
 #....................................................................
 def addfield(mrecord, newfield, newfieldname=None):
@@ -685,28 +786,6 @@
     newdata._fieldmask = newmask
     return newdata
 
-################################################################################
-if __name__ == '__main__':
-    import numpy as N
-    from numpy.ma.testutils import assert_equal
-    if 1:
-        d = N.arange(5)
-        m = numpy.ma.make_mask([1,0,0,1,1])
-        base_d = N.r_[d,d[::-1]].reshape(2,-1).T
-        base_m = N.r_[[m, m[::-1]]].T
-        base = masked_array(base_d, mask=base_m).T
-        mrecord = fromarrays(base,dtype=[('a',N.float_),('b',N.float_)])
-        mrec = MaskedRecords(mrecord.copy())
-        #
-    if 1:
-        mrec = mrec.copy()
-        mrec.harden_mask()
-        assert(mrec._hardmask)
-        mrec._mask = nomask
-        assert_equal(mrec._mask, N.r_[[m,m[::-1]]].all(0))
-        mrec.soften_mask()
-        assert(not mrec._hardmask)
-        mrec.mask = nomask
-        tmp = mrec['b']._mask
-        assert(mrec['b']._mask is nomask)
-        assert_equal(mrec['a']._mask,mrec['b']._mask)
+###############################################################################
+
+        

Modified: branches/maskedarray/numpy/ma/tests/test_core.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-01 11:17:39 UTC (rev 4766)
+++ branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-01 23:40:35 UTC (rev 4767)
@@ -1347,7 +1347,16 @@
         assert_equal(xlist[0],[0,None,2,3])
         assert_equal(xlist[1],[4,5,6,7])
         assert_equal(xlist[2],[8,9,None,11])
+        # Make sure a masked record is output as a tuple of None
+        x = array(zip([1,2,3],
+                      [1.1,2.2,3.3],
+                      ['one','two','thr']),
+                  dtype=[('a',int_),('b',float_),('c','|S8')])
+        x[-1] = masked
+        assert_equal(x.tolist(), [(1,1.1,'one'),(2,2.2,'two'),(None,None,None)])
+        
 
+
     def test_squeeze(self):
         "Check squeeze"
         data = masked_array([[1,2,3]])

Modified: branches/maskedarray/numpy/ma/tests/test_mrecords.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_mrecords.py	2008-02-01 11:17:39 UTC (rev 4766)
+++ branches/maskedarray/numpy/ma/tests/test_mrecords.py	2008-02-01 23:40:35 UTC (rev 4767)
@@ -1,33 +1,35 @@
 # pylint: disable-msg=W0611, W0612, W0511,R0201
-"""Tests suite for mrecarray.
+"""Tests suite for mrecords.
 
 :author: Pierre Gerard-Marchant
 :contact: pierregm_at_uga_dot_edu
-:version: $Id: test_mrecords.py 3473 2007-10-29 15:18:13Z jarrod.millman $
 """
 __author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
 __revision__ = "$Revision: 3473 $"
 __date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
 
 import types
 
 import numpy as N
-import numpy.core.fromnumeric  as fromnumeric
+from numpy import recarray, bool_, int_, float_
+from numpy import array as narray
+from numpy.core.records import fromrecords as recfromrecords
+from numpy.core.records import fromarrays as recfromarrays
+import numpy.core.fromnumeric  as fromnumeric_
 from numpy.testing import NumpyTest, NumpyTestCase
 from numpy.testing.utils import build_err_msg
 
 import numpy.ma.testutils
-from numpy.ma.testutils import *
+from numpy.ma.testutils import assert_equal, assert_equal_records
 
 import numpy.ma
-from numpy.ma import masked_array, masked, nomask
+from numpy.ma import masked_array, masked, nomask, getdata, getmaskarray
 
 #import numpy.ma.mrecords
 #from numpy.ma.mrecords import mrecarray, fromarrays, fromtextfile, fromrecords
 
 import numpy.ma.mrecords
-from numpy.ma.mrecords import MaskedRecords, \
+from numpy.ma.mrecords import MaskedRecords, mrecarray,\
     fromarrays, fromtextfile, fromrecords, addfield
 
 #..............................................................................
@@ -39,111 +41,275 @@
 
     def setup(self):
         "Generic setup"
-        d = N.arange(5)
-        m = numpy.ma.make_mask([1,0,0,1,1])
-        base_d = N.r_[d,d[::-1]].reshape(2,-1).T
-        base_m = N.r_[[m, m[::-1]]].T
-        base = masked_array(base_d, mask=base_m)
-        mrecord = fromarrays(base.T, dtype=[('a',N.float_),('b',N.float_)])
-        self.data = [d, m, mrecord]
+        ilist = [1,2,3,4,5]
+        flist = [1.1,2.2,3.3,4.4,5.5]
+        slist = ['one','two','three','four','five']
+        ddtype = [('a',int_),('b',float_),('c','|S8')]
+        mask = [0,1,0,0,1]
+        self.base = masked_array(zip(ilist,flist,slist), mask=mask, dtype=ddtype)
+        
+    def test_byview(self):
+        "Test creation by view"
+        base = self.base
+        mbase = base.view(mrecarray)
+        assert_equal(mbase._mask, base._mask)
+        assert isinstance(mbase._data, recarray)
+        assert_equal_records(mbase._data, base._data.view(recarray))
+        for field in ('a','b','c'):
+            assert_equal(base[field], mbase[field])
+        assert_equal_records(mbase.view(mrecarray), mbase)
 
     def test_get(self):
         "Tests fields retrieval"
-        [d, m, mrec] = self.data
-        mrec = mrec.copy()
-        assert_equal(mrec.a, masked_array(d,mask=m))
-        assert_equal(mrec.b, masked_array(d[::-1],mask=m[::-1]))
-        assert((mrec._fieldmask == N.core.records.fromarrays([m, m[::-1]], dtype=mrec._fieldmask.dtype)).all())
-        assert_equal(mrec._mask, N.r_[[m,m[::-1]]].all(0))
-        assert_equal(mrec.a[1], mrec[1].a)
-        #
-        assert(isinstance(mrec[:2], MaskedRecords))
-        assert_equal(mrec[:2]['a'], d[:2])
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        # As fields..........
+        for field in ('a','b','c'):
+            assert_equal(getattr(mbase,field), mbase[field])
+            assert_equal(base[field], mbase[field])
+        # as elements .......
+        mbase_first = mbase[0]
+        assert isinstance(mbase_first, mrecarray)
+        assert_equal(mbase_first.dtype, mbase.dtype)
+        assert_equal(mbase_first.tolist(), (1,1.1,'one'))
+        assert_equal(mbase_first.mask, nomask)
+        assert_equal(mbase_first._fieldmask.item(), (False, False, False))
+        assert_equal(mbase_first['a'], mbase['a'][0])
+        mbase_last = mbase[-1]        
+        assert isinstance(mbase_last, mrecarray)
+        assert_equal(mbase_last.dtype, mbase.dtype)
+        assert_equal(mbase_last.tolist(), (None,None,None))
+        assert_equal(mbase_last.mask, True)
+        assert_equal(mbase_last._fieldmask.item(), (True, True, True))
+        assert_equal(mbase_last['a'], mbase['a'][-1])
+        assert (mbase_last['a'] is masked)
+        # as slice ..........
+        mbase_sl = mbase[:2]
+        assert isinstance(mbase_sl, mrecarray)
+        assert_equal(mbase_sl.dtype, mbase.dtype)
+        assert_equal(mbase_sl._mask, [0,1])
+        assert_equal_records(mbase_sl, base[:2].view(mrecarray))
+        for field in ('a','b','c'):
+            assert_equal(getattr(mbase_sl,field), base[:2][field])
 
-    def test_set(self):
-        "Tests setting fields/attributes."
-        [d, m, mrecord] = self.data
-        mrecord.a._data[:] = 5
-        assert_equal(mrecord['a']._data, [5,5,5,5,5])
-        mrecord.a = 1
-        assert_equal(mrecord['a']._data, [1]*5)
-        assert_equal(getmaskarray(mrecord['a']), [0]*5)
-        mrecord.b = masked
-        assert_equal(mrecord.b.mask, [1]*5)
-        assert_equal(getmaskarray(mrecord['b']), [1]*5)
-        mrecord._mask = masked
-        assert_equal(getmaskarray(mrecord['b']), [1]*5)
-        assert_equal(mrecord['a']._mask, mrecord['b']._mask)
-        mrecord._mask = nomask
-        assert_equal(getmaskarray(mrecord['b']), [0]*5)
-        assert_equal(mrecord['a']._mask, mrecord['b']._mask)
+    def test_set_fields(self):
+        "Tests setting fields."        
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        mbase = mbase.copy()
+        mbase.fill_value = (999999,1e20,'N/A')
+        # Change the data, the mask should be conserved
+        mbase.a._data[:] = 5
+        assert_equal(mbase['a']._data, [5,5,5,5,5])
+        assert_equal(mbase['a']._mask, [0,1,0,0,1])
+        # Change the elements, and the mask will follow
+        mbase.a = 1
+        assert_equal(mbase['a']._data, [1]*5)
+        assert_equal(getmaskarray(mbase['a']), [0]*5)
+        assert_equal(mbase._mask, [False]*5)
+        assert_equal(mbase._fieldmask.tolist(), 
+                     narray([(0,0,0),(0,1,1),(0,0,0),(0,0,0),(0,1,1)],
+                            dtype=bool_))
+        # Set a field to mask ........................
+        mbase.c = masked
+        assert_equal(mbase.c.mask, [1]*5)
+        assert_equal(getmaskarray(mbase['c']), [1]*5)
+        assert_equal(getdata(mbase['c']), ['N/A']*5)
+        assert_equal(mbase._fieldmask.tolist(), 
+                     narray([(0,0,1),(0,1,1),(0,0,1),(0,0,1),(0,1,1)],
+                            dtype=bool_))
+        # Set fields by slices .......................
+        mbase = base.view(mrecarray).copy()
+        mbase.a[3:] = 5
+        assert_equal(mbase.a, [1,2,3,5,5])
+        assert_equal(mbase.a._mask, [0,1,0,0,0])
+        mbase.b[3:] = masked
+        assert_equal(mbase.b, base['b'])
+        assert_equal(mbase.b._mask, [0,1,0,1,1])
+    #
+    def test_set_mask(self):
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        # Set the mask to True .......................
+        mbase._mask = masked
+        assert_equal(getmaskarray(mbase['b']), [1]*5)
+        assert_equal(mbase['a']._mask, mbase['b']._mask)
+        assert_equal(mbase['a']._mask, mbase['c']._mask)
+        assert_equal(mbase._fieldmask.tolist(), 
+                     narray([(1,1,1)]*5,
+                            dtype=bool_))
+        # Delete the mask ............................
+        mbase._mask = nomask
+        assert_equal(getmaskarray(mbase['c']), [0]*5)
+        assert_equal(mbase._fieldmask.tolist(), 
+                     narray([(0,0,0)]*5,
+                            dtype=bool_))
+    #
+    def test_set_elements(self):
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        # Set an element to mask .....................
+        mbase[-2] = masked
+        assert_equal(mbase._fieldmask.tolist(),
+                     narray([(0,0,0),(1,1,1),(0,0,0),(1,1,1),(1,1,1)],
+                             dtype=bool_))
+        assert_equal(mbase._mask, [0,1,0,1,1])
+        # Set slices .................................
+        mbase = base.view(mrecarray).copy()
+        mbase[:2] = 5
+        assert_equal(mbase.a._data, [5,5,3,4,5])
+        assert_equal(mbase.a._mask, [0,0,0,0,1])
+        assert_equal(mbase.b._data, [5.,5.,3.3,4.4,5.5])
+        assert_equal(mbase.b._mask, [0,0,0,0,1])
+        assert_equal(mbase.c._data, ['5','5','three','four','five'])
+        assert_equal(mbase.b._mask, [0,0,0,0,1])
         #
-    def test_setfields(self):
-        "Tests setting fields."
-        [d, m, mrecord] = self.data
-        mrecord.a[3:] = 5
-        assert_equal(mrecord.a, [0,1,2,5,5])
-        assert_equal(mrecord.a._mask, [1,0,0,0,0])
-        #
-        mrecord.b[3:] = masked
-        assert_equal(mrecord.b, [4,3,2,1,0])
-        assert_equal(mrecord.b._mask, [1,1,0,1,1])
-
-    def test_setslices(self):
-        "Tests setting slices."
-        [d, m, mrec] = self.data
-        mrec[:2] = 5
-        assert_equal(mrec.a._data, [5,5,2,3,4])
-        assert_equal(mrec.b._data, [5,5,2,1,0])
-        assert_equal(mrec.a._mask, [0,0,0,1,1])
-        assert_equal(mrec.b._mask, [0,0,0,0,1])
-        #
-        mrec[:2] = masked
-        assert_equal(mrec._mask, [1,1,0,0,1])
-        mrec[-2] = masked
-        assert_equal(mrec._mask, [1,1,0,1,1])
-        #
+        mbase = base.view(mrecarray).copy()
+        mbase[:2] = masked
+        assert_equal(mbase.a._data, [1,2,3,4,5])
+        assert_equal(mbase.a._mask, [1,1,0,0,1])
+        assert_equal(mbase.b._data, [1.1,2.2,3.3,4.4,5.5])
+        assert_equal(mbase.b._mask, [1,1,0,0,1])
+        assert_equal(mbase.c._data, ['one','two','three','four','five'])
+        assert_equal(mbase.b._mask, [1,1,0,0,1])
+    #
     def test_setslices_hardmask(self):
         "Tests setting slices w/ hardmask."
-        [d, m, mrec] = self.data
-        mrec.harden_mask()
-        mrec[-2:] = 5
-        assert_equal(mrec.a._data, [0,1,2,3,4])
-        assert_equal(mrec.b._data, [4,3,2,5,0])
-        assert_equal(mrec.a._mask, [1,0,0,1,1])
-        assert_equal(mrec.b._mask, [1,1,0,0,1])
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        mbase.harden_mask()
+        mbase[-2:] = 5
+        assert_equal(mbase.a._data, [1,2,3,5,5])
+        assert_equal(mbase.b._data, [1.1,2.2,3.3,5,5.5])
+        assert_equal(mbase.c._data, ['one','two','three','5','five'])
+        assert_equal(mbase.a._mask, [0,1,0,0,1])
+        assert_equal(mbase.b._mask, mbase.a._mask)
+        assert_equal(mbase.b._mask, mbase.c._mask)
 
     def test_hardmask(self):
         "Test hardmask"
-        [d, m, mrec] = self.data
-        mrec = mrec.copy()
-        mrec.harden_mask()
-        assert(mrec._hardmask)
-        mrec._mask = nomask
-        assert_equal(mrec._mask, N.r_[[m,m[::-1]]].all(0))
-        mrec.soften_mask()
-        assert(not mrec._hardmask)
-        mrec._mask = nomask
-        assert(mrec['b']._mask is nomask)
-        assert_equal(mrec['a']._mask,mrec['b']._mask)
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        mbase.harden_mask()
+        assert(mbase._hardmask)
+        mbase._mask = nomask
+        assert_equal(mbase._mask, [0,1,0,0,1])
+        mbase.soften_mask()
+        assert(not mbase._hardmask)
+        mbase._mask = nomask
+        assert(mbase['b']._mask is nomask)
+        assert_equal(mbase['a']._mask,mbase['b']._mask)
+    #
+    def test_pickling(self):
+        "Test pickling"
+        import cPickle
+        base = self.base.copy()
+        mrec = base.view(mrecarray)
+        _ = cPickle.dumps(mrec)
+        mrec_ = cPickle.loads(_)
+        assert_equal(mrec_.dtype, mrec.dtype)
+        assert_equal_records(mrec_._data, mrec._data)
+        assert_equal(mrec_._mask, mrec._mask)
+        assert_equal_records(mrec_._fieldmask, mrec._fieldmask)
+    #
+    def test_filled(self):
+        "Test filling the array"
+        _a = masked_array([1,2,3],mask=[0,0,1],dtype=int_)
+        _b = masked_array([1.1,2.2,3.3],mask=[0,0,1],dtype=float_)
+        _c = masked_array(['one','two','three'],mask=[0,0,1],dtype='|S8')
+        ddtype = [('a',int_),('b',float_),('c','|S8')]
+        mrec = fromarrays([_a,_b,_c], dtype=ddtype, 
+                          fill_value=(99999,99999.,'N/A')) 
+        mrecfilled = mrec.filled()
+        assert_equal(mrecfilled['a'], narray((1,2,99999), dtype=int_))
+        assert_equal(mrecfilled['b'], narray((1.1,2.2,99999.), dtype=float_))
+        assert_equal(mrecfilled['c'], narray(('one','two','N/A'), dtype='|S8'))
+    #
+    def test_tolist(self):
+        "Test tolist."
+        _a = masked_array([1,2,3],mask=[0,0,1],dtype=int_)
+        _b = masked_array([1.1,2.2,3.3],mask=[0,0,1],dtype=float_)
+        _c = masked_array(['one','two','three'],mask=[1,0,0],dtype='|S8')
+        ddtype = [('a',int_),('b',float_),('c','|S8')]
+        mrec = fromarrays([_a,_b,_c], dtype=ddtype, 
+                          fill_value=(99999,99999.,'N/A')) 
+        #
+        assert_equal(mrec.tolist(),
+                     [(1,1.1,None),(2,2.2,'two'),(None,None,'three')])
 
+################################################################################
+class TestMRecordsImport(NumpyTestCase):
+    "Base test class for MaskedArrays."
+    def __init__(self, *args, **kwds):
+        NumpyTestCase.__init__(self, *args, **kwds)
+        self.setup()
+
+    def setup(self):
+        "Generic setup"
+        _a = masked_array([1,2,3],mask=[0,0,1],dtype=int_)
+        _b = masked_array([1.1,2.2,3.3],mask=[0,0,1],dtype=float_)
+        _c = masked_array(['one','two','three'],mask=[0,0,1],dtype='|S8')
+        ddtype = [('a',int_),('b',float_),('c','|S8')]
+        mrec = fromarrays([_a,_b,_c], dtype=ddtype, 
+                          fill_value=(99999,99999.,'N/A')) 
+        nrec = recfromarrays((_a.data,_b.data,_c.data), dtype=ddtype)
+        self.data = (mrec, nrec, ddtype)
+        
+    def test_fromarrays(self):
+        _a = masked_array([1,2,3],mask=[0,0,1],dtype=int_)
+        _b = masked_array([1.1,2.2,3.3],mask=[0,0,1],dtype=float_)
+        _c = masked_array(['one','two','three'],mask=[0,0,1],dtype='|S8')
+        (mrec, nrec, _) = self.data
+        for (f,l) in zip(('a','b','c'),(_a,_b,_c)):
+            assert_equal(getattr(mrec,f)._mask, l._mask)
+        
+        
     def test_fromrecords(self):
-        "Test from recarray."
-        [d, m, mrec] = self.data
-        nrec = N.core.records.fromarrays(N.r_[[d,d[::-1]]],
-                                         dtype=[('a',N.float_),('b',N.float_)])
-        #....................
-        mrecfr = fromrecords(nrec)
-        assert_equal(mrecfr.a, mrec.a)
-        assert_equal(mrecfr.dtype, mrec.dtype)
-        #....................
-        tmp = mrec[::-1] #.tolist()
-        mrecfr = fromrecords(tmp)
-        assert_equal(mrecfr.a, mrec.a[::-1])
-        #....................
-        mrecfr = fromrecords(nrec.tolist(), names=nrec.dtype.names)
-        assert_equal(mrecfr.a, mrec.a)
-        assert_equal(mrecfr.dtype, mrec.dtype)
+        "Test construction from records."
+        (mrec, nrec, ddtype) = self.data
+        #......
+        palist = [(1, 'abc', 3.7000002861022949, 0),
+                  (2, 'xy', 6.6999998092651367, 1),
+                  (0, ' ', 0.40000000596046448, 0)]
+        pa = recfromrecords(palist, names='c1, c2, c3, c4')
+        mpa = fromrecords(palist, names='c1, c2, c3, c4')
+        assert_equal_records(pa,mpa)
+        #.....
+        _mrec = fromrecords(nrec)
+        assert_equal(_mrec.dtype, mrec.dtype)
+        for field in _mrec.dtype.names:
+            assert_equal(getattr(_mrec, field), getattr(mrec._data, field)) 
+        #
+        _mrec = fromrecords(nrec.tolist(), names='c1,c2,c3')
+        assert_equal(_mrec.dtype, [('c1',int_),('c2',float_),('c3','|S5')])
+        for (f,n) in zip(('c1','c2','c3'), ('a','b','c')):
+            assert_equal(getattr(_mrec,f), getattr(mrec._data, n))
+        #
+        _mrec = fromrecords(mrec)
+        assert_equal(_mrec.dtype, mrec.dtype)
+        assert_equal_records(_mrec._data, mrec.filled())
+        assert_equal_records(_mrec._fieldmask, mrec._fieldmask)
+            
+    def test_fromrecords_wmask(self):
+        "Tests construction from records w/ mask."
+        (mrec, nrec, ddtype) = self.data
+        #
+        _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=[0,1,0,])
+        assert_equal_records(_mrec._data, mrec._data)
+        assert_equal(_mrec._fieldmask.tolist(), [(0,0,0),(1,1,1),(0,0,0)])
+        #
+        _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=True)
+        assert_equal_records(_mrec._data, mrec._data)
+        assert_equal(_mrec._fieldmask.tolist(), [(1,1,1),(1,1,1),(1,1,1)])
+        #
+        _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=mrec._fieldmask)
+        assert_equal_records(_mrec._data, mrec._data)
+        assert_equal(_mrec._fieldmask.tolist(), mrec._fieldmask.tolist())
+        #
+        _mrec = fromrecords(nrec.tolist(), dtype=ddtype, 
+                            mask=mrec._fieldmask.tolist())
+        assert_equal_records(_mrec._data, mrec._data)
+        assert_equal(_mrec._fieldmask.tolist(), mrec._fieldmask.tolist())
 
     def test_fromtextfile(self):
         "Tests reading from a text file."
@@ -170,10 +336,11 @@
 
     def test_addfield(self):
         "Tests addfield"
-        [d, m, mrec] = self.data
-        mrec = addfield(mrec, masked_array(d+10, mask=m[::-1]))
-        assert_equal(mrec.f2, d+10)
-        assert_equal(mrec.f2._mask, m[::-1])
+        (mrec, nrec, ddtype) = self.data
+        (d,m) = ([100,200,300], [1,0,0])
+        mrec = addfield(mrec, masked_array(d, mask=m))
+        assert_equal(mrec.f3, d)
+        assert_equal(mrec.f3._mask, m)
 
 ###############################################################################
 #------------------------------------------------------------------------------



From numpy-svn at scipy.org  Wed Feb  6 18:11:42 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed,  6 Feb 2008 17:11:42 -0600 (CST)
Subject: [Numpy-svn] r4768 - branches/maskedarray/numpy/ma/tests
Message-ID: <20080206231142.5EE0F39C0CD@new.scipy.org>

Author: stefan
Date: 2008-02-06 17:11:09 -0600 (Wed, 06 Feb 2008)
New Revision: 4768

Modified:
   branches/maskedarray/numpy/ma/tests/test_core.py
Log:
Remove print statement from test.


Modified: branches/maskedarray/numpy/ma/tests/test_core.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-01 23:40:35 UTC (rev 4767)
+++ branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-06 23:11:09 UTC (rev 4768)
@@ -1441,7 +1441,6 @@
         b = empty(len(a), dtype=datatype)
         assert_equal(b.shape, a.shape)
         assert_equal(b.fill_value, a.fill_value)
-        print "test_empty passed!"
 
 
 #..............................................................................



From numpy-svn at scipy.org  Wed Feb  6 18:18:02 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed,  6 Feb 2008 17:18:02 -0600 (CST)
Subject: [Numpy-svn] r4769 - branches/maskedarray/numpy/ma/tests
Message-ID: <20080206231802.D8ACE39C0CD@new.scipy.org>

Author: stefan
Date: 2008-02-06 17:17:35 -0600 (Wed, 06 Feb 2008)
New Revision: 4769

Modified:
   branches/maskedarray/numpy/ma/tests/test_core.py
Log:
Ignore DeprecationWarning during testing.


Modified: branches/maskedarray/numpy/ma/tests/test_core.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-06 23:11:09 UTC (rev 4768)
+++ branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-06 23:17:35 UTC (rev 4769)
@@ -174,15 +174,16 @@
         xm /= arange(10)
         assert_equal(xm, ones((10,)))
 
+        warnings.simplefilter('ignore', DeprecationWarning)
         x = arange(10).astype(float_)
         xm = arange(10)
         xm[2] = masked
-#        id1 = id(x.raw_data())
         id1 = x.raw_data().ctypes.data
         x += 1.
-#        assert id1 == id(x.raw_data())
         assert (id1 == x.raw_data().ctypes.data)
         assert_equal(x, y+1.)
+        warnings.simplefilter('default', DeprecationWarning)
+
         # addition w/ array
         x = arange(10, dtype=float_)
         xm = arange(10, dtype=float_)
@@ -449,6 +450,7 @@
         m3 = make_mask(m, copy=1)
         assert(m is not m3)
 
+        warnings.simplefilter('ignore', DeprecationWarning)
         x1 = numpy.arange(5)
         y1 = array(x1, mask=m)
         #assert( y1._data is x1)
@@ -456,6 +458,7 @@
         assert( allequal(x1,y1.raw_data()))
         #assert( y1.mask is m)
         assert_equal(y1._mask.__array_interface__, m.__array_interface__)
+        warnings.simplefilter('default', DeprecationWarning)
 
         y1a = array(y1)
         #assert( y1a.raw_data() is y1.raw_data())



From numpy-svn at scipy.org  Thu Feb  7 06:42:23 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu,  7 Feb 2008 05:42:23 -0600 (CST)
Subject: [Numpy-svn] r4770 - branches/maskedarray/numpy/ma/tests
Message-ID: <20080207114223.74C1639C4DC@new.scipy.org>

Author: stefan
Date: 2008-02-07 05:42:03 -0600 (Thu, 07 Feb 2008)
New Revision: 4770

Modified:
   branches/maskedarray/numpy/ma/tests/test_core.py
   branches/maskedarray/numpy/ma/tests/test_old_ma.py
Log:
Remove .data comparisons in tests.  Fix whitespace.


Modified: branches/maskedarray/numpy/ma/tests/test_core.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-06 23:17:35 UTC (rev 4769)
+++ branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-07 11:42:03 UTC (rev 4770)
@@ -501,13 +501,9 @@
         x = masked_array([1,2,3], mask=[0,1,0])
         # Copy is False by default
         y = masked_array(x)
-#        assert_equal(id(y._data), id(x._data))
-#        assert_equal(id(y._mask), id(x._mask))
         assert_equal(y._data.ctypes.data, x._data.ctypes.data)
         assert_equal(y._mask.ctypes.data, x._mask.ctypes.data)
         y = masked_array(x, copy=True)
-#        assert_not_equal(id(y._data), id(x._data))
-#        assert_not_equal(id(y._mask), id(x._mask))
         assert_not_equal(y._data.ctypes.data, x._data.ctypes.data)
         assert_not_equal(y._mask.ctypes.data, x._mask.ctypes.data)
     #........................
@@ -1357,7 +1353,6 @@
                   dtype=[('a',int_),('b',float_),('c','|S8')])
         x[-1] = masked
         assert_equal(x.tolist(), [(1,1.1,'one'),(2,2.2,'two'),(None,None,None)])
-        
 
 
     def test_squeeze(self):
@@ -1426,7 +1421,7 @@
         assert_equal(b._mask, [1,1,0,0])
         #
         x = numpy.array([3,1,2])
-        b = a.compress(x >= 2, axis=1)    
+        b = a.compress(x >= 2, axis=1)
         assert_equal(b._data, [[10,30],[40,60]])
         assert_equal(b._mask, [[0,1],[1,0]])
     #

Modified: branches/maskedarray/numpy/ma/tests/test_old_ma.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_old_ma.py	2008-02-06 23:17:35 UTC (rev 4769)
+++ branches/maskedarray/numpy/ma/tests/test_old_ma.py	2008-02-07 11:42:03 UTC (rev 4770)
@@ -255,11 +255,9 @@
         self.failUnless( y1.mask is m)
 
         y1a = array(y1, copy=0)
-        self.failUnless( y1a.data is y1.data)
         self.failUnless( y1a.mask is y1.mask)
 
         y2 = array(x1, mask=m, copy=0)
-        self.failUnless( y2.data is x1)
         self.failUnless( y2.mask is m)
         self.failUnless( y2[2] is masked)
         y2[2]=9



From numpy-svn at scipy.org  Thu Feb  7 12:00:05 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu,  7 Feb 2008 11:00:05 -0600 (CST)
Subject: [Numpy-svn] r4771 - branches/maskedarray/numpy/ma
Message-ID: <20080207170005.0B3C739C03A@new.scipy.org>

Author: pierregm
Date: 2008-02-07 11:00:02 -0600 (Thu, 07 Feb 2008)
New Revision: 4771

Modified:
   branches/maskedarray/numpy/ma/core.py
   branches/maskedarray/numpy/ma/extras.py
Log:
comments cleaning and docstring updates.

Modified: branches/maskedarray/numpy/ma/core.py
===================================================================
--- branches/maskedarray/numpy/ma/core.py	2008-02-07 11:42:03 UTC (rev 4770)
+++ branches/maskedarray/numpy/ma/core.py	2008-02-07 17:00:02 UTC (rev 4771)
@@ -258,7 +258,8 @@
     """
     if hasattr(a, 'filled'):
         return a.filled(value)
-    elif isinstance(a, ndarray): # and a.flags['CONTIGUOUS']:
+    elif isinstance(a, ndarray): 
+        # Should we check for contiguity ? and a.flags['CONTIGUOUS']:
         return a
     elif isinstance(a, dict):
         return narray(a, 'O')
@@ -441,7 +442,8 @@
             m = numpy.logical_or(m, dm)
             # The following two lines control the domain filling methods.
             d1 = d1.copy()
-#            d1[dm] = self.fill
+            # We could use smart indexing : d1[dm] = self.fill ...
+            # ... but numpy.putmask looks more efficient, despite the copy.
             numpy.putmask(d1, dm, self.fill)
         # Take care of the masked singletong first ...
         if not m.ndim and m:
@@ -549,7 +551,8 @@
         if (not m.ndim) and m:
             return masked
         rcls = get_masked_subclass(a,b)
-#        d = self.f.outer(filled(a, self.fillx), filled(b, self.filly)).view(rcls)
+        # We could fill the arguments first, butis it useful ?
+        # d = self.f.outer(filled(a, self.fillx), filled(b, self.filly)).view(rcls)
         d = self.f.outer(getdata(a), getdata(b)).view(rcls)
         if d.ndim > 0:
             d._mask = m
@@ -864,11 +867,12 @@
     floating point, consider `masked_values(x, value)` instead.
 
     """
+    # An alternative implementation relies on filling first: probably not needed.
+    # d = filled(x, 0)
+    # c = umath.equal(d, value)
+    # m = mask_or(c, getmask(x))
+    # return array(d, mask=m, copy=copy)
     return masked_where((x == value), x, copy=copy)
-#    d = filled(x, 0)
-#    c = umath.equal(d, value)
-#    m = mask_or(c, getmask(x))
-#    return array(d, mask=m, copy=copy)
 
 def masked_inside(x, v1, v2, copy=True):
     """Shortcut to masked_where, where condition is True for x inside
@@ -970,7 +974,7 @@
     else:
         cls = MaskedArray
     result = a.view(cls)
-    result._mask = cond
+    result._mask = condition
     return result
 
 
@@ -1336,6 +1340,7 @@
         """
         if self is masked:
             raise MAError, 'Cannot alter the masked element.'
+        # This test is useful, but we should keep things light...
 #        if getmask(indx) is not nomask:
 #            msg = "Masked arrays must be filled before they can be used as indices!"
 #            raise IndexError, msg
@@ -1401,6 +1406,8 @@
         """
         if mask is not nomask:
             mask = narray(mask, copy=copy, dtype=MaskType)
+            # We could try to check whether shrinking is needed..
+            # ... but we would waste some precious time
 #            if self._shrinkmask and not mask.any():
 #                mask = nomask
         if self._mask is nomask:
@@ -1425,8 +1432,9 @@
         """Return the current mask.
 
         """
-        return self._mask
+        # We could try to force a reshape, but that wouldn't work in some cases.
 #        return self._mask.reshape(self.shape)
+        return self._mask
     mask = property(fget=_get_mask, fset=__setmask__, doc="Mask")
     #............................................
     def harden_mask(self):
@@ -1566,8 +1574,6 @@
         data._update_from(self)
         if self._mask is not nomask:
             data = data[numpy.logical_not(ndarray.ravel(self._mask))]
-#        if not self._shrinkmask:
-#            data._mask = numpy.zeros(data.shape, dtype=MaskType)
         return data
     
     
@@ -1730,7 +1736,6 @@
         if self._mask is not nomask:
             warnings.warn("Warning: converting a masked element to nan.")
             return numpy.nan
-            #raise MAError, 'Cannot convert masked element to a Python float.'
         return float(self.item())
 
     def __int__(self):
@@ -1793,7 +1798,7 @@
             return masked_array(n1 - n2)
     #............................................
     flatten = _arraymethod('flatten')
-#    ravel = _arraymethod('ravel')
+    #
     def ravel(self):
         """Returns a 1D version of self, as a view."""
         r = ndarray.ravel(self._data).view(type(self))
@@ -1803,6 +1808,7 @@
         else:
             r._mask = nomask
         return r
+    #
     repeat = _arraymethod('repeat')
     #
     def reshape (self, *s):
@@ -1958,7 +1964,8 @@
                 d.__setmask__(self._mask.all(axis))
             return d
         elif type(out) is not type(self):
-            raise TypeError("The external array should have a type %s (got %s instead)" %\
+            raise TypeError("The external array should have a type %s "\
+                            "(got %s instead)" %\
                             (type(self), type(out)))
         self.filled(False).any(axis=axis, out=out)
         if out.ndim:
@@ -2011,7 +2018,7 @@
         axis : int, optional
             Axis along which to perform the operation.
             If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
+        dtype : dtype, optional
             Datatype for the intermediary computation. If not given,
             the current dtype is used instead.
 
@@ -2464,13 +2471,10 @@
         """
         return self.max(axis, fill_value) - self.min(axis, fill_value)
 
-
     # Array methods ---------------------------------------
-#    conj = conjugate = _arraymethod('conjugate')
     copy = _arraymethod('copy')
     diagonal = _arraymethod('diagonal')
     take = _arraymethod('take')
-#    ravel = _arraymethod('ravel')
     transpose = _arraymethod('transpose')
     T = property(fget=lambda self:self.transpose())
     swapaxes = _arraymethod('swapaxes')
@@ -2583,11 +2587,8 @@
     _data = ndarray.__new__(baseclass, baseshape, basetype)
     _mask = ndarray.__new__(ndarray, baseshape, 'b1')
     return subtype.__new__(subtype, _data, mask=_mask, dtype=basetype,)
-#MaskedArray.__dump__ = dump
-#MaskedArray.__dumps__ = dumps
 
 
-
 #####--------------------------------------------------------------------------
 #---- --- Shortcuts ---
 #####---------------------------------------------------------------------------
@@ -2597,6 +2598,7 @@
 isarray = isMaskedArray
 isMA = isMaskedArray  #backward compatibility
 # We define the masked singleton as a float for higher precedence...
+# Note that it can be tricky sometimes w/ type comparison
 masked_singleton = MaskedArray(0, dtype=float_, mask=True)
 masked = masked_singleton
 
@@ -2885,6 +2887,8 @@
         return data
     # OK, so we have to concatenate the masks
     dm = numpy.concatenate([getmaskarray(a) for a in arrays], axis)
+    # If we decide to keep a '_shrinkmask' option, we want to check that ...
+    # ... all of them are True, and then check for dm.any()
 #    shrink = numpy.logical_or.reduce([getattr(a,'_shrinkmask',True) for a in arrays])
 #    if shrink and not dm.any():
     if not dm.any():
@@ -2958,10 +2962,6 @@
 
     """
     # We can't use 'frommethod', the order of arguments is different
-#    try:
-#        return a.putmask(values, mask)
-#    except AttributeError:
-#        return numpy.putmask(narray(a, copy=False), mask, values)
     if not isinstance(a, MaskedArray):
         a = a.view(MaskedArray)
     (valdata, valmask) = (getdata(values), getmask(values))
@@ -2970,9 +2970,6 @@
             a._sharedmask = True
             a.mask = numpy.zeros(a.shape, dtype=bool_)
             numpy.putmask(a._mask, mask, valmask)
-#            m = numpy.zeros(a.shape, dtype=bool_)
-#            numpy.putmask(m, mask, valmask)
-#            a = masked_array(a, copy=False, subok=True, mask=m)
     elif a._hardmask:
         if valmask is not nomask:
             m = a._mask.copy()
@@ -3094,22 +3091,6 @@
     if not d._mask.any():
         d._mask = nomask
     return d
-#    # Get the data as a (subclass of) MaskedArray
-#    xv = getdata(x)
-#    yv = getdata(y)
-#    d = numpy.choose(fc, (yv, xv)).view(MaskedArray)
-#    # Get the mask ....................
-#    xm = getmask(x)
-#    ym = getmask(y)
-#    d.mask = numpy.choose(fc, (ym, xm)) | getmask(condition)
-#    # Fix the dtype if one of the values was masked, to prevent an upload to float
-#    if y is masked:
-#        ndtype = xv.dtype
-#    elif x is masked:
-#        ndtype = yv.dtype
-#    else:
-#        ndtype = d.dtype
-#    return d.astype(ndtype)
 
 def choose (indices, t, out=None, mode='raise'):
     "Return array shaped like indices with elements chosen from t"
@@ -3322,3 +3303,5 @@
 def loads(strg):
     "Load a pickle from the current string."""
     return cPickle.loads(strg)
+
+################################################################################

Modified: branches/maskedarray/numpy/ma/extras.py
===================================================================
--- branches/maskedarray/numpy/ma/extras.py	2008-02-07 11:42:03 UTC (rev 4770)
+++ branches/maskedarray/numpy/ma/extras.py	2008-02-07 17:00:02 UTC (rev 4771)
@@ -52,8 +52,9 @@
 def count_masked(arr, axis=None):
     """Count the number of masked elements along the given axis.
 
-    *Parameters*:
-        axis : {integer}, optional
+    Parameters
+    ----------
+        axis : int, optional
             Axis along which to count.
             If None (default), a flattened version of the array is used.
 
@@ -65,8 +66,9 @@
     """Return an empty masked array of the given shape and dtype,
     where all the data are masked.
 
-    *Parameters*:
-        dtype : {dtype}, optional
+    Parameters
+    ----------
+        dtype : dtype, optional
             Data type of the output.
 
     """
@@ -90,15 +92,17 @@
     """Return an unbiased estimate of the variance.
     i.e. var = sum((x - x.mean())**2)/(size(x,axis)-1)
 
-    *Parameters*:
-        axis : {integer}, optional
+    Parameters
+    ----------
+        axis : int, optional
             Axis along which to perform the operation.
             If None, applies to a flattened version of the array.
         dtype : {dtype}, optional
             Datatype for the intermediary computation. If not given,
             the current dtype is used instead.
 
-    *Notes*:
+    Notes
+    -----
         The value returned is an unbiased estimate of the true variance.
         For the (less standard) biased estimate, use var.
 
@@ -121,15 +125,17 @@
     standard deviation is the square root of the average of the
     squared deviations from the mean, i.e. stdu = sqrt(varu(x)).
 
-    *Parameters*:
-        axis : {integer}, optional
+    Parameters
+    ----------
+        axis : int, optional
             Axis along which to perform the operation.
             If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
+        dtype : dtype, optional
             Datatype for the intermediary computation.
             If not given, the current dtype is used instead.
 
-    *Notes*:
+    Notes
+    -----
         The value returned is an unbiased estimate of the true
         standard deviation.  For the biased estimate,
         use std.
@@ -144,9 +150,8 @@
             # Should we use umath.sqrt instead ?
             return sqrt(dvar)
     return sqrt(dvar)
-#    return a.__class__(sqrt(dvar._data), mask=dvar._mask,
-#                          fill_value=a._fill_value)
 
+
 MaskedArray.stdu = stdu
 MaskedArray.varu = varu
 
@@ -300,19 +305,19 @@
 def average(a, axis=None, weights=None, returned=False):
     """Average the array over the given axis.
 
-    *Parameters*:
-        axis : {integer}, optional
+    Parameters
+    ----------
+        axis : int, optional
             Axis along which to perform the operation.
             If None, applies to a flattened version of the array.
-        weights : {sequence}, optional
+        weights : sequence, optional
             Sequence of weights.
             The weights must have the shape of a, or be 1D with length
             the size of a along the given axis.
             If no weights are given, weights are assumed to be 1.
-        returned : {boolean}
-            Flag indicating whether a tuple (result, sum of
-            weights/counts) should be returned as output (True), or
-            just the result (False).
+        returned : bool
+            Flag indicating whether a tuple (result, sum of weights/counts) 
+            should be returned as output (True), or just the result (False).
 
     """
     a = asarray(a)
@@ -381,7 +386,8 @@
                     ni = ash[axis]
                     r = [None]*len(ash)
                     r[axis] = slice(None, None, 1)
-                    w = eval ("w["+ repr(tuple(r)) + "] * masked_array(ones(ash, float), mask)")
+                    w = eval ("w["+ repr(tuple(r)) + \
+                              "] * masked_array(ones(ash, float), mask)")
                     n = add.reduce(a*w, axis, dtype=float_)
                     d = add.reduce(w, axis, dtype=float_)
                 else:
@@ -415,8 +421,15 @@
         - If axis is None, rows and columns are suppressed.
         - If axis is 0, only rows are suppressed.
         - If axis is 1 or -1, only columns are suppressed.
+        
+    Parameters
+    ----------
+        axis : int, optional
+            Axis along which to perform the operation.
+            If None, applies to a flattened version of the array.
 
-    *Returns*:
+    Returns
+    -------
         compressed_array : an ndarray.
 
     """
@@ -462,7 +475,15 @@
         - If axis is 0, only rows are masked.
         - If axis is 1 or -1, only columns are masked.
 
-    Returns a *pure* ndarray.
+    Parameters
+    ----------
+        axis : int, optional
+            Axis along which to perform the operation.
+            If None, applies to a flattened version of the array.
+            
+    Returns
+    -------
+         a *pure* ndarray.
 
     """
     a = asarray(a)
@@ -483,12 +504,22 @@
 def mask_rows(a, axis=None):
     """Mask whole rows of a 2D array that contain masked values.
 
+    Parameters
+    ----------
+        axis : int, optional
+            Axis along which to perform the operation.
+            If None, applies to a flattened version of the array.
     """
     return mask_rowcols(a, 0)
 
 def mask_cols(a, axis=None):
     """Mask whole columns of a 2D array that contain masked values.
 
+    Parameters
+    ----------
+        axis : int, optional
+            Axis along which to perform the operation.
+            If None, applies to a flattened version of the array.
     """
     return mask_rowcols(a, 1)
 
@@ -502,12 +533,14 @@
     appears in a row or column, the whole row or column is considered
     masked.
 
-    *Parameters*:
+    Parameters
+    ----------
         strict : {boolean}
             Whether masked data are propagated (True) or set to 0 for
             the computation.
 
-    *Note*:
+    Notes
+    -----
         The first argument is not conjugated.
 
     """
@@ -528,7 +561,8 @@
     """Return the differences between consecutive elements of an
     array, possibly with prefixed and/or appended values.
 
-    *Parameters*:
+    Parameters
+    ----------
         array : {array}
             Input array,  will be flattened before the difference is taken.
         to_end : {number}, optional
@@ -538,7 +572,8 @@
             If provided, this number will be taked onto the beginning of the
             returned differences.
 
-    *Returns*:
+    Returns
+    -------
           ed : {array}
             The differences. Loosely, this will be (ary[1:] - ary[:-1]).
 
@@ -693,6 +728,11 @@
     of 2 tuples, corresponding to the indices of the first and last
     unmasked values respectively.
 
+    Parameters
+    ----------
+        axis : int, optional
+            Axis along which to perform the operation.
+            If None, applies to a flattened version of the array.
     """
     a = asarray(a)
     if axis is None or a.ndim == 1:
@@ -726,9 +766,19 @@
     """Find contiguous unmasked data in a masked array along the given
     axis.
 
-    Return a sorted sequence of slices (start index, end index).
+    Parameters
+    ----------
+        axis : int, optional
+            Axis along which to perform the operation.
+            If None, applies to a flattened version of the array.
+            
+    Returns
+    -------
+        a sorted sequence of slices (start index, end index).
 
-    Note: Only accepts 2D arrays at most.
+    Notes
+    -----
+        Only accepts 2D arrays at most.
 
     """
     a = asarray(a)
@@ -750,12 +800,3 @@
     return result
 
 ################################################################################
-if __name__ == '__main__':
-    #
-    import numpy as N
-    from numpy.ma.testutils import assert_equal
-    if 1:
-        b = ones(5)
-        m = [1,0,0,0,0]
-        d = masked_array(b,mask=m)
-        c = mr_[d,0,0,d]



From numpy-svn at scipy.org  Fri Feb  8 04:48:41 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  8 Feb 2008 03:48:41 -0600 (CST)
Subject: [Numpy-svn] r4772 - in branches/build_with_scons/numpy: . core/src
	core/tests doc doc/html f2py f2py/src lib
Message-ID: <20080208094841.56BB639C147@new.scipy.org>

Author: jarrod.millman
Date: 2008-02-08 03:48:31 -0600 (Fri, 08 Feb 2008)
New Revision: 4772

Modified:
   branches/build_with_scons/numpy/add_newdocs.py
   branches/build_with_scons/numpy/core/src/arraytypes.inc.src
   branches/build_with_scons/numpy/core/src/multiarraymodule.c
   branches/build_with_scons/numpy/core/tests/test_regression.py
   branches/build_with_scons/numpy/ctypeslib.py
   branches/build_with_scons/numpy/doc/HOWTO_DOCUMENT.txt
   branches/build_with_scons/numpy/doc/example.py
   branches/build_with_scons/numpy/doc/html/example-module.html
   branches/build_with_scons/numpy/doc/html/example-pysrc.html
   branches/build_with_scons/numpy/doc/html/help.html
   branches/build_with_scons/numpy/doc/html/identifier-index.html
   branches/build_with_scons/numpy/doc/html/module-tree.html
   branches/build_with_scons/numpy/f2py/crackfortran.py
   branches/build_with_scons/numpy/f2py/src/fortranobject.c
   branches/build_with_scons/numpy/lib/function_base.py
Log:
Merge revisions 4721:4771 from the trunk


Modified: branches/build_with_scons/numpy/add_newdocs.py
===================================================================
--- branches/build_with_scons/numpy/add_newdocs.py	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/add_newdocs.py	2008-02-08 09:48:31 UTC (rev 4772)
@@ -216,6 +216,7 @@
     size is determined by the size of string.  If sep is not empty then the
     string is interpreted in ASCII mode and converted to the desired number type
     using sep as the separator between elements (extra whitespace is ignored).
+    ASCII integer conversions are base-10; octal and hex are not supported.
 
     """)
 

Modified: branches/build_with_scons/numpy/core/src/arraytypes.inc.src
===================================================================
--- branches/build_with_scons/numpy/core/src/arraytypes.inc.src	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/core/src/arraytypes.inc.src	2008-02-08 09:48:31 UTC (rev 4772)
@@ -935,7 +935,7 @@
 {
         @btype@ result;
 
-        result = PyOS_strto at func@(str, endptr, 0);
+        result = PyOS_strto at func@(str, endptr, 10);
         *ip = (@type@) result;
         return 0;
 }

Modified: branches/build_with_scons/numpy/core/src/multiarraymodule.c
===================================================================
--- branches/build_with_scons/numpy/core/src/multiarraymodule.c	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/core/src/multiarraymodule.c	2008-02-08 09:48:31 UTC (rev 4772)
@@ -3065,23 +3065,25 @@
     PyArrayObject *ap1=NULL;
     PyArrayObject *ap2=NULL;
     PyArrayObject *ret=NULL;
-    int typenum = 0;
+    PyArray_Descr *dtype;
 
     NPY_BEGIN_THREADS_DEF
 
-        typenum = PyArray_ObjectType((PyObject *)op1, 0);
-    typenum = PyArray_ObjectType(op2, typenum);
+    dtype = PyArray_DescrFromObject((PyObject *)op2, op1->descr);
+    
+    /* need ap1 as contiguous array and of right type */
+    Py_INCREF(dtype);
+    ap1 = (PyArrayObject *)PyArray_FromAny((PyObject *)op1, dtype, 
+					   1, 1, NPY_DEFAULT, NULL);
 
-    /* need ap1 as contiguous array and of right type */
-    ap1 = (PyArrayObject *)PyArray_ContiguousFromAny((PyObject *)op1,
-                                                     typenum,
-                                                     1, 1);
-    if (ap1 == NULL)
+    if (ap1 == NULL) {
+        Py_DECREF(dtype);
         return NULL;
+    }
 
     /* need ap2 as contiguous array and of right type */
-    ap2 = (PyArrayObject *)PyArray_ContiguousFromAny(op2, typenum,
-                                                     0, 0);
+    ap2 = (PyArrayObject *)PyArray_FromAny(op2, dtype, 0, 0, NPY_DEFAULT, NULL);
+
     if (ap2 == NULL)
         goto fail;
 

Modified: branches/build_with_scons/numpy/core/tests/test_regression.py
===================================================================
--- branches/build_with_scons/numpy/core/tests/test_regression.py	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/core/tests/test_regression.py	2008-02-08 09:48:31 UTC (rev 4772)
@@ -771,5 +771,14 @@
     def check_binary_repr_0_width(self, level=rlevel):
         assert_equal(np.binary_repr(0,width=3),'000')
 
+    def check_fromstring(self, level=rlevel):
+        assert_equal(np.fromstring("12:09:09", dtype=int, sep=":"),
+                     [12,9,9])
+
+    def check_searchsorted_variable_length(self, level=rlevel):
+        x = np.array(['a','aa','b'])
+        y = np.array(['d','e'])
+        assert_equal(x.searchsorted(y), [3,3])
+
 if __name__ == "__main__":
     NumpyTest().run()

Modified: branches/build_with_scons/numpy/ctypeslib.py
===================================================================
--- branches/build_with_scons/numpy/ctypeslib.py	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/ctypeslib.py	2008-02-08 09:48:31 UTC (rev 4772)
@@ -1,8 +1,8 @@
 __all__ = ['load_library', 'ndpointer', 'test', 'ctypes_load_library',
-           'c_intp']
+           'c_intp', 'as_ctypes', 'as_array']
 
 import sys, os
-from numpy import integer, ndarray, dtype as _dtype, deprecate
+from numpy import integer, ndarray, dtype as _dtype, deprecate, array
 from numpy.core.multiarray import _flagdict, flagsobj
 
 try:
@@ -15,6 +15,8 @@
         raise ImportError, "ctypes is not available."
     ctypes_load_library = _dummy
     load_library = _dummy
+    as_ctypes = _dummy
+    as_array = _dummy
     from numpy import intp as c_intp
 else:
     import numpy.core._internal as nic
@@ -160,6 +162,118 @@
     _pointer_type_cache[dtype] = klass
     return klass
 
+if ctypes is not None:
+    ct = ctypes
+    ################################################################
+    # simple types
+
+    # maps the numpy typecodes like '<f8' to simple ctypes types like
+    # c_double. Filled in by prep_simple.
+    _typecodes = {}
+
+    def prep_simple(simple_type, typestr):
+        """Given a ctypes simple type, construct and attach an
+        __array_interface__ property to it if it does not yet have one.
+        """
+        try: simple_type.__array_interface__
+        except AttributeError: pass
+        else: return
+
+        _typecodes[typestr] = simple_type
+
+        def __array_interface__(self):
+            return {'descr': [('', typestr)],
+                    '__ref': self,
+                    'strides': None,
+                    'shape': (),
+                    'version': 3,
+                    'typestr': typestr,
+                    'data': (ct.addressof(self), False),
+                    }
+
+        simple_type.__array_interface__ = property(__array_interface__)
+
+    if sys.byteorder == "little":
+        TYPESTR = "<%c%d"
+    else:
+        TYPESTR = ">%c%d"
+
+    simple_types = [
+        ((ct.c_byte, ct.c_short, ct.c_int, ct.c_long, ct.c_longlong), "i"),
+        ((ct.c_ubyte, ct.c_ushort, ct.c_uint, ct.c_ulong, ct.c_ulonglong), "u"),
+        ((ct.c_float, ct.c_double), "f"),
+    ]
+
+    # Prep that numerical ctypes types:
+    for types, code in simple_types:
+        for tp in types:
+            prep_simple(tp, TYPESTR % (code, ct.sizeof(tp)))
+
+    ################################################################
+    # array types
+
+    _ARRAY_TYPE = type(ct.c_int * 1)
+
+    def prep_array(array_type):
+        """Given a ctypes array type, construct and attach an
+        __array_interface__ property to it if it does not yet have one.
+        """
+        try: array_type.__array_interface__
+        except AttributeError: pass
+        else: return
+
+        shape = []
+        ob = array_type
+        while type(ob) == _ARRAY_TYPE:
+            shape.append(ob._length_)
+            ob = ob._type_
+        shape = tuple(shape)
+        ai = ob().__array_interface__
+        descr = ai['descr']
+        typestr = ai['typestr']
+
+        def __array_interface__(self):
+            return {'descr': descr,
+                    '__ref': self,
+                    'strides': None,
+                    'shape': shape,
+                    'version': 3,
+                    'typestr': typestr,
+                    'data': (ct.addressof(self), False),
+                    }
+
+        array_type.__array_interface__ = property(__array_interface__)
+
+    ################################################################
+    # public functions
+
+    def as_array(obj):
+        """Create a numpy array from a ctypes array.  The numpy array
+        shares the memory with the ctypes object."""
+        tp = type(obj)
+        try: tp.__array_interface__
+        except AttributeError: prep_array(tp)
+        return array(obj, copy=False)
+
+    def as_ctypes(obj):
+        """Create and return a ctypes object from a numpy array.  Actually
+        anything that exposes the __array_interface__ is accepted."""
+        ai = obj.__array_interface__
+        if ai["strides"]:
+            raise TypeError("strided arrays not supported")
+        if ai["version"] != 3:
+            raise TypeError("only __array_interface__ version 3 supported")
+        addr, readonly = ai["data"]
+        if readonly:
+            raise TypeError("readonly arrays unsupported")
+        tp = _typecodes[ai["typestr"]]
+        for dim in ai["shape"][::-1]:
+            tp = tp * dim
+        result = tp.from_address(addr)
+        result.__keep = ai
+        return result
+
+
 def test(level=1, verbosity=1):
     from numpy.testing import NumpyTest
     return NumpyTest().test(level, verbosity)

Modified: branches/build_with_scons/numpy/doc/HOWTO_DOCUMENT.txt
===================================================================
--- branches/build_with_scons/numpy/doc/HOWTO_DOCUMENT.txt	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/doc/HOWTO_DOCUMENT.txt	2008-02-08 09:48:31 UTC (rev 4772)
@@ -4,6 +4,8 @@
 
 .. Contents::
 
+.. Attention:: This document is slightly out of date.  During the December 2007 sprint, Travis Oliphant made some changes to the NumPy/SciPy docstring standard.  The changes are relatively minor, but the standard no longer follows the epydoc/restructured text standards.  The changes brings our docstring standard more in line with the ETS standard; in addition, it also conserves horizontal real-estate and arguably looks better when printed as plain text.  Unfortunately, these changes mean that currently it isn't possible to render the docstrings as desired.  Travis has committed to writing something to render the docstrings.  At that point, we will update this document to correspond with the new standard.  For now, just refer to: `example.py <http://svn.scipy.org/svn/numpy/trunk/numpy/doc/example.py>`__
+
 Overview
 --------
 In general, we follow the standard Python style conventions as described here:
@@ -158,6 +160,11 @@
   cd epydoc/src
   sudo python setup.py install
 
+Since we use reST-formatted docstrings instead of the epytext markup, you will
+need to include the following line near the top of your module::
+
+    __docformat__ = "restructuredtext en"
+
 The appearance of some elements can be changed in the epydoc.css
 style sheet. 
 

Modified: branches/build_with_scons/numpy/doc/example.py
===================================================================
--- branches/build_with_scons/numpy/doc/example.py	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/doc/example.py	2008-02-08 09:48:31 UTC (rev 4772)
@@ -8,6 +8,9 @@
 a line by itself, preferably preceeded by a blank line.
 
 """
+# Make sure this line is here such that epydoc 3 can parse the docstrings for
+# auto-generated documentation.
+__docformat__ = "restructuredtext en"
 
 import os                      # standard library imports first
 

Modified: branches/build_with_scons/numpy/doc/html/example-module.html
===================================================================
--- branches/build_with_scons/numpy/doc/html/example-module.html	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/doc/html/example-module.html	2008-02-08 09:48:31 UTC (rev 4772)
@@ -56,12 +56,12 @@
 <!-- ==================== MODULE DESCRIPTION ==================== -->
 <h1 class="epydoc">Module example</h1><p class="nomargin-top"><span class="codelink"><a href="example-pysrc.html">source&nbsp;code</a></span></p>
 <p>This is the docstring for the example.py module.  Modules names should
-  have short, all-lowercase names.  The module name may have underscores if
-  this improves readability.</p>
-  <p>Every module should have a docstring at the very top of the file.  The
-  module's docstring may extend over multiple lines.  If your docstring 
-  does extend over multiple lines, the closing three quotation marks must 
-  be on a line by itself, preferably preceeded by a blank line.</p>
+have short, all-lowercase names.  The module name may have underscores if
+this improves readability.</p>
+<p>Every module should have a docstring at the very top of the file.  The
+module's docstring may extend over multiple lines.  If your docstring does
+extend over multiple lines, the closing three quotation marks must be on
+a line by itself, preferably preceeded by a blank line.</p>
 
 <!-- ==================== FUNCTIONS ==================== -->
 <a name="section-Functions"></a>
@@ -168,61 +168,61 @@
     </td>
   </tr></table>
   
-  <pre class="literalblock">
-One-line summary or signature.
-
-Several sentences providing an extended description. You can put
-text in mono-spaced type like so: ``var``.
-
-Parameters
-----------
-var1 : array_like
-    Array_like means all those objects -- lists, nested lists, etc. --
-    that can be converted to an array.
-var2 : integer
-    Write out the full type
-long_variable_name : {'hi', 'ho'}, optional
-    Choices in brackets, default first when optional.
-
-Returns
--------
-named : type
-    Explanation
-list
-    Explanation
-of
-    Explanation
-outputs
-    even more explaining
-
-Other Parameters
-----------------
-only_seldom_used_keywords : type
-    Explanation
-common_parametrs_listed_above : type
-    Explanation
-
-See Also
---------    
-otherfunc : relationship (optional)
-newfunc : relationship (optional)
-
-Notes
------
-Notes about the implementation algorithm (if needed).
-
-This can have multiple paragraphs as can all sections.
-
-Examples
---------
-
-examples in doctest format
-
-&gt;&gt;&gt; a=[1,2,3]
-&gt;&gt;&gt; [x + 3 for x in a]
-[4, 5, 6]
-
-</pre>
+  <p>One-line summary or signature.</p>
+<p>Several sentences providing an extended description. You can put
+text in mono-spaced type like so: <tt class="rst-docutils literal"><span class="pre">var</span></tt>.</p>
+<div class="rst-section" id="rst-parameters">
+<h1 class="heading">Parameters</h1>
+<dl class="rst-docutils">
+<dt>var1 <span class="classifier-delimiter">:</span> <span class="rst-classifier">array_like</span></dt>
+<dd>Array_like means all those objects -- lists, nested lists, etc. --
+that can be converted to an array.</dd>
+<dt>var2 <span class="classifier-delimiter">:</span> <span class="rst-classifier">integer</span></dt>
+<dd>Write out the full type</dd>
+<dt>long_variable_name <span class="classifier-delimiter">:</span> <span class="rst-classifier">{'hi', 'ho'}, optional</span></dt>
+<dd>Choices in brackets, default first when optional.</dd>
+</dl>
+</div>
+<div class="rst-section" id="rst-returns">
+<h1 class="heading">Returns</h1>
+<dl class="rst-docutils">
+<dt>named <span class="classifier-delimiter">:</span> <span class="rst-classifier">type</span></dt>
+<dd>Explanation</dd>
+<dt>list</dt>
+<dd>Explanation</dd>
+<dt>of</dt>
+<dd>Explanation</dd>
+<dt>outputs</dt>
+<dd>even more explaining</dd>
+</dl>
+</div>
+<div class="rst-section" id="rst-other-parameters">
+<h1 class="heading">Other Parameters</h1>
+<dl class="rst-docutils">
+<dt>only_seldom_used_keywords <span class="classifier-delimiter">:</span> <span class="rst-classifier">type</span></dt>
+<dd>Explanation</dd>
+<dt>common_parametrs_listed_above <span class="classifier-delimiter">:</span> <span class="rst-classifier">type</span></dt>
+<dd>Explanation</dd>
+</dl>
+</div>
+<div class="rst-section" id="rst-see-also">
+<h1 class="heading">See Also</h1>
+<p>otherfunc : relationship (optional)
+newfunc : relationship (optional)</p>
+</div>
+<div class="rst-section" id="rst-notes">
+<h1 class="heading">Notes</h1>
+<p>Notes about the implementation algorithm (if needed).</p>
+<p>This can have multiple paragraphs as can all sections.</p>
+</div>
+<div class="rst-section" id="rst-examples">
+<h1 class="heading">Examples</h1>
+<p>examples in doctest format</p>
+<pre class="py-doctest">
+<span class="py-prompt">&gt;&gt;&gt; </span>a=[1,2,3]
+<span class="py-prompt">&gt;&gt;&gt; </span>[x + 3 <span class="py-keyword">for</span> x <span class="py-keyword">in</span> a]
+<span class="py-output">[4, 5, 6]</span></pre>
+</div>
   <dl class="fields">
   </dl>
 </td></tr></table>
@@ -242,7 +242,7 @@
   </tr></table>
   
   <p>Do nothing.</p>
-  <p>I never saw a purple cow.</p>
+<p>I never saw a purple cow.</p>
   <dl class="fields">
   </dl>
 </td></tr></table>
@@ -262,7 +262,7 @@
   </tr></table>
   
   <p>Do nothing.</p>
-  <p>I never hope to see one.</p>
+<p>I never hope to see one.</p>
   <dl class="fields">
   </dl>
 </td></tr></table>
@@ -294,7 +294,7 @@
 <table border="0" cellpadding="0" cellspacing="0" width="100%%">
   <tr>
     <td align="left" class="footer">
-    Generated by Epydoc 3.0beta1 on Fri Dec 28 00:50:17 2007
+    Generated by Epydoc 3.0beta1 on Tue Jan 22 00:26:36 2008
     </td>
     <td align="right" class="footer">
       <a target="mainFrame" href="http://epydoc.sourceforge.net"

Modified: branches/build_with_scons/numpy/doc/html/example-pysrc.html
===================================================================
--- branches/build_with_scons/numpy/doc/html/example-pysrc.html	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/doc/html/example-pysrc.html	2008-02-08 09:48:31 UTC (rev 4772)
@@ -65,61 +65,61 @@
 <a name="L8"></a><tt class="py-lineno"> 8</tt>  <tt class="py-line"><tt class="py-docstring">a line by itself, preferably preceeded by a blank line.</tt> </tt>
 <a name="L9"></a><tt class="py-lineno"> 9</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
 <a name="L10"></a><tt class="py-lineno">10</tt>  <tt class="py-line"><tt class="py-docstring">"""</tt> </tt>
-<a name="L11"></a><tt class="py-lineno">11</tt>  <tt class="py-line"> </tt>
-<a name="L12"></a><tt class="py-lineno">12</tt>  <tt class="py-line"><tt class="py-keyword">import</tt> <tt class="py-name">os</tt>                      <tt class="py-comment"># standard library imports first</tt> </tt>
-<a name="L13"></a><tt class="py-lineno">13</tt>  <tt class="py-line"> </tt>
-<a name="L14"></a><tt class="py-lineno">14</tt>  <tt class="py-line"><tt class="py-keyword">import</tt> <tt class="py-name">numpy</tt> <tt class="py-keyword">as</tt> <tt class="py-name">np</tt>             <tt class="py-comment"># related third party imports next</tt> </tt>
-<a name="L15"></a><tt class="py-lineno">15</tt>  <tt class="py-line"><tt class="py-keyword">import</tt> <tt class="py-name">scipy</tt> <tt class="py-keyword">as</tt> <tt class="py-name">sp</tt>             <tt class="py-comment"># imports should be at the top of the module</tt> </tt>
-<a name="L16"></a><tt class="py-lineno">16</tt>  <tt class="py-line"><tt class="py-keyword">import</tt> <tt class="py-name">matplotlib</tt> <tt class="py-keyword">as</tt> <tt class="py-name">mpl</tt>       <tt class="py-comment"># imports should usually be on separate lines</tt> </tt>
-<a name="L17"></a><tt class="py-lineno">17</tt>  <tt class="py-line"> </tt>
-<a name="foo"></a><div id="foo-def"><a name="L18"></a><tt class="py-lineno">18</tt> <a class="py-toggle" href="#" id="foo-toggle" onclick="return toggle('foo');">-</a><tt class="py-line"><tt class="py-keyword">def</tt> <a class="py-def-name" href="example-module.html#foo">foo</a><tt class="py-op">(</tt><tt class="py-param">var1</tt><tt class="py-op">,</tt> <tt class="py-param">var2</tt><tt class="py-op">,</tt> <tt class="py-param">long_var_name</tt><tt class="py-op">=</tt><tt class="py-string">'hi'</tt><tt class="py-op">)</tt> <tt class="py-op">:</tt> </tt>
-</div><div id="foo-collapsed" style="display:none;" pad="++" indent="++++"></div><div id="foo-expanded"><a name="L19"></a><tt class="py-lineno">19</tt>  <tt class="py-line">    <tt class="py-docstring">"""One-line summary or signature.</tt> </tt>
-<a name="L20"></a><tt class="py-lineno">20</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
-<a name="L21"></a><tt class="py-lineno">21</tt>  <tt class="py-line"><tt class="py-docstring">    Several sentences providing an extended description. You can put</tt> </tt>
-<a name="L22"></a><tt class="py-lineno">22</tt>  <tt class="py-line"><tt class="py-docstring">    text in mono-spaced type like so: ``var``.</tt> </tt>
-<a name="L23"></a><tt class="py-lineno">23</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
-<a name="L24"></a><tt class="py-lineno">24</tt>  <tt class="py-line"><tt class="py-docstring">    Parameters</tt> </tt>
-<a name="L25"></a><tt class="py-lineno">25</tt>  <tt class="py-line"><tt class="py-docstring">    ----------</tt> </tt>
-<a name="L26"></a><tt class="py-lineno">26</tt>  <tt class="py-line"><tt class="py-docstring">    var1 : array_like</tt> </tt>
-<a name="L27"></a><tt class="py-lineno">27</tt>  <tt class="py-line"><tt class="py-docstring">        Array_like means all those objects -- lists, nested lists, etc. --</tt> </tt>
-<a name="L28"></a><tt class="py-lineno">28</tt>  <tt class="py-line"><tt class="py-docstring">        that can be converted to an array.</tt> </tt>
-<a name="L29"></a><tt class="py-lineno">29</tt>  <tt class="py-line"><tt class="py-docstring">    var2 : integer</tt> </tt>
-<a name="L30"></a><tt class="py-lineno">30</tt>  <tt class="py-line"><tt class="py-docstring">        Write out the full type</tt> </tt>
-<a name="L31"></a><tt class="py-lineno">31</tt>  <tt class="py-line"><tt class="py-docstring">    long_variable_name : {'hi', 'ho'}, optional</tt> </tt>
-<a name="L32"></a><tt class="py-lineno">32</tt>  <tt class="py-line"><tt class="py-docstring">        Choices in brackets, default first when optional.</tt> </tt>
-<a name="L33"></a><tt class="py-lineno">33</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
-<a name="L34"></a><tt class="py-lineno">34</tt>  <tt class="py-line"><tt class="py-docstring">    Returns</tt> </tt>
-<a name="L35"></a><tt class="py-lineno">35</tt>  <tt class="py-line"><tt class="py-docstring">    -------</tt> </tt>
-<a name="L36"></a><tt class="py-lineno">36</tt>  <tt class="py-line"><tt class="py-docstring">    named : type</tt> </tt>
-<a name="L37"></a><tt class="py-lineno">37</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
-<a name="L38"></a><tt class="py-lineno">38</tt>  <tt class="py-line"><tt class="py-docstring">    list</tt> </tt>
-<a name="L39"></a><tt class="py-lineno">39</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
-<a name="L40"></a><tt class="py-lineno">40</tt>  <tt class="py-line"><tt class="py-docstring">    of</tt> </tt>
-<a name="L41"></a><tt class="py-lineno">41</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
-<a name="L42"></a><tt class="py-lineno">42</tt>  <tt class="py-line"><tt class="py-docstring">    outputs</tt> </tt>
-<a name="L43"></a><tt class="py-lineno">43</tt>  <tt class="py-line"><tt class="py-docstring">        even more explaining</tt> </tt>
-<a name="L44"></a><tt class="py-lineno">44</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
-<a name="L45"></a><tt class="py-lineno">45</tt>  <tt class="py-line"><tt class="py-docstring">    Other Parameters</tt> </tt>
-<a name="L46"></a><tt class="py-lineno">46</tt>  <tt class="py-line"><tt class="py-docstring">    ----------------</tt> </tt>
-<a name="L47"></a><tt class="py-lineno">47</tt>  <tt class="py-line"><tt class="py-docstring">    only_seldom_used_keywords : type</tt> </tt>
-<a name="L48"></a><tt class="py-lineno">48</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
-<a name="L49"></a><tt class="py-lineno">49</tt>  <tt class="py-line"><tt class="py-docstring">    common_parametrs_listed_above : type</tt> </tt>
-<a name="L50"></a><tt class="py-lineno">50</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
-<a name="L51"></a><tt class="py-lineno">51</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
-<a name="L52"></a><tt class="py-lineno">52</tt>  <tt class="py-line"><tt class="py-docstring">    See Also</tt> </tt>
-<a name="L53"></a><tt class="py-lineno">53</tt>  <tt class="py-line"><tt class="py-docstring">    --------    </tt> </tt>
-<a name="L54"></a><tt class="py-lineno">54</tt>  <tt class="py-line"><tt class="py-docstring">    otherfunc : relationship (optional)</tt> </tt>
-<a name="L55"></a><tt class="py-lineno">55</tt>  <tt class="py-line"><tt class="py-docstring">    newfunc : relationship (optional)</tt> </tt>
-<a name="L56"></a><tt class="py-lineno">56</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
-<a name="L57"></a><tt class="py-lineno">57</tt>  <tt class="py-line"><tt class="py-docstring">    Notes</tt> </tt>
-<a name="L58"></a><tt class="py-lineno">58</tt>  <tt class="py-line"><tt class="py-docstring">    -----</tt> </tt>
-<a name="L59"></a><tt class="py-lineno">59</tt>  <tt class="py-line"><tt class="py-docstring">    Notes about the implementation algorithm (if needed).</tt> </tt>
-<a name="L60"></a><tt class="py-lineno">60</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
-<a name="L61"></a><tt class="py-lineno">61</tt>  <tt class="py-line"><tt class="py-docstring">    This can have multiple paragraphs as can all sections.</tt> </tt>
-<a name="L62"></a><tt class="py-lineno">62</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
-<a name="L63"></a><tt class="py-lineno">63</tt>  <tt class="py-line"><tt class="py-docstring">    Examples</tt> </tt>
-<a name="L64"></a><tt class="py-lineno">64</tt>  <tt class="py-line"><tt class="py-docstring">    --------</tt> </tt>
-<a name="L65"></a><tt class="py-lineno">65</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L11"></a><tt class="py-lineno">11</tt>  <tt class="py-line"><tt class="py-name">__docformat__</tt> <tt class="py-op">=</tt> <tt class="py-string">"restructuredtext en"</tt> </tt>
+<a name="L12"></a><tt class="py-lineno">12</tt>  <tt class="py-line"> </tt>
+<a name="L13"></a><tt class="py-lineno">13</tt>  <tt class="py-line"><tt class="py-keyword">import</tt> <tt class="py-name">os</tt>                      <tt class="py-comment"># standard library imports first</tt> </tt>
+<a name="L14"></a><tt class="py-lineno">14</tt>  <tt class="py-line"> </tt>
+<a name="L15"></a><tt class="py-lineno">15</tt>  <tt class="py-line"><tt class="py-keyword">import</tt> <tt class="py-name">numpy</tt> <tt class="py-keyword">as</tt> <tt class="py-name">np</tt>             <tt class="py-comment"># related third party imports next</tt> </tt>
+<a name="L16"></a><tt class="py-lineno">16</tt>  <tt class="py-line"><tt class="py-keyword">import</tt> <tt class="py-name">scipy</tt> <tt class="py-keyword">as</tt> <tt class="py-name">sp</tt>             <tt class="py-comment"># imports should be at the top of the module</tt> </tt>
+<a name="L17"></a><tt class="py-lineno">17</tt>  <tt class="py-line"><tt class="py-keyword">import</tt> <tt class="py-name">matplotlib</tt> <tt class="py-keyword">as</tt> <tt class="py-name">mpl</tt>       <tt class="py-comment"># imports should usually be on separate lines</tt> </tt>
+<a name="L18"></a><tt class="py-lineno">18</tt>  <tt class="py-line"> </tt>
+<a name="foo"></a><div id="foo-def"><a name="L19"></a><tt class="py-lineno">19</tt> <a class="py-toggle" href="#" id="foo-toggle" onclick="return toggle('foo');">-</a><tt class="py-line"><tt class="py-keyword">def</tt> <a class="py-def-name" href="example-module.html#foo">foo</a><tt class="py-op">(</tt><tt class="py-param">var1</tt><tt class="py-op">,</tt> <tt class="py-param">var2</tt><tt class="py-op">,</tt> <tt class="py-param">long_var_name</tt><tt class="py-op">=</tt><tt class="py-string">'hi'</tt><tt class="py-op">)</tt> <tt class="py-op">:</tt> </tt>
+</div><div id="foo-collapsed" style="display:none;" pad="++" indent="++++"></div><div id="foo-expanded"><a name="L20"></a><tt class="py-lineno">20</tt>  <tt class="py-line">    <tt class="py-docstring">"""One-line summary or signature.</tt> </tt>
+<a name="L21"></a><tt class="py-lineno">21</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L22"></a><tt class="py-lineno">22</tt>  <tt class="py-line"><tt class="py-docstring">    Several sentences providing an extended description. You can put</tt> </tt>
+<a name="L23"></a><tt class="py-lineno">23</tt>  <tt class="py-line"><tt class="py-docstring">    text in mono-spaced type like so: ``var``.</tt> </tt>
+<a name="L24"></a><tt class="py-lineno">24</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L25"></a><tt class="py-lineno">25</tt>  <tt class="py-line"><tt class="py-docstring">    Parameters</tt> </tt>
+<a name="L26"></a><tt class="py-lineno">26</tt>  <tt class="py-line"><tt class="py-docstring">    ----------</tt> </tt>
+<a name="L27"></a><tt class="py-lineno">27</tt>  <tt class="py-line"><tt class="py-docstring">    var1 : array_like</tt> </tt>
+<a name="L28"></a><tt class="py-lineno">28</tt>  <tt class="py-line"><tt class="py-docstring">        Array_like means all those objects -- lists, nested lists, etc. --</tt> </tt>
+<a name="L29"></a><tt class="py-lineno">29</tt>  <tt class="py-line"><tt class="py-docstring">        that can be converted to an array.</tt> </tt>
+<a name="L30"></a><tt class="py-lineno">30</tt>  <tt class="py-line"><tt class="py-docstring">    var2 : integer</tt> </tt>
+<a name="L31"></a><tt class="py-lineno">31</tt>  <tt class="py-line"><tt class="py-docstring">        Write out the full type</tt> </tt>
+<a name="L32"></a><tt class="py-lineno">32</tt>  <tt class="py-line"><tt class="py-docstring">    long_variable_name : {'hi', 'ho'}, optional</tt> </tt>
+<a name="L33"></a><tt class="py-lineno">33</tt>  <tt class="py-line"><tt class="py-docstring">        Choices in brackets, default first when optional.</tt> </tt>
+<a name="L34"></a><tt class="py-lineno">34</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L35"></a><tt class="py-lineno">35</tt>  <tt class="py-line"><tt class="py-docstring">    Returns</tt> </tt>
+<a name="L36"></a><tt class="py-lineno">36</tt>  <tt class="py-line"><tt class="py-docstring">    -------</tt> </tt>
+<a name="L37"></a><tt class="py-lineno">37</tt>  <tt class="py-line"><tt class="py-docstring">    named : type</tt> </tt>
+<a name="L38"></a><tt class="py-lineno">38</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
+<a name="L39"></a><tt class="py-lineno">39</tt>  <tt class="py-line"><tt class="py-docstring">    list</tt> </tt>
+<a name="L40"></a><tt class="py-lineno">40</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
+<a name="L41"></a><tt class="py-lineno">41</tt>  <tt class="py-line"><tt class="py-docstring">    of</tt> </tt>
+<a name="L42"></a><tt class="py-lineno">42</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
+<a name="L43"></a><tt class="py-lineno">43</tt>  <tt class="py-line"><tt class="py-docstring">    outputs</tt> </tt>
+<a name="L44"></a><tt class="py-lineno">44</tt>  <tt class="py-line"><tt class="py-docstring">        even more explaining</tt> </tt>
+<a name="L45"></a><tt class="py-lineno">45</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L46"></a><tt class="py-lineno">46</tt>  <tt class="py-line"><tt class="py-docstring">    Other Parameters</tt> </tt>
+<a name="L47"></a><tt class="py-lineno">47</tt>  <tt class="py-line"><tt class="py-docstring">    ----------------</tt> </tt>
+<a name="L48"></a><tt class="py-lineno">48</tt>  <tt class="py-line"><tt class="py-docstring">    only_seldom_used_keywords : type</tt> </tt>
+<a name="L49"></a><tt class="py-lineno">49</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
+<a name="L50"></a><tt class="py-lineno">50</tt>  <tt class="py-line"><tt class="py-docstring">    common_parametrs_listed_above : type</tt> </tt>
+<a name="L51"></a><tt class="py-lineno">51</tt>  <tt class="py-line"><tt class="py-docstring">        Explanation</tt> </tt>
+<a name="L52"></a><tt class="py-lineno">52</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L53"></a><tt class="py-lineno">53</tt>  <tt class="py-line"><tt class="py-docstring">    See Also</tt> </tt>
+<a name="L54"></a><tt class="py-lineno">54</tt>  <tt class="py-line"><tt class="py-docstring">    --------    </tt> </tt>
+<a name="L55"></a><tt class="py-lineno">55</tt>  <tt class="py-line"><tt class="py-docstring">    otherfunc : relationship (optional)</tt> </tt>
+<a name="L56"></a><tt class="py-lineno">56</tt>  <tt class="py-line"><tt class="py-docstring">    newfunc : relationship (optional)</tt> </tt>
+<a name="L57"></a><tt class="py-lineno">57</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L58"></a><tt class="py-lineno">58</tt>  <tt class="py-line"><tt class="py-docstring">    Notes</tt> </tt>
+<a name="L59"></a><tt class="py-lineno">59</tt>  <tt class="py-line"><tt class="py-docstring">    -----</tt> </tt>
+<a name="L60"></a><tt class="py-lineno">60</tt>  <tt class="py-line"><tt class="py-docstring">    Notes about the implementation algorithm (if needed).</tt> </tt>
+<a name="L61"></a><tt class="py-lineno">61</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L62"></a><tt class="py-lineno">62</tt>  <tt class="py-line"><tt class="py-docstring">    This can have multiple paragraphs as can all sections.</tt> </tt>
+<a name="L63"></a><tt class="py-lineno">63</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
+<a name="L64"></a><tt class="py-lineno">64</tt>  <tt class="py-line"><tt class="py-docstring">    Examples</tt> </tt>
+<a name="L65"></a><tt class="py-lineno">65</tt>  <tt class="py-line"><tt class="py-docstring">    --------</tt> </tt>
 <a name="L66"></a><tt class="py-lineno">66</tt>  <tt class="py-line"><tt class="py-docstring">    examples in doctest format</tt> </tt>
 <a name="L67"></a><tt class="py-lineno">67</tt>  <tt class="py-line"><tt class="py-docstring"></tt> </tt>
 <a name="L68"></a><tt class="py-lineno">68</tt>  <tt class="py-line"><tt class="py-docstring">    &gt;&gt;&gt; a=[1,2,3]</tt> </tt>
@@ -182,7 +182,7 @@
 <table border="0" cellpadding="0" cellspacing="0" width="100%%">
   <tr>
     <td align="left" class="footer">
-    Generated by Epydoc 3.0beta1 on Fri Dec 28 00:50:17 2007
+    Generated by Epydoc 3.0beta1 on Tue Jan 22 00:26:36 2008
     </td>
     <td align="right" class="footer">
       <a target="mainFrame" href="http://epydoc.sourceforge.net"

Modified: branches/build_with_scons/numpy/doc/html/help.html
===================================================================
--- branches/build_with_scons/numpy/doc/html/help.html	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/doc/html/help.html	2008-02-08 09:48:31 UTC (rev 4772)
@@ -246,7 +246,7 @@
 <table border="0" cellpadding="0" cellspacing="0" width="100%%">
   <tr>
     <td align="left" class="footer">
-    Generated by Epydoc 3.0beta1 on Fri Dec 28 00:50:17 2007
+    Generated by Epydoc 3.0beta1 on Tue Jan 22 00:26:36 2008
     </td>
     <td align="right" class="footer">
       <a target="mainFrame" href="http://epydoc.sourceforge.net"

Modified: branches/build_with_scons/numpy/doc/html/identifier-index.html
===================================================================
--- branches/build_with_scons/numpy/doc/html/identifier-index.html	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/doc/html/identifier-index.html	2008-02-08 09:48:31 UTC (rev 4772)
@@ -158,7 +158,7 @@
 <table border="0" cellpadding="0" cellspacing="0" width="100%%">
   <tr>
     <td align="left" class="footer">
-    Generated by Epydoc 3.0beta1 on Fri Dec 28 00:50:17 2007
+    Generated by Epydoc 3.0beta1 on Tue Jan 22 00:26:36 2008
     </td>
     <td align="right" class="footer">
       <a target="mainFrame" href="http://epydoc.sourceforge.net"

Modified: branches/build_with_scons/numpy/doc/html/module-tree.html
===================================================================
--- branches/build_with_scons/numpy/doc/html/module-tree.html	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/doc/html/module-tree.html	2008-02-08 09:48:31 UTC (rev 4772)
@@ -79,7 +79,7 @@
 <table border="0" cellpadding="0" cellspacing="0" width="100%%">
   <tr>
     <td align="left" class="footer">
-    Generated by Epydoc 3.0beta1 on Fri Dec 28 00:50:17 2007
+    Generated by Epydoc 3.0beta1 on Tue Jan 22 00:26:36 2008
     </td>
     <td align="right" class="footer">
       <a target="mainFrame" href="http://epydoc.sourceforge.net"

Modified: branches/build_with_scons/numpy/f2py/crackfortran.py
===================================================================
--- branches/build_with_scons/numpy/f2py/crackfortran.py	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/f2py/crackfortran.py	2008-02-08 09:48:31 UTC (rev 4772)
@@ -791,7 +791,7 @@
             grouplist[groupcounter]=[]
         if needinterface:
             if verbose>1:
-                outmess('analyzeline: Creating additional interface block.\n',0)
+                outmess('analyzeline: Creating additional interface block (groupcounter=%s).\n' % (groupcounter),0)
             groupname[groupcounter]='interface'
             groupcache[groupcounter]['block']='interface'
             groupcache[groupcounter]['name']='unknown_interface'
@@ -892,6 +892,7 @@
             pl = ch[0]
             outmess('analyzeline: cannot handle multiple attributes without type specification. Ignoring %r.\n' % (','.join(ch[1:])))
         last_name = None
+
         for e in [x.strip() for x in markoutercomma(ll).split('@,@')]:
             m1=namepattern.match(e)
             if not m1:
@@ -910,11 +911,14 @@
                 ap=m.group('this')+pl
                 if _intentcallbackpattern.match(ap):
                     if k not in groupcache[groupcounter]['args']:
-                        if groupcounter>1 and \
-                               '__user__' in groupcache[groupcounter-2]['name']:
+                        if groupcounter>1:
                             outmess('analyzeline: appending intent(callback) %s'\
                                     ' to %s arguments\n' % (k,groupcache[groupcounter]['name']))
+                            if '__user__' not in groupcache[groupcounter-2]['name']:
+                                outmess('analyzeline: missing __user__ module (could be nothing)\n')
                             groupcache[groupcounter]['args'].append(k)
+                        else:
+                            errmess('analyzeline: intent(callback) %s is ignored' % (k))
                     else:
                         errmess('analyzeline: intent(callback) %s is already'\
                                 ' in argument list' % (k))

Modified: branches/build_with_scons/numpy/f2py/src/fortranobject.c
===================================================================
--- branches/build_with_scons/numpy/f2py/src/fortranobject.c	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/f2py/src/fortranobject.c	2008-02-08 09:48:31 UTC (rev 4772)
@@ -694,18 +694,20 @@
         npy_intp new_size = 1;
         int free_axe = -1;
         int i;
+        npy_intp d;
         /* Fill dims where -1 or 0; check dimensions; calc new_size; */
         for(i=0;i<arr->nd;++i) {
+            d = arr->dimensions[i];
             if (dims[i] >= 0) {
-                if (dims[i]!=arr->dimensions[i]) {
+                if (d>1 && dims[i]!=d) {
                     fprintf(stderr,"%d-th dimension must be fixed to %" NPY_INTP_FMT
                             " but got %" NPY_INTP_FMT "\n",
-                            i,dims[i], arr->dimensions[i]);
+                            i,dims[i], d);
                     return 1;
                 }
                 if (!dims[i]) dims[i] = 1;
             } else {
-                dims[i] = arr->dimensions[i] ? arr->dimensions[i] : 1;
+                dims[i] = d ? d : 1;
             }
             new_size *= dims[i];
         }
@@ -724,16 +726,17 @@
             new_size *= dims[free_axe];
         }
         if (new_size != arr_size) {
-            fprintf(stderr,"confused: new_size=%" NPY_INTP_FMT
-                    ", arr_size=%" NPY_INTP_FMT " (maybe too many free"
+            fprintf(stderr,"unexpected array size: new_size=%" NPY_INTP_FMT
+                    ", got array with arr_size=%" NPY_INTP_FMT " (maybe too many free"
                     " indices)\n", new_size,arr_size);
             return 1;
         }
     } else if (rank==arr->nd) {
+        npy_intp new_size = 1;
         int i;
         npy_intp d;
         for (i=0; i<rank; ++i) {
-            d = arr->dimensions[i];
+	    d = arr->dimensions[i];
             if (dims[i]>=0) {
                 if (d > 1 && d!=dims[i]) {
                     fprintf(stderr,"%d-th dimension must be fixed to %" NPY_INTP_FMT
@@ -743,7 +746,13 @@
                 }
                 if (!dims[i]) dims[i] = 1;
             } else dims[i] = d;
+            new_size *= dims[i];
         }
+        if (new_size != arr_size) {
+            fprintf(stderr,"unexpected array size: new_size=%" NPY_INTP_FMT
+                    ", got array with arr_size=%" NPY_INTP_FMT "\n", new_size,arr_size);
+            return 1;
+        }
     } else { /* [[1,2]] -> [[1],[2]] */
         int i,j;
         npy_intp d;
@@ -782,7 +791,7 @@
         }
         for (i=0,size=1;i<rank;++i) size *= dims[i];
         if (size != arr_size) {
-            fprintf(stderr,"confused: size=%" NPY_INTP_FMT ", arr_size=%" NPY_INTP_FMT
+            fprintf(stderr,"unexpected array size: size=%" NPY_INTP_FMT ", arr_size=%" NPY_INTP_FMT
                     ", rank=%d, effrank=%d, arr.nd=%d, dims=[",
                     size,arr_size,rank,effrank,arr->nd);
             for (i=0;i<rank;++i) fprintf(stderr," %" NPY_INTP_FMT,dims[i]);

Modified: branches/build_with_scons/numpy/lib/function_base.py
===================================================================
--- branches/build_with_scons/numpy/lib/function_base.py	2008-02-07 17:00:02 UTC (rev 4771)
+++ branches/build_with_scons/numpy/lib/function_base.py	2008-02-08 09:48:31 UTC (rev 4772)
@@ -151,6 +151,7 @@
             mx += 0.5
         bins = linspace(mn, mx, bins, endpoint=False)
     else:
+        bins = asarray(bins)
         if(any(bins[1:]-bins[:-1] < 0)):
             raise AttributeError, 'bins must increase monotonically.'
 



From numpy-svn at scipy.org  Fri Feb  8 05:13:36 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  8 Feb 2008 04:13:36 -0600 (CST)
Subject: [Numpy-svn] r4773 - in trunk: . numpy numpy/core
	numpy/core/code_generators numpy/core/include/numpy
	numpy/core/src numpy/distutils numpy/distutils/command
	numpy/f2py numpy/fft numpy/lib numpy/linalg numpy/numarray
	numpy/oldnumeric numpy/random numpy/testing
Message-ID: <20080208101336.85EA439C34C@new.scipy.org>

Author: jarrod.millman
Date: 2008-02-08 04:12:16 -0600 (Fri, 08 Feb 2008)
New Revision: 4773

Added:
   trunk/numpy/core/SConstruct
   trunk/numpy/core/code_generators/__init__.py
   trunk/numpy/core/include/numpy/numpyconfig.h.in
   trunk/numpy/core/scons_support.py
   trunk/numpy/core/setupscons.py
   trunk/numpy/distutils/command/scons.py
   trunk/numpy/distutils/numpy_distribution.py
   trunk/numpy/distutils/setupscons.py
   trunk/numpy/f2py/setupscons.py
   trunk/numpy/fft/SConstruct
   trunk/numpy/fft/setupscons.py
   trunk/numpy/lib/SConstruct
   trunk/numpy/lib/setupscons.py
   trunk/numpy/linalg/SConstruct
   trunk/numpy/linalg/setupscons.py
   trunk/numpy/numarray/SConstruct
   trunk/numpy/numarray/setupscons.py
   trunk/numpy/oldnumeric/setupscons.py
   trunk/numpy/random/SConstruct
   trunk/numpy/random/setupscons.py
   trunk/numpy/setupscons.py
   trunk/numpy/testing/setupscons.py
   trunk/setupscons.py
   trunk/test.sh
Modified:
   trunk/
   trunk/numpy/core/code_generators/generate_array_api.py
   trunk/numpy/core/code_generators/generate_ufunc_api.py
   trunk/numpy/core/include/numpy/ndarrayobject.h
   trunk/numpy/core/setup.py
   trunk/numpy/core/src/arraytypes.inc.src
   trunk/numpy/core/src/multiarraymodule.c
   trunk/numpy/core/src/umathmodule.c.src
   trunk/numpy/distutils/command/build.py
   trunk/numpy/distutils/command/config.py
   trunk/numpy/distutils/core.py
   trunk/numpy/distutils/misc_util.py
Log:
merging David Cournapeau's build_with_scons branch, which adds scons support to numpy.distutils and modifies the configuration of numpy/core



Property changes on: trunk
___________________________________________________________________
Name: svnmerge-integrated
   - /branches/build_with_scons:1-4676 /branches/cleanconfig_rtm:1-4610 /branches/distutils-revamp:1-2752 /branches/distutils_scons_command:1-4619 /branches/multicore:1-3687 /branches/numpy.scons:1-4484 /trunk:1-2871
   + /branches/build_with_scons:1-4676 /branches/cleanconfig_rtm:1-4677 /branches/distutils-revamp:1-2752 /branches/distutils_scons_command:1-4619 /branches/multicore:1-3687 /branches/numpy.scons:1-4484 /trunk:1-2871


Copied: trunk/numpy/core/SConstruct (from rev 4772, branches/build_with_scons/numpy/core/SConstruct)

Copied: trunk/numpy/core/code_generators/__init__.py (from rev 4772, branches/build_with_scons/numpy/core/code_generators/__init__.py)

Modified: trunk/numpy/core/code_generators/generate_array_api.py
===================================================================
--- trunk/numpy/core/code_generators/generate_array_api.py	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/core/code_generators/generate_array_api.py	2008-02-08 10:12:16 UTC (rev 4773)
@@ -1,9 +1,6 @@
 import os
 import genapi
 
-OBJECT_API_ORDER = 'array_api_order.txt'
-MULTIARRAY_API_ORDER = 'multiarray_api_order.txt'
-
 types = ['Generic','Number','Integer','SignedInteger','UnsignedInteger',
          'Inexact',
          'Floating', 'ComplexFloating', 'Flexible', 'Character',
@@ -122,22 +119,30 @@
 """
 
 def generate_api(output_dir, force=False):
-    header_file = os.path.join(output_dir, '__multiarray_api.h')
-    c_file = os.path.join(output_dir,'__multiarray_api.c')
-    doc_file = os.path.join(output_dir, 'multiarray_api.txt')
+    basename = 'multiarray_api'
 
-    targets = (header_file, c_file, doc_file)
-    if (not force
-            and not genapi.should_rebuild(targets,
-                                          [OBJECT_API_ORDER,
-                                           MULTIARRAY_API_ORDER,
-                                           __file__])):
+    h_file = os.path.join(output_dir, '__%s.h' % basename)
+    c_file = os.path.join(output_dir, '__%s.c' % basename)
+    d_file = os.path.join(output_dir, '%s.txt' % basename)
+    targets = (h_file, c_file, d_file)
+    sources = ['array_api_order.txt',  'multiarray_api_order.txt']
+
+    if (not force and not genapi.should_rebuild(targets, sources + [__file__])):
         return targets
+    else:
+        do_generate_api(targets, sources)
 
+    return targets
+
+def do_generate_api(targets, sources):
+    header_file = targets[0]
+    c_file = targets[1]
+    doc_file = targets[2]
+
     objectapi_list = genapi.get_api_functions('OBJECT_API',
-                                              OBJECT_API_ORDER)
+                                              sources[0])
     multiapi_list = genapi.get_api_functions('MULTIARRAY_API',
-                                             MULTIARRAY_API_ORDER)
+                                             sources[1])
     # API fixes for __arrayobject_api.h
 
     fixed = 10

Modified: trunk/numpy/core/code_generators/generate_ufunc_api.py
===================================================================
--- trunk/numpy/core/code_generators/generate_ufunc_api.py	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/core/code_generators/generate_ufunc_api.py	2008-02-08 10:12:16 UTC (rev 4773)
@@ -1,8 +1,6 @@
 import os
 import genapi
 
-UFUNC_API_ORDER = 'ufunc_api_order.txt'
-
 h_template = r"""
 #ifdef _UMATHMODULE
 
@@ -72,18 +70,29 @@
 """
 
 def generate_api(output_dir, force=False):
-    header_file = os.path.join(output_dir, '__ufunc_api.h')
-    c_file = os.path.join(output_dir, '__ufunc_api.c')
-    doc_file = os.path.join(output_dir, 'ufunc_api.txt')
+    basename = 'ufunc_api'
+    
+    h_file = os.path.join(output_dir, '__%s.h' % basename)
+    c_file = os.path.join(output_dir, '__%s.c' % basename)
+    d_file = os.path.join(output_dir, '%s.txt' % basename)
+    targets = (h_file, c_file, d_file)
 
-    targets = (header_file, c_file, doc_file)
-    if (not force
-            and not genapi.should_rebuild(targets,
-                                          [UFUNC_API_ORDER, __file__])):
+    sources = ['ufunc_api_order.txt']
+
+    if (not force and not genapi.should_rebuild(targets, sources + [__file__])):
         return targets
+    else:
+        do_generate_api(targets, sources)
 
-    ufunc_api_list = genapi.get_api_functions('UFUNC_API', UFUNC_API_ORDER)
+    return targets
 
+def do_generate_api(targets, sources):
+    header_file = targets[0]
+    c_file = targets[1]
+    doc_file = targets[2]
+
+    ufunc_api_list = genapi.get_api_functions('UFUNC_API', sources[0])
+
     # API fixes for __arrayobject_api.h
 
     fixed = 1

Modified: trunk/numpy/core/include/numpy/ndarrayobject.h
===================================================================
--- trunk/numpy/core/include/numpy/ndarrayobject.h	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/core/include/numpy/ndarrayobject.h	2008-02-08 10:12:16 UTC (rev 4773)
@@ -13,8 +13,15 @@
        everything when you're typing */
 #endif
 /* This is auto-generated by the installer */
-#include "config.h"
+#include "numpyconfig.h"
 
+/* Only use thread if configured in config and python supports it */
+#if defined WITH_THREAD && !NPY_NO_SMP
+        #define NPY_ALLOW_THREADS 1
+#else
+        #define NPY_ALLOW_THREADS 0
+#endif
+
 /* There are several places in the code where an array of dimensions is
  * allocated statically.  This is the size of that static allocation.
  *
@@ -80,7 +87,8 @@
 #define NPY_FALSE 0
 #define NPY_TRUE 1
 
-#if SIZEOF_LONG_DOUBLE==SIZEOF_DOUBLE
+
+#if NPY_SIZEOF_LONGDOUBLE == NPY_SIZEOF_DOUBLE
         typedef double npy_longdouble;
         #define NPY_LONGDOUBLE_FMT "g"
 #else
@@ -279,22 +287,15 @@
 #define NPY_MAX_ULONG  ULONG_MAX
 
 
-#define NPY_SIZEOF_LONG SIZEOF_LONG
-#define NPY_SIZEOF_INT SIZEOF_INT
-#define NPY_SIZEOF_SHORT SIZEOF_SHORT
-#define NPY_SIZEOF_FLOAT SIZEOF_FLOAT
-#define NPY_SIZEOF_DOUBLE SIZEOF_DOUBLE
-#define NPY_SIZEOF_LONGDOUBLE SIZEOF_LONG_DOUBLE
-#define NPY_SIZEOF_LONGLONG SIZEOF_LONG_LONG
 #define NPY_BITSOF_BOOL (sizeof(npy_bool)*CHAR_BIT)
 #define NPY_BITSOF_CHAR CHAR_BIT
-#define NPY_BITSOF_SHORT (SIZEOF_SHORT*CHAR_BIT)
-#define NPY_BITSOF_INT (SIZEOF_INT*CHAR_BIT)
-#define NPY_BITSOF_LONG (SIZEOF_LONG*CHAR_BIT)
-#define NPY_BITSOF_LONGLONG (NPY_SIZEOF_LONGLONG*CHAR_BIT)
-#define NPY_BITSOF_FLOAT (SIZEOF_FLOAT*CHAR_BIT)
-#define NPY_BITSOF_DOUBLE (SIZEOF_DOUBLE*CHAR_BIT)
-#define NPY_BITSOF_LONGDOUBLE (NPY_SIZEOF_LONGDOUBLE*CHAR_BIT)
+#define NPY_BITSOF_SHORT (NPY_SIZEOF_SHORT * CHAR_BIT)
+#define NPY_BITSOF_INT (NPY_SIZEOF_INT * CHAR_BIT)
+#define NPY_BITSOF_LONG (NPY_SIZEOF_LONG * CHAR_BIT)
+#define NPY_BITSOF_LONGLONG (NPY_SIZEOF_LONGLONG * CHAR_BIT)
+#define NPY_BITSOF_FLOAT (NPY_SIZEOF_FLOAT * CHAR_BIT)
+#define NPY_BITSOF_DOUBLE (NPY_SIZEOF_DOUBLE * CHAR_BIT)
+#define NPY_BITSOF_LONGDOUBLE (NPY_SIZEOF_LONGDOUBLE * CHAR_BIT)
 
 #if NPY_BITSOF_LONG == 8
 #define NPY_INT8 NPY_LONG
@@ -918,8 +919,8 @@
  * platform.  Py_intptr_t, Py_uintptr_t are defined in pyport.h. */
 typedef Py_intptr_t npy_intp;
 typedef Py_uintptr_t npy_uintp;
-#define NPY_SIZEOF_INTP SIZEOF_PY_INTPTR_T
-#define NPY_SIZEOF_UINTP SIZEOF_PY_INTPTR_T
+#define NPY_SIZEOF_INTP NPY_SIZEOF_PY_INTPTR_T
+#define NPY_SIZEOF_UINTP NPY_SIZEOF_PY_INTPTR_T
 
 #ifdef constchar
 #undef constchar
@@ -940,7 +941,7 @@
 #define constchar char
 #endif
 
-#if SIZEOF_PY_INTPTR_T == SIZEOF_INT
+#if NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_INT
         #define NPY_INTP NPY_INT
         #define NPY_UINTP NPY_UINT
         #define PyIntpArrType_Type PyIntArrType_Type
@@ -949,7 +950,7 @@
         #define NPY_MIN_INTP NPY_MIN_INT
         #define NPY_MAX_UINTP NPY_MAX_UINT
         #define NPY_INTP_FMT "d"
-#elif SIZEOF_PY_INTPTR_T == SIZEOF_LONG
+#elif NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONG
         #define NPY_INTP NPY_LONG
         #define NPY_UINTP NPY_ULONG
         #define PyIntpArrType_Type PyLongArrType_Type
@@ -958,7 +959,7 @@
         #define NPY_MIN_INTP MIN_LONG
         #define NPY_MAX_UINTP NPY_MAX_ULONG
         #define NPY_INTP_FMT "ld"
-#elif defined(PY_LONG_LONG) && (SIZEOF_PY_INTPTR_T == SIZEOF_LONG_LONG)
+#elif defined(PY_LONG_LONG) && (NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONGLONG)
         #define NPY_INTP NPY_LONGLONG
         #define NPY_UINTP NPY_ULONGLONG
         #define PyIntpArrType_Type PyLongLongArrType_Type
@@ -1894,7 +1895,7 @@
 
 #define PyArray_REFCOUNT(obj) (((PyObject *)(obj))->ob_refcnt)
 #define NPY_REFCOUNT PyArray_REFCOUNT
-#define NPY_MAX_ELSIZE (2*SIZEOF_LONGDOUBLE)
+#define NPY_MAX_ELSIZE (2 * NPY_SIZEOF_LONGDOUBLE)
 
 #define PyArray_ContiguousFromAny(op, type, min_depth, max_depth)             \
         PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,           \

Copied: trunk/numpy/core/include/numpy/numpyconfig.h.in (from rev 4772, branches/build_with_scons/numpy/core/include/numpy/numpyconfig.h.in)

Copied: trunk/numpy/core/scons_support.py (from rev 4772, branches/build_with_scons/numpy/core/scons_support.py)

Modified: trunk/numpy/core/setup.py
===================================================================
--- trunk/numpy/core/setup.py	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/core/setup.py	2008-02-08 10:12:16 UTC (rev 4773)
@@ -18,6 +18,36 @@
     ('rint', 'HAVE_RINT'),
     ]
 
+def is_npy_no_signal():
+    """Return True if the NPY_NO_SIGNAL symbol must be defined in configuration
+    header."""
+    return sys.platform == 'win32'
+
+def is_npy_no_smp():
+    """Return True if the NPY_NO_SMP symbol must be defined in public
+    header (when SMP support cannot be reliably enabled)."""
+    # Python 2.3 causes a segfault when
+    #  trying to re-acquire the thread-state
+    #  which is done in error-handling
+    #  ufunc code.  NPY_ALLOW_C_API and friends
+    #  cause the segfault. So, we disable threading
+    #  for now.
+    if sys.version[:5] < '2.4.2':
+        nosmp = 1
+    else:
+        # Perhaps a fancier check is in order here.
+        #  so that threads are only enabled if there
+        #  are actually multiple CPUS? -- but
+        #  threaded code can be nice even on a single
+        #  CPU so that long-calculating code doesn't
+        #  block.
+        try:
+            nosmp = os.environ['NPY_NOSMP']
+            nosmp = 1
+        except KeyError:
+            nosmp = 0
+    return nosmp == 1
+
 def configuration(parent_package='',top_path=None):
     from numpy.distutils.misc_util import Configuration,dot_join
     from numpy.distutils.system_info import get_info, default_lib_dirs
@@ -53,28 +83,7 @@
                 raise SystemError,"Failed to test configuration. "\
                       "See previous error messages for more information."
 
-                # Python 2.3 causes a segfault when
-                #  trying to re-acquire the thread-state
-                #  which is done in error-handling
-                #  ufunc code.  NPY_ALLOW_C_API and friends
-                #  cause the segfault. So, we disable threading
-                #  for now.
-            if sys.version[:5] < '2.4.2':
-                nosmp = 1
-            else:
-                # Perhaps a fancier check is in order here.
-                #  so that threads are only enabled if there
-                #  are actually multiple CPUS? -- but
-                #  threaded code can be nice even on a single
-                #  CPU so that long-calculating code doesn't
-                #  block.
-                try:
-                    nosmp = os.environ['NPY_NOSMP']
-                    nosmp = 1
-                except KeyError:
-                    nosmp = 0
-            if nosmp: moredefs = [('NPY_ALLOW_THREADS', '0')]
-            else: moredefs = []
+            moredefs = []
             #
             mathlibs = []
             tc = testcode_mathlib()
@@ -102,8 +111,8 @@
                 if check_func(func_name):
                     moredefs.append(defsymbol)
 
-            if sys.platform == 'win32':
-                moredefs.append('NPY_NO_SIGNAL')
+            if is_npy_no_signal():
+                moredefs.append('__NPY_PRIVATE_NO_SIGNAL')
 
             if sys.platform=='win32' or os.name=='nt':
                 from distutils.msvccompiler import get_build_architecture
@@ -123,8 +132,6 @@
                     target_f.write('#define %s\n' % (d))
                 else:
                     target_f.write('#define %s %s\n' % (d[0],d[1]))
-            if not nosmp:  # default is to use WITH_THREAD
-                target_f.write('#ifdef WITH_THREAD\n#define NPY_ALLOW_THREADS 1\n#else\n#define NPY_ALLOW_THREADS 0\n#endif\n')
             target_f.close()
             print 'File:',target
             target_f = open(target)
@@ -151,6 +158,39 @@
         config.add_data_files((header_dir,target))
         return target
 
+    def generate_numpyconfig_h(ext, build_dir):
+        """Depends on config.h: generate_config_h has to be called before !"""
+        target = join(build_dir,'numpyconfig.h')
+        if newer(__file__,target):
+            config_cmd = config.get_config_cmd()
+            log.info('Generating %s',target)
+            testcode = generate_numpyconfig_code(target)
+
+            from distutils import sysconfig
+            python_include = sysconfig.get_python_inc()
+            python_h = join(python_include, 'Python.h')
+            if not os.path.isfile(python_h):
+                raise SystemError,\
+                      "Non-existing %s. Perhaps you need to install"\
+                      " python-dev|python-devel." % (python_h)
+
+            config.numpy_include_dirs
+            result = config_cmd.try_run(testcode, 
+                                include_dirs = [python_include] + \
+                                                       config.numpy_include_dirs,
+                                        library_dirs = default_lib_dirs)
+
+            if not result:
+                raise SystemError,"Failed to generate numpy configuration. "\
+                      "See previous error messages for more information."
+
+            print 'File: %s' % target
+            target_f = open(target)
+            print target_f.read()
+            target_f.close()
+            print 'EOF'
+        return target
+                                
     def generate_api_func(module_name):
         def generate_api(ext, build_dir):
             script = join(codegen_dir, module_name + '.py')
@@ -205,6 +245,7 @@
     config.add_extension('multiarray',
                          sources = [join('src','multiarraymodule.c'),
                                     generate_config_h,
+                                    generate_numpyconfig_h,
                                     generate_array_api,
                                     join('src','scalartypes.inc.src'),
                                     join('src','arraytypes.inc.src'),
@@ -216,6 +257,7 @@
 
     config.add_extension('umath',
                          sources = [generate_config_h,
+                                    generate_numpyconfig_h,
                                     join('src','umathmodule.c.src'),
                                     generate_umath_c,
                                     generate_ufunc_api,
@@ -231,6 +273,7 @@
     config.add_extension('_sort',
                          sources=[join('src','_sortmodule.c.src'),
                                   generate_config_h,
+                                  generate_numpyconfig_h,
                                   generate_array_api,
                                   ],
                          )
@@ -238,6 +281,7 @@
     config.add_extension('scalarmath',
                          sources=[join('src','scalarmathmodule.c.src'),
                                   generate_config_h,
+                                  generate_numpyconfig_h,
                                   generate_array_api,
                                   generate_ufunc_api],
                          )
@@ -342,6 +386,85 @@
     testcode = '\n'.join(testcode)
     return testcode
 
+def generate_numpyconfig_code(target):
+    """Return the source code as a string of the code to generate the
+    numpyconfig header file."""
+    if sys.platform == 'win32':
+        target = target.replace('\\','\\\\')
+    # Config symbols to prepend
+    prepends = [('NPY_SIZEOF_SHORT', 'SIZEOF_SHORT'),
+            ('NPY_SIZEOF_INT', 'SIZEOF_INT'),
+            ('NPY_SIZEOF_LONG', 'SIZEOF_LONG'),
+            ('NPY_SIZEOF_FLOAT', 'SIZEOF_FLOAT'),
+            ('NPY_SIZEOF_DOUBLE', 'SIZEOF_DOUBLE'),
+            ('NPY_SIZEOF_LONGDOUBLE', 'SIZEOF_LONG_DOUBLE'),
+            ('NPY_SIZEOF_PY_INTPTR_T', 'SIZEOF_PY_INTPTR_T')]
+
+    testcode = ["""
+#include <Python.h>
+#include "config.h"
+
+int main()
+{   
+    FILE* f;
+   
+    f = fopen("%s", "w");
+    if (f == NULL) {
+        return -1;
+    }
+""" % target]
+
+    testcode.append(r"""
+    fprintf(f, "/*\n * This file is generated by %s. DO NOT EDIT \n */\n");
+""" % __file__)
+
+    # Prepend NPY_ to any SIZEOF defines
+    testcode.extend([r'    fprintf(f, "#define ' + i + r' %%d \n", %s);' % j for i, j in prepends])
+
+    # Conditionally define NPY_NO_SIGNAL
+    if is_npy_no_signal():
+        testcode.append(r'    fprintf(f, "\n#define NPY_NO_SIGNAL\n");')
+
+    # Define NPY_NOSMP to 1 if explicitely requested, or if we cannot
+    # support thread support reliably
+    if is_npy_no_smp():
+        testcode.append(r'    fprintf(f, "#define NPY_NO_SMP 1\n");')
+    else:
+        testcode.append(r'    fprintf(f, "#define NPY_NO_SMP 0\n");')
+
+    tmpcode = r"""
+    #ifdef PY_LONG_LONG
+        fprintf(f, "\n#define %s %%d \n", %s);
+        fprintf(f, "#define %s %%d \n", %s);
+    #else
+        fprintf(f, "/* PY_LONG_LONG not defined  */ \n");
+    #endif"""
+    testcode.append(tmpcode % ('NPY_SIZEOF_LONGLONG', 'SIZEOF_LONG_LONG',
+                               'NPY_SIZEOF_PY_LONG_LONG', 'SIZEOF_PY_LONG_LONG'))
+
+    testcode.append(r"""
+#ifndef CHAR_BIT
+          {
+             unsigned char var = 2;
+             int i = 0;
+             while (var >= 2) {
+                     var = var << 1;
+                     i++;
+             }
+             fprintf(f,"#define CHAR_BIT %d\n", i+1);
+          }
+#else
+          fprintf(f, "/* #define CHAR_BIT %d */\n", CHAR_BIT);
+#endif""")
+
+    testcode.append("""
+    fclose(f);
+
+    return 0;
+}
+""")
+    return "\n".join(testcode)
+
 if __name__=='__main__':
     from numpy.distutils.core import setup
     setup(configuration=configuration)

Copied: trunk/numpy/core/setupscons.py (from rev 4772, branches/build_with_scons/numpy/core/setupscons.py)

Modified: trunk/numpy/core/src/arraytypes.inc.src
===================================================================
--- trunk/numpy/core/src/arraytypes.inc.src	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/core/src/arraytypes.inc.src	2008-02-08 10:12:16 UTC (rev 4773)
@@ -1,4 +1,5 @@
 /* -*- c -*- */
+#include "config.h"
 
 static longlong
 MyPyLong_AsLongLong(PyObject *vv)

Modified: trunk/numpy/core/src/multiarraymodule.c
===================================================================
--- trunk/numpy/core/src/multiarraymodule.c	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/core/src/multiarraymodule.c	2008-02-08 10:12:16 UTC (rev 4773)
@@ -7269,7 +7269,7 @@
 }
 
 
-#ifndef NPY_NO_SIGNAL
+#ifndef __NPY_PRIVATE_NO_SIGNAL
 
 SIGJMP_BUF _NPY_SIGINT_BUF;
 

Modified: trunk/numpy/core/src/umathmodule.c.src
===================================================================
--- trunk/numpy/core/src/umathmodule.c.src	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/core/src/umathmodule.c.src	2008-02-08 10:12:16 UTC (rev 4773)
@@ -5,6 +5,7 @@
 #define _UMATHMODULE
 #include "numpy/ufuncobject.h"
 #include "abstract.h"
+#include "config.h"
 #include <math.h>
 
 /* A whole slew of basic math functions are provided originally

Modified: trunk/numpy/distutils/command/build.py
===================================================================
--- trunk/numpy/distutils/command/build.py	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/distutils/command/build.py	2008-02-08 10:12:16 UTC (rev 4773)
@@ -32,3 +32,9 @@
         if build_scripts is None:
             self.build_scripts = os.path.join(self.build_base,
                                               'scripts' + plat_specifier)
+
+    def run(self):
+        # Make sure that scons based extensions are complete.
+        self.run_command('scons')
+
+        old_build.run(self)

Modified: trunk/numpy/distutils/command/config.py
===================================================================
--- trunk/numpy/distutils/command/config.py	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/distutils/command/config.py	2008-02-08 10:12:16 UTC (rev 4773)
@@ -101,6 +101,21 @@
                                  (body, headers, include_dirs,
                                   libraries, library_dirs, lang))
 
+    def check_decl(self, symbol,
+                   headers=None, include_dirs=None):
+        self._check_compiler()
+        body = """
+int main()
+{
+#ifndef %s
+    (void) %s;
+#endif
+    ;
+    return 0;
+}""" % (symbol, symbol)
+
+        return self.try_compile(body, headers, include_dirs)
+
     def check_func(self, func,
                    headers=None, include_dirs=None,
                    libraries=None, library_dirs=None,

Copied: trunk/numpy/distutils/command/scons.py (from rev 4772, branches/build_with_scons/numpy/distutils/command/scons.py)

Modified: trunk/numpy/distutils/core.py
===================================================================
--- trunk/numpy/distutils/core.py	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/distutils/core.py	2008-02-08 10:12:16 UTC (rev 4773)
@@ -21,9 +21,10 @@
 import distutils.dist
 
 from numpy.distutils.extension import Extension
+from numpy.distutils.numpy_distribution import NumpyDistribution
 from numpy.distutils.command import config, config_compiler, \
      build, build_py, build_ext, build_clib, build_src, build_scripts, \
-     sdist, install_data, install_headers, install, bdist_rpm
+     sdist, install_data, install_headers, install, bdist_rpm, scons
 from numpy.distutils.misc_util import get_data_files, is_sequence, is_string
 
 numpy_cmdclass = {'build':            build.build,
@@ -36,6 +37,7 @@
                   'build_py':         build_py.build_py,
                   'build_clib':       build_clib.build_clib,
                   'sdist':            sdist.sdist,
+                  'scons':            scons.scons,
                   'install_data':     install_data.install_data,
                   'install_headers':  install_headers.install_headers,
                   'install':          install.install,
@@ -95,9 +97,10 @@
     # class is local to a function in setuptools.command.easy_install
     if dist is not None and \
             'DistributionWithoutHelpCommands' in repr(dist):
+        raise NotImplementedError("setuptools not supported yet for numpy.scons branch")
         dist = None
     if always and dist is None:
-        dist = distutils.dist.Distribution()
+        dist = NumpyDistribution()
     return dist
 
 def _exit_interactive_session(_cache=[]):
@@ -175,6 +178,9 @@
        and 'headers' not in new_attr:
         new_attr['headers'] = []
 
+    # Use our custom NumpyDistribution class instead of distutils' one
+    new_attr['distclass'] = NumpyDistribution
+
     return old_setup(**new_attr)
 
 def _check_append_library(libraries, item):

Modified: trunk/numpy/distutils/misc_util.py
===================================================================
--- trunk/numpy/distutils/misc_util.py	2008-02-08 09:48:31 UTC (rev 4772)
+++ trunk/numpy/distutils/misc_util.py	2008-02-08 10:12:16 UTC (rev 4773)
@@ -112,11 +112,11 @@
     return minrelpath(joined)
 
 def get_mathlibs(path=None):
-    """Return the MATHLIB line from config.h
+    """Return the MATHLIB line from numpyconfig.h
     """
     if path is None:
         path = os.path.join(get_numpy_include_dirs()[0], 'numpy')
-    config_file = os.path.join(path,'config.h')
+    config_file = os.path.join(path,'numpyconfig.h')
     fid = open(config_file)
     mathlibs = []
     s = '#define MATHLIB'
@@ -574,7 +574,7 @@
 class Configuration(object):
 
     _list_keys = ['packages', 'ext_modules', 'data_files', 'include_dirs',
-                  'libraries', 'headers', 'scripts', 'py_modules']
+                  'libraries', 'headers', 'scripts', 'py_modules', 'scons_data']
     _dict_keys = ['package_dir']
     _extra_keys = ['name', 'version']
 
@@ -586,6 +586,7 @@
                  top_path=None,
                  package_path=None,
                  caller_level=1,
+                 setup_name='setup.py',
                  **attrs):
         """Construct configuration instance of a package.
 
@@ -674,6 +675,8 @@
             if caller_instance.options['delegate_options_to_subpackages']:
                 self.set_options(**caller_instance.options)
 
+        self.setup_name = setup_name
+
     def todict(self):
         """Return configuration distionary suitable for passing
         to distutils.core.setup() function.
@@ -795,7 +798,7 @@
         else:
             subpackage_path = njoin([subpackage_path] + l[:-1])
             subpackage_path = self.paths([subpackage_path])[0]
-        setup_py = njoin(subpackage_path, 'setup.py')
+        setup_py = njoin(subpackage_path, self.setup_name)
         if not self.options['ignore_setup_xxx_py']:
             if not os.path.isfile(setup_py):
                 setup_py = njoin(subpackage_path,
@@ -1165,6 +1168,55 @@
             self.warn('distutils distribution has been initialized,'\
                       ' it may be too late to add a library '+ name)
 
+    def add_sconscript(self, sconscript, subpackage_path=None,
+                       standalone = False, pre_hook = None,
+                       post_hook = None, source_files = None):
+        """Add a sconscript to configuration.
+
+        pre_hook and post hook should be sequences of callable, which will be
+        use before and after executing scons. """
+        if standalone:
+            parent_name = None
+        else:
+            parent_name = self.name
+
+        dist = self.get_distribution()
+        # Convert the sconscript name to a relative filename (relative from top
+        # setup.py's directory)
+        fullsconsname = self.paths(sconscript)[0]
+
+        # XXX: Think about a way to automatically register source files from
+        # scons...
+        full_source_files = []
+        if source_files:
+            full_source_files.extend([self.paths(i)[0] for i in source_files])
+
+        if dist is not None:
+            dist.scons_data.append((fullsconsname, 
+                                    pre_hook, 
+                                    post_hook,
+                                    full_source_files,
+                                    parent_name))
+            self.warn('distutils distribution has been initialized,'\
+                      ' it may be too late to add a subpackage '+ subpackage_name)
+            # XXX: we add a fake extension, to correctly initialize some
+            # options in distutils command.
+            dist.add_extension('', sources = [])
+        else:
+            self.scons_data.append((fullsconsname, 
+                                    pre_hook, 
+                                    post_hook,
+                                    full_source_files,
+                                    parent_name))
+            # XXX: we add a fake extension, to correctly initialize some
+            # options in distutils command.
+            self.add_extension('', sources = [])
+
+    def add_configres(self):
+        from numscons import get_scons_configres_dir, get_scons_configres_filename
+        file = os.path.join(get_scons_configres_dir(), self.local_path, 
+                            get_scons_configres_filename())
+
     def add_scripts(self,*files):
         """Add scripts to configuration.
         """
@@ -1394,6 +1446,12 @@
         """
         self.py_modules.append((self.name,name,generate_config_py))
 
+    def scons_make_config_py(self, name = '__config__'):
+        """Generate package __config__.py file containing system_info
+        information used during building the package.
+        """
+        self.py_modules.append((self.name, name, scons_generate_config_py))
+
     def get_info(self,*names):
         """Get resources information.
         """
@@ -1425,6 +1483,50 @@
     # else running numpy/core/setup.py
     return include_dirs
 
+def scons_generate_config_py(target):
+    """generate config.py file containing system_info information
+    used during building the package.
+
+    usage:
+        config['py_modules'].append((packagename, '__config__',generate_config_py))
+    """
+    from distutils.dir_util import mkpath
+    from numscons import get_scons_configres_dir, get_scons_configres_filename
+    d = {}
+    mkpath(os.path.dirname(target))
+    f = open(target, 'w')
+    f.write('# this file is generated by %s\n' % (os.path.abspath(sys.argv[0])))
+    f.write('# it contains system_info results at the time of building this package.\n')
+    f.write('__all__ = ["show"]\n\n')
+    confdir = get_scons_configres_dir()
+    confilename = get_scons_configres_filename()
+    for root, dirs, files in os.walk(confdir):
+        if files:
+            file = os.path.join(root, confilename)
+            assert root.startswith(confdir)
+            pkg_name = '.'.join(root[len(confdir)+1:].split(os.sep))
+            fid = open(file, 'r')
+            try:
+                cnt = fid.read()
+                d[pkg_name] = eval(cnt)
+            finally:
+                fid.close()
+    # d is a dictionary whose keys are package names, and values the
+    # corresponding configuration. Each configuration is itself a dictionary
+    # (lib : libinfo)
+    f.write('_config = %s\n' % d)
+    f.write(r'''
+def show():
+    for pkg, config in _config.items():
+        print "package %s configuration:" % pkg
+        for lib, libc in config.items():
+            print '    %s' % lib
+            for line in libc.split('\n'):
+                print '\t%s' % line
+    ''')
+    f.close()
+    return target
+
 #########################
 
 def default_config_dict(name = None, parent_name = None, local_path=None):

Copied: trunk/numpy/distutils/numpy_distribution.py (from rev 4772, branches/build_with_scons/numpy/distutils/numpy_distribution.py)

Copied: trunk/numpy/distutils/setupscons.py (from rev 4772, branches/build_with_scons/numpy/distutils/setupscons.py)

Copied: trunk/numpy/f2py/setupscons.py (from rev 4772, branches/build_with_scons/numpy/f2py/setupscons.py)

Copied: trunk/numpy/fft/SConstruct (from rev 4772, branches/build_with_scons/numpy/fft/SConstruct)

Copied: trunk/numpy/fft/setupscons.py (from rev 4772, branches/build_with_scons/numpy/fft/setupscons.py)

Copied: trunk/numpy/lib/SConstruct (from rev 4772, branches/build_with_scons/numpy/lib/SConstruct)

Copied: trunk/numpy/lib/setupscons.py (from rev 4772, branches/build_with_scons/numpy/lib/setupscons.py)

Copied: trunk/numpy/linalg/SConstruct (from rev 4772, branches/build_with_scons/numpy/linalg/SConstruct)

Copied: trunk/numpy/linalg/setupscons.py (from rev 4772, branches/build_with_scons/numpy/linalg/setupscons.py)

Copied: trunk/numpy/numarray/SConstruct (from rev 4772, branches/build_with_scons/numpy/numarray/SConstruct)

Copied: trunk/numpy/numarray/setupscons.py (from rev 4772, branches/build_with_scons/numpy/numarray/setupscons.py)

Copied: trunk/numpy/oldnumeric/setupscons.py (from rev 4772, branches/build_with_scons/numpy/oldnumeric/setupscons.py)

Copied: trunk/numpy/random/SConstruct (from rev 4772, branches/build_with_scons/numpy/random/SConstruct)

Copied: trunk/numpy/random/setupscons.py (from rev 4772, branches/build_with_scons/numpy/random/setupscons.py)

Copied: trunk/numpy/setupscons.py (from rev 4772, branches/build_with_scons/numpy/setupscons.py)

Copied: trunk/numpy/testing/setupscons.py (from rev 4772, branches/build_with_scons/numpy/testing/setupscons.py)

Copied: trunk/setupscons.py (from rev 4772, branches/build_with_scons/setupscons.py)

Copied: trunk/test.sh (from rev 4772, branches/build_with_scons/test.sh)



From numpy-svn at scipy.org  Fri Feb  8 05:18:00 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  8 Feb 2008 04:18:00 -0600 (CST)
Subject: [Numpy-svn] r4774 - branches
Message-ID: <20080208101800.4745639C3FE@new.scipy.org>

Author: jarrod.millman
Date: 2008-02-08 04:17:57 -0600 (Fri, 08 Feb 2008)
New Revision: 4774

Removed:
   branches/build_with_scons/
Log:
this has been merged with the trunk




From numpy-svn at scipy.org  Fri Feb  8 05:54:27 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  8 Feb 2008 04:54:27 -0600 (CST)
Subject: [Numpy-svn] r4775 - in trunk: benchmarks numpy numpy/core
	numpy/core/code_generators numpy/distutils
	numpy/distutils/command numpy/doc numpy/fft numpy/lib
	numpy/lib/tests numpy/linalg numpy/random
Message-ID: <20080208105427.6B00839C45B@new.scipy.org>

Author: jarrod.millman
Date: 2008-02-08 04:54:01 -0600 (Fri, 08 Feb 2008)
New Revision: 4775

Modified:
   trunk/benchmarks/simpleindex.py
   trunk/numpy/_import_tools.py
   trunk/numpy/add_newdocs.py
   trunk/numpy/core/code_generators/generate_ufunc_api.py
   trunk/numpy/core/defmatrix.py
   trunk/numpy/core/numeric.py
   trunk/numpy/core/records.py
   trunk/numpy/core/scons_support.py
   trunk/numpy/core/setup.py
   trunk/numpy/core/setupscons.py
   trunk/numpy/distutils/command/scons.py
   trunk/numpy/distutils/misc_util.py
   trunk/numpy/doc/example.py
   trunk/numpy/fft/setupscons.py
   trunk/numpy/lib/arraysetops.py
   trunk/numpy/lib/format.py
   trunk/numpy/lib/io.py
   trunk/numpy/lib/scimath.py
   trunk/numpy/lib/setupscons.py
   trunk/numpy/lib/tests/test_format.py
   trunk/numpy/lib/utils.py
   trunk/numpy/linalg/linalg.py
   trunk/numpy/linalg/setupscons.py
   trunk/numpy/random/setupscons.py
Log:
ran reindent


Modified: trunk/benchmarks/simpleindex.py
===================================================================
--- trunk/benchmarks/simpleindex.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/benchmarks/simpleindex.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -46,4 +46,3 @@
 print "Numarray: ", numarray_timer.repeat(3,100)
 print "Python: ", python_timer.repeat(3,100)
 print "Optimized: ", numpy_timer3.repeat(3,100)
-

Modified: trunk/numpy/_import_tools.py
===================================================================
--- trunk/numpy/_import_tools.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/_import_tools.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -152,10 +152,10 @@
 
        Parameters
        ----------
-        *packges : arg-tuple 
+        *packges : arg-tuple
              the names (one or more strings) of all the modules one
              wishes to load into the top-level namespace.
-        verbose= : integer 
+        verbose= : integer
              verbosity level [default: -1].
              verbose=-1 will suspend also warnings.
         force= : bool

Modified: trunk/numpy/add_newdocs.py
===================================================================
--- trunk/numpy/add_newdocs.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/add_newdocs.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -1,7 +1,7 @@
 # This is only meant to add docs to
 #  objects defined in C-extension modules.
 # The purpose is to allow easier editing of the
-#  docstrings without requiring a re-compile. 
+#  docstrings without requiring a re-compile.
 from lib import add_newdoc
 
 add_newdoc('numpy.core','dtype',
@@ -238,7 +238,7 @@
         open file object or string containing file name.
     dtype : data-type
         data type of the returned array
-    count : int 
+    count : int
         number of items to read (-1 mean 'all')
     sep : string
         separater between items if file is a text file (default "")
@@ -1107,8 +1107,8 @@
     is done if the array is not of float type and 'decimals' is >= 0.
 
     The keyword 'out' may be used to specify a different array to hold the
-    result rather than the default new array. If the type of the array 
-    specified by 'out' differs from that of 'a', the result is cast to the 
+    result rather than the default new array. If the type of the array
+    specified by 'out' differs from that of 'a', the result is cast to the
     new type, otherwise the original type is kept. Floats round to floats
     by default.
 
@@ -1209,7 +1209,7 @@
     |'heapsort' |   3   | O(n*log(n)) |     0      |   no  |
     |------------------------------------------------------|
 
-    All the sort algorithms make temporary copies of the data when the sort is 
+    All the sort algorithms make temporary copies of the data when the sort is
     not along the last axis. Consequently, sorts along the last axis are faster
     and use less space than sorts along other axis.
     """))

Modified: trunk/numpy/core/code_generators/generate_ufunc_api.py
===================================================================
--- trunk/numpy/core/code_generators/generate_ufunc_api.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/core/code_generators/generate_ufunc_api.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -71,7 +71,7 @@
 
 def generate_api(output_dir, force=False):
     basename = 'ufunc_api'
-    
+
     h_file = os.path.join(output_dir, '__%s.h' % basename)
     c_file = os.path.join(output_dir, '__%s.c' % basename)
     d_file = os.path.join(output_dir, '%s.txt' % basename)

Modified: trunk/numpy/core/defmatrix.py
===================================================================
--- trunk/numpy/core/defmatrix.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/core/defmatrix.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -51,16 +51,16 @@
 class matrix(N.ndarray):
     """mat = matrix(data, dtype=None, copy=True)
 
-    Returns a matrix from an array-like object, or a string of 
+    Returns a matrix from an array-like object, or a string of
     data.  A matrix is a specialized 2-d array that retains
     it's 2-d nature through operations and where '*' means matrix
-    multiplication and '**' means matrix power. 
+    multiplication and '**' means matrix power.
 
     Parameters
     ----------
     data : array-like or string
-       If data is a string, then interpret the string as a matrix 
-         with commas or spaces separating columns and semicolons 
+       If data is a string, then interpret the string as a matrix
+         with commas or spaces separating columns and semicolons
          separating rows.
        If data is array-like than convert the array to a matrix.
     dtype : data-type
@@ -273,7 +273,7 @@
         the flattened array by default, otherwise over the specified axis.
 
         Parameters
-        ----------        
+        ----------
         axis : integer
             Axis along which the means are computed. The default is
             to compute the standard deviation of the flattened array.
@@ -289,7 +289,7 @@
             cast if necessary.
 
         Returns
-        -------        
+        -------
         mean : The return type varies, see above.
             A new array holding the result is returned unless out is
             specified, in which case a reference to out is returned.
@@ -342,7 +342,7 @@
         mean : average
 
         Notes
-        ----- 
+        -----
         The standard deviation is the square root of the
         average of the squared deviations from the mean, i.e. var =
         sqrt(mean((x - x.mean())**2)).  The computed standard
@@ -362,7 +362,7 @@
         ----------
         axis : integer
             Axis along which the variance is computed. The default is to
-            compute the variance of the flattened array.            
+            compute the variance of the flattened array.
         dtype : data-type
             Type to use in computing the variance. For arrays of integer
             type the default is float32, for arrays of float types it is

Modified: trunk/numpy/core/numeric.py
===================================================================
--- trunk/numpy/core/numeric.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/core/numeric.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -149,7 +149,7 @@
 
 def require(a, dtype=None, requirements=None):
     """Return an ndarray of the provided type that satisfies requirements.
-    
+
     This function is useful to be sure that an array with the correct flags
     is returned for passing to compiled code (perhaps through ctypes).
 
@@ -160,7 +160,7 @@
      dtype : data-type
        The required data-type (None is the default data-type -- float64)
      requirements : list of strings
-       The requirements list can be any of the 
+       The requirements list can be any of the
        'ENSUREARRAY' ('E')  - ensure that  a base-class ndarray
        'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
        'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
@@ -169,7 +169,7 @@
        'OWNDATA' ('O')      - ensure an array that owns its own data
 
        The returned array will be guaranteed to have the listed requirements
-       by making a copy if needed. 
+       by making a copy if needed.
     """
     if requirements is None:
         requirements = []
@@ -276,7 +276,7 @@
 try:
     # importing this changes the dot function for basic 4 types
     # to blas-optimized versions.
-    from _dotblas import dot, vdot, inner, alterdot, restoredot    
+    from _dotblas import dot, vdot, inner, alterdot, restoredot
 except ImportError:
     def alterdot():
         "Does Nothing"

Modified: trunk/numpy/core/records.py
===================================================================
--- trunk/numpy/core/records.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/core/records.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -45,9 +45,9 @@
 class format_parser:
     """Class to convert formats, names, titles description to a dtype
 
-    After constructing the format_parser object, the dtype attribute is 
+    After constructing the format_parser object, the dtype attribute is
       the converted data-type.
-    
+
     dtype = format_parser(formats, names, titles).dtype
 
     Parameters
@@ -59,18 +59,18 @@
         comma-separated field names --- 'col1, col2, col3'
         list or tuple of field names
     titles : sequence
-        sequence of title strings or unicode        
+        sequence of title strings or unicode
     aligned : bool
         align the fields by padding as the C-compiler would
-    byteorder : 
-        If specified, all the fields will be changed to the 
+    byteorder :
+        If specified, all the fields will be changed to the
         provided byteorder.  Otherwise, the default byteorder is
         used.
 
     Returns
     -------
     object
-        A Python object whose dtype attribute is a data-type. 
+        A Python object whose dtype attribute is a data-type.
     """
     def __init__(self, formats, names, titles, aligned=False, byteorder=None):
         self._parseFormats(formats, aligned)
@@ -227,9 +227,9 @@
         by the *formats*, *names*, *titles*, *aligned*, and *byteorder* keywords.
     buf : [buffer] or None
         If this is None, then a new array is created of the given shape and data-type
-        If this is an object exposing the buffer interface, then the array will 
-        use the memory from an existing buffer.  In this case, the *offset* and 
-        *strides* keywords can also be used. 
+        If this is an object exposing the buffer interface, then the array will
+        use the memory from an existing buffer.  In this case, the *offset* and
+        *strides* keywords can also be used.
 
     See Also
     --------

Modified: trunk/numpy/core/scons_support.py
===================================================================
--- trunk/numpy/core/scons_support.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/core/scons_support.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -30,12 +30,12 @@
 # Ufunc and multiarray API generators
 #------------------------------------
 def do_generate_array_api(target, source, env):
-    nowrap_do_generate_array_api([str(i) for i in target], 
+    nowrap_do_generate_array_api([str(i) for i in target],
                                  [str(i) for i in source])
     return 0
 
 def do_generate_ufunc_api(target, source, env):
-    nowrap_do_generate_ufunc_api([str(i) for i in target], 
+    nowrap_do_generate_ufunc_api([str(i) for i in target],
                                  [str(i) for i in source])
     return 0
 
@@ -74,7 +74,7 @@
     base, ext = split_ext(pbasename(str(source[0])))
     t = pjoin(pdirname(str(target[0])), base)
     return ([t], source)
-    
+
 #----------------
 # umath generator
 #----------------
@@ -92,7 +92,7 @@
 def generate_umath_emitter(target, source, env):
     t = str(target[0]) + '.c'
     return ([t], source)
-    
+
 #-----------------------------------------
 # Other functions related to configuration
 #-----------------------------------------

Modified: trunk/numpy/core/setup.py
===================================================================
--- trunk/numpy/core/setup.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/core/setup.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -175,7 +175,7 @@
                       " python-dev|python-devel." % (python_h)
 
             config.numpy_include_dirs
-            result = config_cmd.try_run(testcode, 
+            result = config_cmd.try_run(testcode,
                                 include_dirs = [python_include] + \
                                                        config.numpy_include_dirs,
                                         library_dirs = default_lib_dirs)
@@ -190,7 +190,7 @@
             target_f.close()
             print 'EOF'
         return target
-                                
+
     def generate_api_func(module_name):
         def generate_api(ext, build_dir):
             script = join(codegen_dir, module_name + '.py')
@@ -405,9 +405,9 @@
 #include "config.h"
 
 int main()
-{   
+{
     FILE* f;
-   
+
     f = fopen("%s", "w");
     if (f == NULL) {
         return -1;

Modified: trunk/numpy/core/setupscons.py
===================================================================
--- trunk/numpy/core/setupscons.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/core/setupscons.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -25,10 +25,10 @@
                       join('code_generators', 'multiarray_api_order.txt'),
                       join('code_generators', 'ufunc_api_order.txt')]
     core_src = [join('src', basename(i)) for i in glob.glob(join(local_dir,
-                                                                'src', 
+                                                                'src',
                                                                 '*.c'))]
     core_src += [join('src', basename(i)) for i in glob.glob(join(local_dir,
-                                                                 'src', 
+                                                                 'src',
                                                                  '*.src'))]
 
     source_files = dot_blas_src + api_definition + core_src + \
@@ -54,7 +54,7 @@
         incl_dir = os.path.dirname(target)
         if incl_dir not in config.numpy_include_dirs:
             config.numpy_include_dirs.append(incl_dir)
-        config.add_data_files((header_dir, target)) 
+        config.add_data_files((header_dir, target))
 
     def add_array_api():
         scons_build_dir = get_scons_build_dir()
@@ -83,7 +83,7 @@
         add_ufunc_api()
         config.add_configres()
 
-    config.add_sconscript('SConstruct', 
+    config.add_sconscript('SConstruct',
                           post_hook = add_generated_files,
                           source_files = source_files)
 

Modified: trunk/numpy/distutils/command/scons.py
===================================================================
--- trunk/numpy/distutils/command/scons.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/distutils/command/scons.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -14,21 +14,21 @@
 
 def get_scons_build_dir():
     """Return the top path where everything produced by scons will be put.
-    
+
     The path is relative to the top setup.py"""
     from numscons import get_scons_build_dir
     return get_scons_build_dir()
 
 def get_scons_configres_dir():
     """Return the top path where everything produced by scons will be put.
-    
+
     The path is relative to the top setup.py"""
     from numscons import get_scons_configres_dir
     return get_scons_configres_dir()
 
 def get_scons_configres_filename():
     """Return the top path where everything produced by scons will be put.
-    
+
     The path is relative to the top setup.py"""
     from numscons import get_scons_configres_filename
     return get_scons_configres_filename()
@@ -101,7 +101,7 @@
 def get_compiler_executable(compiler):
     """For any give CCompiler instance, this gives us the name of C compiler
     (the actual executable).
-    
+
     NOTE: does NOT work with FCompiler instances."""
     # Geez, why does distutils has no common way to get the compiler name...
     if compiler.compiler_type == 'msvc':
@@ -112,7 +112,7 @@
         # hardcoded string
         #compiler.initialize()
         #print compiler.cc
-        return 'cl.exe' 
+        return 'cl.exe'
     else:
         return compiler.compiler[0]
 
@@ -124,7 +124,7 @@
 def get_cxxcompiler_executable(compiler):
     """For any give CCompiler instance, this gives us the name of CXX compiler
     (the actual executable).
-    
+
     NOTE: does NOT work with FCompiler instances."""
     # Geez, why does distutils has no common way to get the compiler name...
     if compiler.compiler_type == 'msvc':
@@ -135,7 +135,7 @@
         # hardcoded string
         #compiler.initialize()
         #print compiler.cc
-        return 'cl.exe' 
+        return 'cl.exe'
     else:
         return compiler.compiler_cxx[0]
 
@@ -181,7 +181,7 @@
     # XXX: add an option to the scons command for configuration (auto/force/cache).
     description = "Scons builder"
     user_options = old_build_ext.user_options + \
-            [('jobs=', None, 
+            [('jobs=', None,
               "specify number of worker threads when executing scons"),
              ('scons-tool-path=', None, 'specify additional path '\
                                     '(absolute) to look for scons tools'),
@@ -239,11 +239,11 @@
             self.scons_compiler = dist2sconscc(distutils_compiler)
             self.scons_compiler_path = protect_path(get_tool_path(distutils_compiler))
         except DistutilsPlatformError, e:
-            if not self._bypass_distutils_cc: 
+            if not self._bypass_distutils_cc:
                 raise e
             else:
                 self.scons_compiler = compiler_type
- 		
+
         # We do the same for the fortran compiler ...
         fcompiler_type = self.fcompiler
         from numpy.distutils.fcompiler import new_fcompiler

Modified: trunk/numpy/distutils/misc_util.py
===================================================================
--- trunk/numpy/distutils/misc_util.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/distutils/misc_util.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -1192,8 +1192,8 @@
             full_source_files.extend([self.paths(i)[0] for i in source_files])
 
         if dist is not None:
-            dist.scons_data.append((fullsconsname, 
-                                    pre_hook, 
+            dist.scons_data.append((fullsconsname,
+                                    pre_hook,
                                     post_hook,
                                     full_source_files,
                                     parent_name))
@@ -1203,8 +1203,8 @@
             # options in distutils command.
             dist.add_extension('', sources = [])
         else:
-            self.scons_data.append((fullsconsname, 
-                                    pre_hook, 
+            self.scons_data.append((fullsconsname,
+                                    pre_hook,
                                     post_hook,
                                     full_source_files,
                                     parent_name))
@@ -1214,7 +1214,7 @@
 
     def add_configres(self):
         from numscons import get_scons_configres_dir, get_scons_configres_filename
-        file = os.path.join(get_scons_configres_dir(), self.local_path, 
+        file = os.path.join(get_scons_configres_dir(), self.local_path,
                             get_scons_configres_filename())
 
     def add_scripts(self,*files):

Modified: trunk/numpy/doc/example.py
===================================================================
--- trunk/numpy/doc/example.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/doc/example.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -53,7 +53,7 @@
         Explanation
 
     See Also
-    --------    
+    --------
     otherfunc : relationship (optional)
     newfunc : relationship (optional)
 

Modified: trunk/numpy/fft/setupscons.py
===================================================================
--- trunk/numpy/fft/setupscons.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/fft/setupscons.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -4,7 +4,7 @@
 
     config.add_data_dir('tests')
 
-    config.add_sconscript('SConstruct', 
+    config.add_sconscript('SConstruct',
                           source_files = ['fftpack_litemodule.c', 'fftpack.c',
                                           'fftpack.h'])
 

Modified: trunk/numpy/lib/arraysetops.py
===================================================================
--- trunk/numpy/lib/arraysetops.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/lib/arraysetops.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -207,7 +207,7 @@
     b1 = nm.zeros( ar1.shape, dtype = nm.int8 )
     b2 = nm.ones( ar2.shape, dtype = nm.int8 )
     tt = nm.concatenate( (b1, b2) )
-        
+
     # 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.

Modified: trunk/numpy/lib/format.py
===================================================================
--- trunk/numpy/lib/format.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/lib/format.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -227,7 +227,7 @@
         raise ValueError("Header does not contain the correct keys: %r" % (keys,))
 
     # Sanity-check the values.
-    if (not isinstance(d['shape'], tuple) or 
+    if (not isinstance(d['shape'], tuple) or
         not numpy.all([isinstance(x, int) for x in d['shape']])):
         raise ValueError("shape is not valid: %r" % (d['shape'],))
     if not isinstance(d['fortran_order'], bool):
@@ -407,6 +407,3 @@
         mode=mode, offset=offset)
 
     return marray
-
-
-

Modified: trunk/numpy/lib/io.py
===================================================================
--- trunk/numpy/lib/io.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/lib/io.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -19,8 +19,8 @@
 _file = file
 
 class BagObj(object):
-    """A simple class that converts attribute lookups to 
-    getitems on the class passed in. 
+    """A simple class that converts attribute lookups to
+    getitems on the class passed in.
     """
     def __init__(self, obj):
         self._obj = obj
@@ -31,8 +31,8 @@
             raise AttributeError, key
 
 class NpzFile(object):
-    """A dictionary-like object with lazy-loading of files in the zipped 
-    archive provided on construction. 
+    """A dictionary-like object with lazy-loading of files in the zipped
+    archive provided on construction.
 
     The arrays and file strings are lazily loaded on either
     getitem access using obj['key'] or attribute lookup using obj.f.key
@@ -54,13 +54,13 @@
 
     def __getitem__(self, key):
         # FIXME: This seems like it will copy strings around
-        #   more than is strictly necessary.  The zipfile 
+        #   more than is strictly necessary.  The zipfile
         #   will read the string and then
         #   the format.read_array will copy the string
-        #   to another place in memory. 
-        #   It would be better if the zipfile could read 
+        #   to another place in memory.
+        #   It would be better if the zipfile could read
         #   (or at least uncompress) the data
-        #   directly into the array memory. 
+        #   directly into the array memory.
         member = 0
         if key in self._files:
             member = 1
@@ -90,21 +90,21 @@
     memmap : bool
         If true, then memory-map the .npy file or unzip the .npz file into
            a temporary directory and memory-map each component
-        This has no effect for a pickle. 
+        This has no effect for a pickle.
 
     Returns
     -------
     result : array, tuple, dict, etc.
-        data stored in the file. 
+        data stored in the file.
         If file contains pickle data, then whatever is stored in the pickle is
           returned.
-        If the file is .npy file, then an array is returned.  
-        If the file is .npz file, then a dictionary-like object is returned 
+        If the file is .npy file, then an array is returned.
+        If the file is .npz file, then a dictionary-like object is returned
           which has a filename:array key:value pair for every file in the zip.
 
     Raises
     ------
-    IOError 
+    IOError
     """
     if isinstance(file, type("")):
         fid = _file(file,"rb")
@@ -124,7 +124,7 @@
     elif magic == format.MAGIC_PREFIX: # .npy file
         return format.read_array(fid)
     else:  # Try a pickle
-        try: 
+        try:
             return _cload(fid)
         except:
             raise IOError, \
@@ -133,8 +133,8 @@
 def save(file, arr):
     """Save an array to a binary file (a string or file-like object).
 
-    If the file is a string, then if it does not have the .npy extension, 
-        it is appended and a file open. 
+    If the file is a string, then if it does not have the .npy extension,
+        it is appended and a file open.
 
     Data is saved to the open file in NumPy-array format
 
@@ -144,7 +144,7 @@
     ...
     np.save('myfile', a)
     a = np.load('myfile.npy')
-    """    
+    """
     if isinstance(file, str):
         if not file.endswith('.npy'):
             file = file + '.npy'
@@ -158,15 +158,15 @@
 def savez(file, *args, **kwds):
     """Save several arrays into an .npz file format which is a zipped-archive
     of arrays
-    
-    If keyword arguments are given, then filenames are taken from the keywords. 
-    If arguments are passed in with no keywords, then stored file names are 
-    arr_0, arr_1, etc.  
+
+    If keyword arguments are given, then filenames are taken from the keywords.
+    If arguments are passed in with no keywords, then stored file names are
+    arr_0, arr_1, etc.
     """
 
     if isinstance(file, str):
         if not file.endswith('.npz'):
-            file = file + '.npz'        
+            file = file + '.npz'
 
     namedict = kwds
     for i, val in enumerate(args):
@@ -190,7 +190,7 @@
         format.write_array(fid, np.asanyarray(val))
         fid.close()
         zip.write(filename, arcname=fname)
-        
+
     zip.close()
     for name in todel:
         os.remove(name)
@@ -359,7 +359,3 @@
 
     if origShape is not None:
         X.shape = origShape
-
-
-
-

Modified: trunk/numpy/lib/scimath.py
===================================================================
--- trunk/numpy/lib/scimath.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/lib/scimath.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -93,7 +93,7 @@
     """Convert `x` to complex if it has real, negative components.
 
     Otherwise, output is just the array version of the input (via asarray).
-    
+
     Parameters
     ----------
     x : array_like
@@ -119,7 +119,7 @@
     """Convert `x` to double if it has real, negative components.
 
     Otherwise, output is just the array version of the input (via asarray).
-    
+
     Parameters
     ----------
     x : array_like
@@ -145,7 +145,7 @@
     """Convert `x` to complex if it has real components x_i with abs(x_i)>1.
 
     Otherwise, output is just the array version of the input (via asarray).
-    
+
     Parameters
     ----------
     x : array_like
@@ -203,7 +203,7 @@
 
     If x contains negative inputs, the answer is computed and returned in the
     complex domain.
-    
+
     Parameters
     ----------
     x : array_like
@@ -221,7 +221,7 @@
 
     Negative arguments are correctly handled (recall that for negative
     arguments, the identity exp(log(z))==z does not hold anymore):
-    
+
     >>> log(-math.exp(1)) == (1+1j*math.pi)
     True
     """
@@ -233,7 +233,7 @@
 
     If x contains negative inputs, the answer is computed and returned in the
     complex domain.
-    
+
     Parameters
     ----------
     x : array_like
@@ -263,7 +263,7 @@
 
     If x contains negative inputs, the answer is computed and returned in the
     complex domain.
-    
+
     Parameters
     ----------
     x : array_like
@@ -293,7 +293,7 @@
 
     If x contains negative inputs, the answer is computed and returned in the
     complex domain.
-    
+
     Parameters
     ----------
     x : array_like
@@ -307,7 +307,7 @@
 
     (We set the printing precision so the example can be auto-tested)
     >>> import numpy as np; np.set_printoptions(precision=4)
-    
+
     >>> log2([4,8])
     array([ 2.,  3.])
 
@@ -323,7 +323,7 @@
     If x contains negative values, it is converted to the complex domain.
 
     If p contains negative values, it is converted to floating point.
-    
+
     Parameters
     ----------
     x : array_like
@@ -332,7 +332,7 @@
     Returns
     -------
     array_like
-    
+
     Examples
     --------
     (We set the printing precision so the example can be auto-tested)
@@ -357,7 +357,7 @@
     For real x with abs(x)<=1, this returns the principal value.
 
     If abs(x)>1, the complex arccos() is computed.
-    
+
     Parameters
     ----------
     x : array_like
@@ -385,7 +385,7 @@
     For real x with abs(x)<=1, this returns the principal value.
 
     If abs(x)>1, the complex arcsin() is computed.
-    
+
     Parameters
     ----------
     x : array_like
@@ -414,7 +414,7 @@
     For real x with abs(x)<=1, this returns the principal value.
 
     If abs(x)>1, the complex arctanh() is computed.
-    
+
     Parameters
     ----------
     x : array_like

Modified: trunk/numpy/lib/setupscons.py
===================================================================
--- trunk/numpy/lib/setupscons.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/lib/setupscons.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -5,7 +5,7 @@
 
     config = Configuration('lib',parent_package,top_path)
 
-    config.add_sconscript('SConstruct', 
+    config.add_sconscript('SConstruct',
                           source_files = [join('src', '_compiled_base.c')])
     config.add_data_dir('tests')
 

Modified: trunk/numpy/lib/tests/test_format.py
===================================================================
--- trunk/numpy/lib/tests/test_format.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/lib/tests/test_format.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -21,9 +21,9 @@
     ...     np.complex128,
     ...     object,
     ... ]
-    >>> 
+    >>>
     >>> basic_arrays = []
-    >>> 
+    >>>
     >>> for scalar in scalars:
     ...     for endian in '<>':
     ...         dtype = np.dtype(scalar).newbyteorder(endian)
@@ -36,20 +36,20 @@
     ...             basic.reshape((3,5)).T,
     ...             basic.reshape((3,5))[::-1,::2],
     ...         ])
-    ... 
-    >>> 
+    ...
+    >>>
     >>> Pdescr = [
     ...     ('x', 'i4', (2,)),
     ...     ('y', 'f8', (2, 2)),
     ...     ('z', 'u1')]
-    >>> 
-    >>> 
+    >>>
+    >>>
     >>> PbufferT = [
     ...     ([3,2], [[6.,4.],[6.,4.]], 8),
     ...     ([4,3], [[7.,5.],[7.,5.]], 9),
     ...     ]
-    >>> 
-    >>> 
+    >>>
+    >>>
     >>> Ndescr = [
     ...     ('x', 'i4', (2,)),
     ...     ('Info', [
@@ -68,14 +68,14 @@
     ...         ('Value', 'c16')]),
     ...     ('y', 'f8', (2, 2)),
     ...     ('z', 'u1')]
-    >>> 
-    >>> 
+    >>>
+    >>>
     >>> NbufferT = [
     ...     ([3,2], (6j, 6., ('nn', [6j,4j], [6.,4.], [1,2]), 'NN', True), 'cc', ('NN', 6j), [[6.,4.],[6.,4.]], 8),
     ...     ([4,3], (7j, 7., ('oo', [7j,5j], [7.,5.], [2,1]), 'OO', False), 'dd', ('OO', 7j), [[7.,5.],[7.,5.]], 9),
     ...     ]
-    >>> 
-    >>> 
+    >>>
+    >>>
     >>> record_arrays = [
     ...     np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('<')),
     ...     np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('<')),
@@ -111,7 +111,7 @@
     ...     f = StringIO()
     ...     format.write_array_header_1_0(f, arr)
     ...     print repr(f.getvalue())
-    ... 
+    ...
     "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (0,)}              \n"
     "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': ()}                \n"
     "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (15,)}             \n"
@@ -506,5 +506,3 @@
     for magic in bad_version_magic + malformed_magic:
         f = StringIO(magic)
         yield raises(ValueError)(format.read_array), f
-
-

Modified: trunk/numpy/lib/utils.py
===================================================================
--- trunk/numpy/lib/utils.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/lib/utils.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -106,7 +106,7 @@
     else:
         str1 = "%s is deprecated, use %s" % (oldname, newname),
         depdoc = '%s is DEPRECATED!! -- use %s instead' % (oldname, newname,)
-        
+
     def newfunc(*args,**kwds):
         warnings.warn(str1, DeprecationWarning)
         return func(*args, **kwds)
@@ -487,28 +487,28 @@
 #   * raise SyntaxError instead of a custom exception.
 
 class SafeEval(object):
-    
+
     def visit(self, node, **kw):
         cls = node.__class__
         meth = getattr(self,'visit'+cls.__name__,self.default)
         return meth(node, **kw)
-            
+
     def default(self, node, **kw):
         raise SyntaxError("Unsupported source construct: %s" % node.__class__)
-            
+
     def visitExpression(self, node, **kw):
         for child in node.getChildNodes():
             return self.visit(child, **kw)
-    
+
     def visitConst(self, node, **kw):
         return node.value
 
     def visitDict(self, node,**kw):
         return dict([(self.visit(k),self.visit(v)) for k,v in node.items])
-        
+
     def visitTuple(self, node, **kw):
         return tuple([self.visit(i) for i in node.nodes])
-        
+
     def visitList(self, node, **kw):
         return [self.visit(i) for i in node.nodes]
 
@@ -578,5 +578,3 @@
         raise
 
 #-----------------------------------------------------------------------------
-
-

Modified: trunk/numpy/linalg/linalg.py
===================================================================
--- trunk/numpy/linalg/linalg.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/linalg/linalg.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -138,11 +138,11 @@
 
 def tensorsolve(a, b, axes=None):
     """Solve the tensor equation a x = b for x
-    
+
     It is assumed that all indices of x are summed over in the product,
     together with the rightmost indices of a, similarly as in
     tensordot(a, x, axes=len(b.shape)).
-    
+
     Parameters
     ----------
     a : array, shape b.shape+Q
@@ -153,11 +153,11 @@
     axes : tuple of integers
         Axes in a to reorder to the right, before inversion.
         If None (default), no reordering is done.
-    
+
     Returns
     -------
     x : array, shape Q
-    
+
     Examples
     --------
     >>> from numpy import *
@@ -169,7 +169,7 @@
     (2, 3, 4)
     >>> allclose(tensordot(a, x, axes=3), b)
     True
-    
+
     """
     a = asarray(a)
     b = asarray(b)
@@ -206,7 +206,7 @@
     x : array, shape (M,)
 
     Raises LinAlgError if a is singular or not square
-    
+
     """
     one_eq = len(b.shape) == 1
     if one_eq:
@@ -239,10 +239,10 @@
 
     The result is an inverse corresponding to the operation
     tensordot(a, b, ind), ie.,
-    
+
         x == tensordot(tensordot(tensorinv(a), a, ind), x, ind)
           == tensordot(tensordot(a, tensorinv(a), ind), x, ind)
-    
+
     for all x (up to floating-point accuracy).
 
     Parameters
@@ -298,12 +298,12 @@
 
 def inv(a):
     """Compute the inverse of a matrix.
-    
+
     Parameters
     ----------
     a : array-like, shape (M, M)
         Matrix to be inverted
-    
+
     Returns
     -------
     ainv : array-like, shape (M, M)
@@ -330,20 +330,20 @@
 
 def cholesky(a):
     """Compute the Cholesky decomposition of a matrix.
-    
+
     Returns the Cholesky decomposition, :lm:`A = L L^*` of a Hermitian
     positive-definite matrix :lm:`A`.
-    
+
     Parameters
     ----------
     a : array, shape (M, M)
         Matrix to be decomposed
-    
+
     Returns
     -------
     L : array, shape (M, M)
         Lower-triangular Cholesky factor of A
-    
+
     Raises LinAlgError if decomposition fails
 
     Examples
@@ -357,7 +357,7 @@
     >>> dot(L, L.T.conj())
     array([[ 1.+0.j,  0.-2.j],
            [ 0.+2.j,  5.+0.j]])
-    
+
     """
     _assertRank2(a)
     _assertSquareness(a)
@@ -400,7 +400,7 @@
     Q : double or complex array, shape (M, K)
     R : double or complex array, shape (K, N)
         Size K = min(M, N)
-    
+
     mode = 'r'
     R : double or complex array, shape (K, N)
 
@@ -429,7 +429,7 @@
     True
     >>> allclose(r, triu(r3[:6,:6], k=0))
     True
-    
+
     """
     _assertRank2(a)
     m, n = a.shape
@@ -507,7 +507,7 @@
 
 def eigvals(a):
     """Compute the eigenvalues of a general matrix.
-    
+
     Parameters
     ----------
     a : array, shape (M, M)
@@ -520,7 +520,7 @@
         The eigenvalues, each repeated according to its multiplicity.
         They are not necessarily ordered, nor are they necessarily
         real for real matrices.
-    
+
     Raises LinAlgError if eigenvalue computation does not converge
 
     See Also
@@ -534,7 +534,7 @@
     This is a simple interface to the LAPACK routines dgeev and zgeev
     that sets the flags to return only the eigenvalues of general real
     and complex arrays respectively.
-    
+
     The number w is an eigenvalue of a if there exists a vector v
     satisfying the equation dot(a,v) = w*v. Alternately, if w is a root of
     the characteristic equation det(a - w[i]*I) = 0, where det is the
@@ -586,7 +586,7 @@
 
 def eigvalsh(a, UPLO='L'):
     """Compute the eigenvalues of a Hermitean or real symmetric matrix.
-    
+
     Parameters
     ----------
     a : array, shape (M, M)
@@ -596,7 +596,7 @@
         Specifies whether the pertinent array data is taken from the upper
         or lower triangular part of a. Possible values are 'L', and 'U' for
         upper and lower respectively. Default is 'L'.
-    
+
     Returns
     -------
     w : double array, shape (M,)
@@ -616,7 +616,7 @@
     This is a simple interface to the LAPACK routines dsyevd and
     zheevd that sets the flags to return only the eigenvalues of real
     symmetric and complex Hermetian arrays respectively.
-    
+
     The number w is an eigenvalue of a if there exists a vector v
     satisfying the equation dot(a,v) = w*v. Alternately, if w is a root of
     the characteristic equation det(a - w[i]*I) = 0, where det is the
@@ -714,10 +714,10 @@
     that fact. If the eigenvalues are all different, then theoretically the
     eigenvectors are independent. Likewise, the matrix of eigenvectors is
     unitary if the matrix a is normal, i.e., if dot(a, a.H) = dot(a.H, a).
-    
+
     The left and right eigenvectors are not necessarily the (Hermitian)
     transposes of each other.
-    
+
     """
     a, wrap = _makearray(a)
     _assertRank2(a)
@@ -775,7 +775,7 @@
 
 def eigh(a, UPLO='L'):
     """Compute eigenvalues for a Hermitian or real symmetric matrix.
-    
+
     Parameters
     ----------
     a : array, shape (M, M)
@@ -785,7 +785,7 @@
         Specifies whether the pertinent array date is taken from the upper
         or lower triangular part of a. Possible values are 'L', and 'U'.
         Default is 'L'.
-    
+
     Returns
     -------
     w : double array, shape (M,)
@@ -793,7 +793,7 @@
     v : double or complex double array, shape (M, M)
         The normalized eigenvector corresponding to the eigenvalue w[i] is
         the column v[:,i].
-    
+
     Raises LinAlgError if eigenvalue computation does not converge
 
     See Also
@@ -801,13 +801,13 @@
     eigvalsh : eigenvalues of symmetric or Hemitiean arrays.
     eig : eigenvalues and right eigenvectors for non-symmetric arrays
     eigvals : eigenvalues of non-symmetric array.
-    
+
     Notes
     -----
     A simple interface to the LAPACK routines dsyevd and zheevd that compute
     the eigenvalues and eigenvectors of real symmetric and complex Hermitian
     arrays respectively.
-    
+
     The number w is an eigenvalue of a if there exists a vector v
     satisfying the equation dot(a,v) = w*v. Alternately, if w is a root of
     the characteristic equation det(a - w[i]*I) = 0, where det is the
@@ -866,7 +866,7 @@
     an 1d-array s of singular values (real, non-negative) such that
     a == U S Vh  if S is an suitably shaped matrix of zeros whose
     main diagonal is s.
-    
+
     Parameters
     ----------
     a : array, shape (M, N)
@@ -876,7 +876,7 @@
         If false, the shapes are    (M,K), (K,N) where K = min(M,N)
     compute_uv : boolean
         Whether to compute also U, Vh in addition to s
-    
+
     Returns
     -------
     U:  array, shape (M,M) or (M,K) depending on full_matrices
@@ -884,7 +884,7 @@
         The singular values, sorted so that s[i] >= s[i+1]
         K = min(M, N)
     Vh: array, shape (N,N) or (K,N) depending on full_matrices
-    
+
     For compute_uv = False, only s is returned.
 
     Raises LinAlgError if SVD computation does not converge
@@ -895,14 +895,14 @@
     >>> U, s, Vh = linalg.svd(a)
     >>> U.shape, Vh.shape, s.shape
     ((9, 9), (6, 6), (6,))
-    
+
     >>> U, s, Vh = linalg.svd(a, full_matrices=False)
     >>> U.shape, Vh.shape, s.shape
     ((9, 6), (6, 6), (6,))
     >>> S = diag(s)
     >>> allclose(a, dot(U, dot(S, Vh)))
     True
-    
+
     >>> s2 = linalg.svd(a, compute_uv=False)
     >>> allclose(s, s2)
     True
@@ -969,11 +969,11 @@
 
 def pinv(a, rcond=1e-15 ):
     """Compute the (Moore-Penrose) pseudo-inverse of a matrix.
-    
+
     Calculate a generalized inverse of a matrix using its
     singular-value decomposition and including all 'large' singular
     values.
-    
+
     Parameters
     ----------
     a : array, shape (M, N)
@@ -982,11 +982,11 @@
         Cutoff for 'small' singular values.
         Singular values smaller than rcond*largest_singular_value are
         considered zero.
-    
+
     Returns
     -------
     B : array, shape (N, M)
-    
+
     Raises LinAlgError if SVD computation does not converge
 
     Examples
@@ -998,7 +998,7 @@
     True
     >>> allclose(B, dot(B, dot(a, B)))
     True
-    
+
     """
     a, wrap = _makearray(a)
     _assertNonEmpty(a)
@@ -1028,7 +1028,7 @@
     -------
     det : float or complex
         Determinant of a
-    
+
     Notes
     -----
     The determinant is computed via LU factorization, LAPACK routine z/dgetrf.
@@ -1057,9 +1057,9 @@
 
 def lstsq(a, b, rcond=-1):
     """Compute least-squares solution to equation :m:`a x = b`
-    
+
     Compute a vector x such that the 2-norm :m:`|b - a x|` is minimised.
-    
+
     Parameters
     ----------
     a : array, shape (M, N)
@@ -1068,9 +1068,9 @@
         Cutoff for 'small' singular values.
         Singular values smaller than rcond*largest_singular_value are
         considered zero.
-    
+
     Raises LinAlgError if computation does not converge
-    
+
     Returns
     -------
     x : array, shape (N,) or (N, K) depending on shape of b
@@ -1169,7 +1169,7 @@
         -2     smallest singular value       as below
         other  -                             sum(abs(x)**ord)**(1./ord)
         =====  ============================  ==========================
-    
+
     Returns
     -------
     n : float
@@ -1180,7 +1180,7 @@
     For values ord < 0, the result is, strictly speaking, not a
     mathematical 'norm', but it may still be useful for numerical
     purposes.
-    
+
     """
     x = asarray(x)
     nd = len(x.shape)

Modified: trunk/numpy/linalg/setupscons.py
===================================================================
--- trunk/numpy/linalg/setupscons.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/linalg/setupscons.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -6,7 +6,7 @@
 
     config.add_data_dir('tests')
 
-    config.add_sconscript('SConstruct', 
+    config.add_sconscript('SConstruct',
                           source_files = ['lapack_litemodule.c',
                                           'zlapack_lite.c', 'dlapack_lite.c',
                                           'blas_lite.c', 'dlamch.c',

Modified: trunk/numpy/random/setupscons.py
===================================================================
--- trunk/numpy/random/setupscons.py	2008-02-08 10:17:57 UTC (rev 4774)
+++ trunk/numpy/random/setupscons.py	2008-02-08 10:54:01 UTC (rev 4775)
@@ -5,12 +5,12 @@
     from numpy.distutils.misc_util import Configuration, get_mathlibs
     config = Configuration('random',parent_package,top_path)
 
-    source_files = [join('mtrand', i) for i in ['mtrand.c', 
+    source_files = [join('mtrand', i) for i in ['mtrand.c',
                                                 'mtrand.pyx',
                                                 'numpy.pxi',
-                                                'randomkit.c', 
-                                                'randomkit.h', 
-                                                'Python.pxi', 
+                                                'randomkit.c',
+                                                'randomkit.h',
+                                                'Python.pxi',
                                                 'initarray.c',
                                                 'initarray.h',
                                                 'distributions.c',



From numpy-svn at scipy.org  Fri Feb  8 15:20:57 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  8 Feb 2008 14:20:57 -0600 (CST)
Subject: [Numpy-svn] r4776 - trunk/numpy/core
Message-ID: <20080208202057.9C3C539C166@new.scipy.org>

Author: chris.burns
Date: 2008-02-08 14:20:55 -0600 (Fri, 08 Feb 2008)
New Revision: 4776

Modified:
   trunk/numpy/core/setup.py
Log:
Add numpyconfig.h to the install

Modified: trunk/numpy/core/setup.py
===================================================================
--- trunk/numpy/core/setup.py	2008-02-08 10:54:01 UTC (rev 4775)
+++ trunk/numpy/core/setup.py	2008-02-08 20:20:55 UTC (rev 4776)
@@ -189,6 +189,7 @@
             print target_f.read()
             target_f.close()
             print 'EOF'
+        config.add_data_files((header_dir, target))
         return target
 
     def generate_api_func(module_name):



From numpy-svn at scipy.org  Fri Feb  8 19:50:06 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  8 Feb 2008 18:50:06 -0600 (CST)
Subject: [Numpy-svn] r4777 - in branches/maskedarray: . benchmarks numpy
	numpy/core numpy/core/code_generators
	numpy/core/include/numpy numpy/core/src numpy/core/tests
	numpy/distutils numpy/distutils/command numpy/doc numpy/f2py
	numpy/fft numpy/lib numpy/lib/tests numpy/linalg
	numpy/numarray numpy/oldnumeric numpy/random numpy/testing
Message-ID: <20080209005006.A1C3039C114@new.scipy.org>

Author: stefan
Date: 2008-02-08 18:45:11 -0600 (Fri, 08 Feb 2008)
New Revision: 4777

Added:
   branches/maskedarray/numpy/core/SConstruct
   branches/maskedarray/numpy/core/code_generators/__init__.py
   branches/maskedarray/numpy/core/include/numpy/numpyconfig.h.in
   branches/maskedarray/numpy/core/scons_support.py
   branches/maskedarray/numpy/core/setupscons.py
   branches/maskedarray/numpy/distutils/command/scons.py
   branches/maskedarray/numpy/distutils/numpy_distribution.py
   branches/maskedarray/numpy/distutils/setupscons.py
   branches/maskedarray/numpy/f2py/setupscons.py
   branches/maskedarray/numpy/fft/SConstruct
   branches/maskedarray/numpy/fft/setupscons.py
   branches/maskedarray/numpy/lib/SConstruct
   branches/maskedarray/numpy/lib/setupscons.py
   branches/maskedarray/numpy/linalg/SConstruct
   branches/maskedarray/numpy/linalg/setupscons.py
   branches/maskedarray/numpy/numarray/SConstruct
   branches/maskedarray/numpy/numarray/setupscons.py
   branches/maskedarray/numpy/oldnumeric/setupscons.py
   branches/maskedarray/numpy/random/SConstruct
   branches/maskedarray/numpy/random/setupscons.py
   branches/maskedarray/numpy/setupscons.py
   branches/maskedarray/numpy/testing/setupscons.py
   branches/maskedarray/setupscons.py
   branches/maskedarray/test.sh
Modified:
   branches/maskedarray/
   branches/maskedarray/benchmarks/simpleindex.py
   branches/maskedarray/numpy/_import_tools.py
   branches/maskedarray/numpy/add_newdocs.py
   branches/maskedarray/numpy/core/code_generators/generate_array_api.py
   branches/maskedarray/numpy/core/code_generators/generate_ufunc_api.py
   branches/maskedarray/numpy/core/defmatrix.py
   branches/maskedarray/numpy/core/include/numpy/ndarrayobject.h
   branches/maskedarray/numpy/core/numeric.py
   branches/maskedarray/numpy/core/records.py
   branches/maskedarray/numpy/core/setup.py
   branches/maskedarray/numpy/core/src/arraytypes.inc.src
   branches/maskedarray/numpy/core/src/multiarraymodule.c
   branches/maskedarray/numpy/core/src/umathmodule.c.src
   branches/maskedarray/numpy/core/tests/test_regression.py
   branches/maskedarray/numpy/distutils/command/build.py
   branches/maskedarray/numpy/distutils/command/config.py
   branches/maskedarray/numpy/distutils/core.py
   branches/maskedarray/numpy/distutils/misc_util.py
   branches/maskedarray/numpy/doc/example.py
   branches/maskedarray/numpy/f2py/crackfortran.py
   branches/maskedarray/numpy/lib/arraysetops.py
   branches/maskedarray/numpy/lib/format.py
   branches/maskedarray/numpy/lib/io.py
   branches/maskedarray/numpy/lib/scimath.py
   branches/maskedarray/numpy/lib/tests/test_format.py
   branches/maskedarray/numpy/lib/utils.py
   branches/maskedarray/numpy/linalg/linalg.py
Log:
Merge maskedarray branch up to r4776.



Property changes on: branches/maskedarray
___________________________________________________________________
Name: svnmerge-integrated
   - /branches/build_with_scons:1-4676 /branches/cleanconfig_rtm:1-4610 /branches/distutils-revamp:1-2752 /branches/distutils_scons_command:1-4619 /branches/multicore:1-3687 /branches/numpy.scons:1-4484 /trunk:1-2871
   + /branches/build_with_scons:1-4676 /branches/cleanconfig_rtm:1-4677 /branches/distutils-revamp:1-2752 /branches/distutils_scons_command:1-4619 /branches/multicore:1-3687 /branches/numpy.scons:1-4484 /trunk:1-2871


Modified: branches/maskedarray/benchmarks/simpleindex.py
===================================================================
--- branches/maskedarray/benchmarks/simpleindex.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/benchmarks/simpleindex.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -46,4 +46,3 @@
 print "Numarray: ", numarray_timer.repeat(3,100)
 print "Python: ", python_timer.repeat(3,100)
 print "Optimized: ", numpy_timer3.repeat(3,100)
-

Modified: branches/maskedarray/numpy/_import_tools.py
===================================================================
--- branches/maskedarray/numpy/_import_tools.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/_import_tools.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -152,10 +152,10 @@
 
        Parameters
        ----------
-        *packges : arg-tuple 
+        *packges : arg-tuple
              the names (one or more strings) of all the modules one
              wishes to load into the top-level namespace.
-        verbose= : integer 
+        verbose= : integer
              verbosity level [default: -1].
              verbose=-1 will suspend also warnings.
         force= : bool

Modified: branches/maskedarray/numpy/add_newdocs.py
===================================================================
--- branches/maskedarray/numpy/add_newdocs.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/add_newdocs.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -1,7 +1,7 @@
 # This is only meant to add docs to
 #  objects defined in C-extension modules.
 # The purpose is to allow easier editing of the
-#  docstrings without requiring a re-compile. 
+#  docstrings without requiring a re-compile.
 from lib import add_newdoc
 
 add_newdoc('numpy.core','dtype',
@@ -216,6 +216,7 @@
     size is determined by the size of string.  If sep is not empty then the
     string is interpreted in ASCII mode and converted to the desired number type
     using sep as the separator between elements (extra whitespace is ignored).
+    ASCII integer conversions are base-10; octal and hex are not supported.
 
     """)
 
@@ -237,7 +238,7 @@
         open file object or string containing file name.
     dtype : data-type
         data type of the returned array
-    count : int 
+    count : int
         number of items to read (-1 mean 'all')
     sep : string
         separater between items if file is a text file (default "")
@@ -1106,8 +1107,8 @@
     is done if the array is not of float type and 'decimals' is >= 0.
 
     The keyword 'out' may be used to specify a different array to hold the
-    result rather than the default new array. If the type of the array 
-    specified by 'out' differs from that of 'a', the result is cast to the 
+    result rather than the default new array. If the type of the array
+    specified by 'out' differs from that of 'a', the result is cast to the
     new type, otherwise the original type is kept. Floats round to floats
     by default.
 
@@ -1208,7 +1209,7 @@
     |'heapsort' |   3   | O(n*log(n)) |     0      |   no  |
     |------------------------------------------------------|
 
-    All the sort algorithms make temporary copies of the data when the sort is 
+    All the sort algorithms make temporary copies of the data when the sort is
     not along the last axis. Consequently, sorts along the last axis are faster
     and use less space than sorts along other axis.
     """))

Copied: branches/maskedarray/numpy/core/SConstruct (from rev 4776, trunk/numpy/core/SConstruct)

Copied: branches/maskedarray/numpy/core/code_generators/__init__.py (from rev 4776, trunk/numpy/core/code_generators/__init__.py)

Modified: branches/maskedarray/numpy/core/code_generators/generate_array_api.py
===================================================================
--- branches/maskedarray/numpy/core/code_generators/generate_array_api.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/code_generators/generate_array_api.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -1,9 +1,6 @@
 import os
 import genapi
 
-OBJECT_API_ORDER = 'array_api_order.txt'
-MULTIARRAY_API_ORDER = 'multiarray_api_order.txt'
-
 types = ['Generic','Number','Integer','SignedInteger','UnsignedInteger',
          'Inexact',
          'Floating', 'ComplexFloating', 'Flexible', 'Character',
@@ -122,22 +119,30 @@
 """
 
 def generate_api(output_dir, force=False):
-    header_file = os.path.join(output_dir, '__multiarray_api.h')
-    c_file = os.path.join(output_dir,'__multiarray_api.c')
-    doc_file = os.path.join(output_dir, 'multiarray_api.txt')
+    basename = 'multiarray_api'
 
-    targets = (header_file, c_file, doc_file)
-    if (not force
-            and not genapi.should_rebuild(targets,
-                                          [OBJECT_API_ORDER,
-                                           MULTIARRAY_API_ORDER,
-                                           __file__])):
+    h_file = os.path.join(output_dir, '__%s.h' % basename)
+    c_file = os.path.join(output_dir, '__%s.c' % basename)
+    d_file = os.path.join(output_dir, '%s.txt' % basename)
+    targets = (h_file, c_file, d_file)
+    sources = ['array_api_order.txt',  'multiarray_api_order.txt']
+
+    if (not force and not genapi.should_rebuild(targets, sources + [__file__])):
         return targets
+    else:
+        do_generate_api(targets, sources)
 
+    return targets
+
+def do_generate_api(targets, sources):
+    header_file = targets[0]
+    c_file = targets[1]
+    doc_file = targets[2]
+
     objectapi_list = genapi.get_api_functions('OBJECT_API',
-                                              OBJECT_API_ORDER)
+                                              sources[0])
     multiapi_list = genapi.get_api_functions('MULTIARRAY_API',
-                                             MULTIARRAY_API_ORDER)
+                                             sources[1])
     # API fixes for __arrayobject_api.h
 
     fixed = 10

Modified: branches/maskedarray/numpy/core/code_generators/generate_ufunc_api.py
===================================================================
--- branches/maskedarray/numpy/core/code_generators/generate_ufunc_api.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/code_generators/generate_ufunc_api.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -1,8 +1,6 @@
 import os
 import genapi
 
-UFUNC_API_ORDER = 'ufunc_api_order.txt'
-
 h_template = r"""
 #ifdef _UMATHMODULE
 
@@ -72,18 +70,29 @@
 """
 
 def generate_api(output_dir, force=False):
-    header_file = os.path.join(output_dir, '__ufunc_api.h')
-    c_file = os.path.join(output_dir, '__ufunc_api.c')
-    doc_file = os.path.join(output_dir, 'ufunc_api.txt')
+    basename = 'ufunc_api'
 
-    targets = (header_file, c_file, doc_file)
-    if (not force
-            and not genapi.should_rebuild(targets,
-                                          [UFUNC_API_ORDER, __file__])):
+    h_file = os.path.join(output_dir, '__%s.h' % basename)
+    c_file = os.path.join(output_dir, '__%s.c' % basename)
+    d_file = os.path.join(output_dir, '%s.txt' % basename)
+    targets = (h_file, c_file, d_file)
+
+    sources = ['ufunc_api_order.txt']
+
+    if (not force and not genapi.should_rebuild(targets, sources + [__file__])):
         return targets
+    else:
+        do_generate_api(targets, sources)
 
-    ufunc_api_list = genapi.get_api_functions('UFUNC_API', UFUNC_API_ORDER)
+    return targets
 
+def do_generate_api(targets, sources):
+    header_file = targets[0]
+    c_file = targets[1]
+    doc_file = targets[2]
+
+    ufunc_api_list = genapi.get_api_functions('UFUNC_API', sources[0])
+
     # API fixes for __arrayobject_api.h
 
     fixed = 1

Modified: branches/maskedarray/numpy/core/defmatrix.py
===================================================================
--- branches/maskedarray/numpy/core/defmatrix.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/defmatrix.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -51,16 +51,16 @@
 class matrix(N.ndarray):
     """mat = matrix(data, dtype=None, copy=True)
 
-    Returns a matrix from an array-like object, or a string of 
+    Returns a matrix from an array-like object, or a string of
     data.  A matrix is a specialized 2-d array that retains
     it's 2-d nature through operations and where '*' means matrix
-    multiplication and '**' means matrix power. 
+    multiplication and '**' means matrix power.
 
     Parameters
     ----------
     data : array-like or string
-       If data is a string, then interpret the string as a matrix 
-         with commas or spaces separating columns and semicolons 
+       If data is a string, then interpret the string as a matrix
+         with commas or spaces separating columns and semicolons
          separating rows.
        If data is array-like than convert the array to a matrix.
     dtype : data-type
@@ -273,7 +273,7 @@
         the flattened array by default, otherwise over the specified axis.
 
         Parameters
-        ----------        
+        ----------
         axis : integer
             Axis along which the means are computed. The default is
             to compute the standard deviation of the flattened array.
@@ -289,7 +289,7 @@
             cast if necessary.
 
         Returns
-        -------        
+        -------
         mean : The return type varies, see above.
             A new array holding the result is returned unless out is
             specified, in which case a reference to out is returned.
@@ -342,7 +342,7 @@
         mean : average
 
         Notes
-        ----- 
+        -----
         The standard deviation is the square root of the
         average of the squared deviations from the mean, i.e. var =
         sqrt(mean((x - x.mean())**2)).  The computed standard
@@ -362,7 +362,7 @@
         ----------
         axis : integer
             Axis along which the variance is computed. The default is to
-            compute the variance of the flattened array.            
+            compute the variance of the flattened array.
         dtype : data-type
             Type to use in computing the variance. For arrays of integer
             type the default is float32, for arrays of float types it is

Modified: branches/maskedarray/numpy/core/include/numpy/ndarrayobject.h
===================================================================
--- branches/maskedarray/numpy/core/include/numpy/ndarrayobject.h	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/include/numpy/ndarrayobject.h	2008-02-09 00:45:11 UTC (rev 4777)
@@ -13,8 +13,15 @@
        everything when you're typing */
 #endif
 /* This is auto-generated by the installer */
-#include "config.h"
+#include "numpyconfig.h"
 
+/* Only use thread if configured in config and python supports it */
+#if defined WITH_THREAD && !NPY_NO_SMP
+        #define NPY_ALLOW_THREADS 1
+#else
+        #define NPY_ALLOW_THREADS 0
+#endif
+
 /* There are several places in the code where an array of dimensions is
  * allocated statically.  This is the size of that static allocation.
  *
@@ -80,7 +87,8 @@
 #define NPY_FALSE 0
 #define NPY_TRUE 1
 
-#if SIZEOF_LONG_DOUBLE==SIZEOF_DOUBLE
+
+#if NPY_SIZEOF_LONGDOUBLE == NPY_SIZEOF_DOUBLE
         typedef double npy_longdouble;
         #define NPY_LONGDOUBLE_FMT "g"
 #else
@@ -279,22 +287,15 @@
 #define NPY_MAX_ULONG  ULONG_MAX
 
 
-#define NPY_SIZEOF_LONG SIZEOF_LONG
-#define NPY_SIZEOF_INT SIZEOF_INT
-#define NPY_SIZEOF_SHORT SIZEOF_SHORT
-#define NPY_SIZEOF_FLOAT SIZEOF_FLOAT
-#define NPY_SIZEOF_DOUBLE SIZEOF_DOUBLE
-#define NPY_SIZEOF_LONGDOUBLE SIZEOF_LONG_DOUBLE
-#define NPY_SIZEOF_LONGLONG SIZEOF_LONG_LONG
 #define NPY_BITSOF_BOOL (sizeof(npy_bool)*CHAR_BIT)
 #define NPY_BITSOF_CHAR CHAR_BIT
-#define NPY_BITSOF_SHORT (SIZEOF_SHORT*CHAR_BIT)
-#define NPY_BITSOF_INT (SIZEOF_INT*CHAR_BIT)
-#define NPY_BITSOF_LONG (SIZEOF_LONG*CHAR_BIT)
-#define NPY_BITSOF_LONGLONG (NPY_SIZEOF_LONGLONG*CHAR_BIT)
-#define NPY_BITSOF_FLOAT (SIZEOF_FLOAT*CHAR_BIT)
-#define NPY_BITSOF_DOUBLE (SIZEOF_DOUBLE*CHAR_BIT)
-#define NPY_BITSOF_LONGDOUBLE (NPY_SIZEOF_LONGDOUBLE*CHAR_BIT)
+#define NPY_BITSOF_SHORT (NPY_SIZEOF_SHORT * CHAR_BIT)
+#define NPY_BITSOF_INT (NPY_SIZEOF_INT * CHAR_BIT)
+#define NPY_BITSOF_LONG (NPY_SIZEOF_LONG * CHAR_BIT)
+#define NPY_BITSOF_LONGLONG (NPY_SIZEOF_LONGLONG * CHAR_BIT)
+#define NPY_BITSOF_FLOAT (NPY_SIZEOF_FLOAT * CHAR_BIT)
+#define NPY_BITSOF_DOUBLE (NPY_SIZEOF_DOUBLE * CHAR_BIT)
+#define NPY_BITSOF_LONGDOUBLE (NPY_SIZEOF_LONGDOUBLE * CHAR_BIT)
 
 #if NPY_BITSOF_LONG == 8
 #define NPY_INT8 NPY_LONG
@@ -918,8 +919,8 @@
  * platform.  Py_intptr_t, Py_uintptr_t are defined in pyport.h. */
 typedef Py_intptr_t npy_intp;
 typedef Py_uintptr_t npy_uintp;
-#define NPY_SIZEOF_INTP SIZEOF_PY_INTPTR_T
-#define NPY_SIZEOF_UINTP SIZEOF_PY_INTPTR_T
+#define NPY_SIZEOF_INTP NPY_SIZEOF_PY_INTPTR_T
+#define NPY_SIZEOF_UINTP NPY_SIZEOF_PY_INTPTR_T
 
 #ifdef constchar
 #undef constchar
@@ -940,7 +941,7 @@
 #define constchar char
 #endif
 
-#if SIZEOF_PY_INTPTR_T == SIZEOF_INT
+#if NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_INT
         #define NPY_INTP NPY_INT
         #define NPY_UINTP NPY_UINT
         #define PyIntpArrType_Type PyIntArrType_Type
@@ -949,7 +950,7 @@
         #define NPY_MIN_INTP NPY_MIN_INT
         #define NPY_MAX_UINTP NPY_MAX_UINT
         #define NPY_INTP_FMT "d"
-#elif SIZEOF_PY_INTPTR_T == SIZEOF_LONG
+#elif NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONG
         #define NPY_INTP NPY_LONG
         #define NPY_UINTP NPY_ULONG
         #define PyIntpArrType_Type PyLongArrType_Type
@@ -958,7 +959,7 @@
         #define NPY_MIN_INTP MIN_LONG
         #define NPY_MAX_UINTP NPY_MAX_ULONG
         #define NPY_INTP_FMT "ld"
-#elif defined(PY_LONG_LONG) && (SIZEOF_PY_INTPTR_T == SIZEOF_LONG_LONG)
+#elif defined(PY_LONG_LONG) && (NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONGLONG)
         #define NPY_INTP NPY_LONGLONG
         #define NPY_UINTP NPY_ULONGLONG
         #define PyIntpArrType_Type PyLongLongArrType_Type
@@ -1894,7 +1895,7 @@
 
 #define PyArray_REFCOUNT(obj) (((PyObject *)(obj))->ob_refcnt)
 #define NPY_REFCOUNT PyArray_REFCOUNT
-#define NPY_MAX_ELSIZE (2*SIZEOF_LONGDOUBLE)
+#define NPY_MAX_ELSIZE (2 * NPY_SIZEOF_LONGDOUBLE)
 
 #define PyArray_ContiguousFromAny(op, type, min_depth, max_depth)             \
         PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth,           \

Copied: branches/maskedarray/numpy/core/include/numpy/numpyconfig.h.in (from rev 4776, trunk/numpy/core/include/numpy/numpyconfig.h.in)

Modified: branches/maskedarray/numpy/core/numeric.py
===================================================================
--- branches/maskedarray/numpy/core/numeric.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/numeric.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -149,7 +149,7 @@
 
 def require(a, dtype=None, requirements=None):
     """Return an ndarray of the provided type that satisfies requirements.
-    
+
     This function is useful to be sure that an array with the correct flags
     is returned for passing to compiled code (perhaps through ctypes).
 
@@ -160,7 +160,7 @@
      dtype : data-type
        The required data-type (None is the default data-type -- float64)
      requirements : list of strings
-       The requirements list can be any of the 
+       The requirements list can be any of the
        'ENSUREARRAY' ('E')  - ensure that  a base-class ndarray
        'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
        'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
@@ -169,7 +169,7 @@
        'OWNDATA' ('O')      - ensure an array that owns its own data
 
        The returned array will be guaranteed to have the listed requirements
-       by making a copy if needed. 
+       by making a copy if needed.
     """
     if requirements is None:
         requirements = []
@@ -276,7 +276,7 @@
 try:
     # importing this changes the dot function for basic 4 types
     # to blas-optimized versions.
-    from _dotblas import dot, vdot, inner, alterdot, restoredot    
+    from _dotblas import dot, vdot, inner, alterdot, restoredot
 except ImportError:
     def alterdot():
         "Does Nothing"

Modified: branches/maskedarray/numpy/core/records.py
===================================================================
--- branches/maskedarray/numpy/core/records.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/records.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -45,9 +45,9 @@
 class format_parser:
     """Class to convert formats, names, titles description to a dtype
 
-    After constructing the format_parser object, the dtype attribute is 
+    After constructing the format_parser object, the dtype attribute is
       the converted data-type.
-    
+
     dtype = format_parser(formats, names, titles).dtype
 
     Parameters
@@ -59,18 +59,18 @@
         comma-separated field names --- 'col1, col2, col3'
         list or tuple of field names
     titles : sequence
-        sequence of title strings or unicode        
+        sequence of title strings or unicode
     aligned : bool
         align the fields by padding as the C-compiler would
-    byteorder : 
-        If specified, all the fields will be changed to the 
+    byteorder :
+        If specified, all the fields will be changed to the
         provided byteorder.  Otherwise, the default byteorder is
         used.
 
     Returns
     -------
     object
-        A Python object whose dtype attribute is a data-type. 
+        A Python object whose dtype attribute is a data-type.
     """
     def __init__(self, formats, names, titles, aligned=False, byteorder=None):
         self._parseFormats(formats, aligned)
@@ -227,9 +227,9 @@
         by the *formats*, *names*, *titles*, *aligned*, and *byteorder* keywords.
     buf : [buffer] or None
         If this is None, then a new array is created of the given shape and data-type
-        If this is an object exposing the buffer interface, then the array will 
-        use the memory from an existing buffer.  In this case, the *offset* and 
-        *strides* keywords can also be used. 
+        If this is an object exposing the buffer interface, then the array will
+        use the memory from an existing buffer.  In this case, the *offset* and
+        *strides* keywords can also be used.
 
     See Also
     --------

Copied: branches/maskedarray/numpy/core/scons_support.py (from rev 4776, trunk/numpy/core/scons_support.py)

Modified: branches/maskedarray/numpy/core/setup.py
===================================================================
--- branches/maskedarray/numpy/core/setup.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/setup.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -18,6 +18,36 @@
     ('rint', 'HAVE_RINT'),
     ]
 
+def is_npy_no_signal():
+    """Return True if the NPY_NO_SIGNAL symbol must be defined in configuration
+    header."""
+    return sys.platform == 'win32'
+
+def is_npy_no_smp():
+    """Return True if the NPY_NO_SMP symbol must be defined in public
+    header (when SMP support cannot be reliably enabled)."""
+    # Python 2.3 causes a segfault when
+    #  trying to re-acquire the thread-state
+    #  which is done in error-handling
+    #  ufunc code.  NPY_ALLOW_C_API and friends
+    #  cause the segfault. So, we disable threading
+    #  for now.
+    if sys.version[:5] < '2.4.2':
+        nosmp = 1
+    else:
+        # Perhaps a fancier check is in order here.
+        #  so that threads are only enabled if there
+        #  are actually multiple CPUS? -- but
+        #  threaded code can be nice even on a single
+        #  CPU so that long-calculating code doesn't
+        #  block.
+        try:
+            nosmp = os.environ['NPY_NOSMP']
+            nosmp = 1
+        except KeyError:
+            nosmp = 0
+    return nosmp == 1
+
 def configuration(parent_package='',top_path=None):
     from numpy.distutils.misc_util import Configuration,dot_join
     from numpy.distutils.system_info import get_info, default_lib_dirs
@@ -53,28 +83,7 @@
                 raise SystemError,"Failed to test configuration. "\
                       "See previous error messages for more information."
 
-                # Python 2.3 causes a segfault when
-                #  trying to re-acquire the thread-state
-                #  which is done in error-handling
-                #  ufunc code.  NPY_ALLOW_C_API and friends
-                #  cause the segfault. So, we disable threading
-                #  for now.
-            if sys.version[:5] < '2.4.2':
-                nosmp = 1
-            else:
-                # Perhaps a fancier check is in order here.
-                #  so that threads are only enabled if there
-                #  are actually multiple CPUS? -- but
-                #  threaded code can be nice even on a single
-                #  CPU so that long-calculating code doesn't
-                #  block.
-                try:
-                    nosmp = os.environ['NPY_NOSMP']
-                    nosmp = 1
-                except KeyError:
-                    nosmp = 0
-            if nosmp: moredefs = [('NPY_ALLOW_THREADS', '0')]
-            else: moredefs = []
+            moredefs = []
             #
             mathlibs = []
             tc = testcode_mathlib()
@@ -102,8 +111,8 @@
                 if check_func(func_name):
                     moredefs.append(defsymbol)
 
-            if sys.platform == 'win32':
-                moredefs.append('NPY_NO_SIGNAL')
+            if is_npy_no_signal():
+                moredefs.append('__NPY_PRIVATE_NO_SIGNAL')
 
             if sys.platform=='win32' or os.name=='nt':
                 from distutils.msvccompiler import get_build_architecture
@@ -123,8 +132,6 @@
                     target_f.write('#define %s\n' % (d))
                 else:
                     target_f.write('#define %s %s\n' % (d[0],d[1]))
-            if not nosmp:  # default is to use WITH_THREAD
-                target_f.write('#ifdef WITH_THREAD\n#define NPY_ALLOW_THREADS 1\n#else\n#define NPY_ALLOW_THREADS 0\n#endif\n')
             target_f.close()
             print 'File:',target
             target_f = open(target)
@@ -151,6 +158,40 @@
         config.add_data_files((header_dir,target))
         return target
 
+    def generate_numpyconfig_h(ext, build_dir):
+        """Depends on config.h: generate_config_h has to be called before !"""
+        target = join(build_dir,'numpyconfig.h')
+        if newer(__file__,target):
+            config_cmd = config.get_config_cmd()
+            log.info('Generating %s',target)
+            testcode = generate_numpyconfig_code(target)
+
+            from distutils import sysconfig
+            python_include = sysconfig.get_python_inc()
+            python_h = join(python_include, 'Python.h')
+            if not os.path.isfile(python_h):
+                raise SystemError,\
+                      "Non-existing %s. Perhaps you need to install"\
+                      " python-dev|python-devel." % (python_h)
+
+            config.numpy_include_dirs
+            result = config_cmd.try_run(testcode,
+                                include_dirs = [python_include] + \
+                                                       config.numpy_include_dirs,
+                                        library_dirs = default_lib_dirs)
+
+            if not result:
+                raise SystemError,"Failed to generate numpy configuration. "\
+                      "See previous error messages for more information."
+
+            print 'File: %s' % target
+            target_f = open(target)
+            print target_f.read()
+            target_f.close()
+            print 'EOF'
+        config.add_data_files((header_dir, target))
+        return target
+
     def generate_api_func(module_name):
         def generate_api(ext, build_dir):
             script = join(codegen_dir, module_name + '.py')
@@ -205,6 +246,7 @@
     config.add_extension('multiarray',
                          sources = [join('src','multiarraymodule.c'),
                                     generate_config_h,
+                                    generate_numpyconfig_h,
                                     generate_array_api,
                                     join('src','scalartypes.inc.src'),
                                     join('src','arraytypes.inc.src'),
@@ -216,6 +258,7 @@
 
     config.add_extension('umath',
                          sources = [generate_config_h,
+                                    generate_numpyconfig_h,
                                     join('src','umathmodule.c.src'),
                                     generate_umath_c,
                                     generate_ufunc_api,
@@ -231,6 +274,7 @@
     config.add_extension('_sort',
                          sources=[join('src','_sortmodule.c.src'),
                                   generate_config_h,
+                                  generate_numpyconfig_h,
                                   generate_array_api,
                                   ],
                          )
@@ -238,6 +282,7 @@
     config.add_extension('scalarmath',
                          sources=[join('src','scalarmathmodule.c.src'),
                                   generate_config_h,
+                                  generate_numpyconfig_h,
                                   generate_array_api,
                                   generate_ufunc_api],
                          )
@@ -342,6 +387,85 @@
     testcode = '\n'.join(testcode)
     return testcode
 
+def generate_numpyconfig_code(target):
+    """Return the source code as a string of the code to generate the
+    numpyconfig header file."""
+    if sys.platform == 'win32':
+        target = target.replace('\\','\\\\')
+    # Config symbols to prepend
+    prepends = [('NPY_SIZEOF_SHORT', 'SIZEOF_SHORT'),
+            ('NPY_SIZEOF_INT', 'SIZEOF_INT'),
+            ('NPY_SIZEOF_LONG', 'SIZEOF_LONG'),
+            ('NPY_SIZEOF_FLOAT', 'SIZEOF_FLOAT'),
+            ('NPY_SIZEOF_DOUBLE', 'SIZEOF_DOUBLE'),
+            ('NPY_SIZEOF_LONGDOUBLE', 'SIZEOF_LONG_DOUBLE'),
+            ('NPY_SIZEOF_PY_INTPTR_T', 'SIZEOF_PY_INTPTR_T')]
+
+    testcode = ["""
+#include <Python.h>
+#include "config.h"
+
+int main()
+{
+    FILE* f;
+
+    f = fopen("%s", "w");
+    if (f == NULL) {
+        return -1;
+    }
+""" % target]
+
+    testcode.append(r"""
+    fprintf(f, "/*\n * This file is generated by %s. DO NOT EDIT \n */\n");
+""" % __file__)
+
+    # Prepend NPY_ to any SIZEOF defines
+    testcode.extend([r'    fprintf(f, "#define ' + i + r' %%d \n", %s);' % j for i, j in prepends])
+
+    # Conditionally define NPY_NO_SIGNAL
+    if is_npy_no_signal():
+        testcode.append(r'    fprintf(f, "\n#define NPY_NO_SIGNAL\n");')
+
+    # Define NPY_NOSMP to 1 if explicitely requested, or if we cannot
+    # support thread support reliably
+    if is_npy_no_smp():
+        testcode.append(r'    fprintf(f, "#define NPY_NO_SMP 1\n");')
+    else:
+        testcode.append(r'    fprintf(f, "#define NPY_NO_SMP 0\n");')
+
+    tmpcode = r"""
+    #ifdef PY_LONG_LONG
+        fprintf(f, "\n#define %s %%d \n", %s);
+        fprintf(f, "#define %s %%d \n", %s);
+    #else
+        fprintf(f, "/* PY_LONG_LONG not defined  */ \n");
+    #endif"""
+    testcode.append(tmpcode % ('NPY_SIZEOF_LONGLONG', 'SIZEOF_LONG_LONG',
+                               'NPY_SIZEOF_PY_LONG_LONG', 'SIZEOF_PY_LONG_LONG'))
+
+    testcode.append(r"""
+#ifndef CHAR_BIT
+          {
+             unsigned char var = 2;
+             int i = 0;
+             while (var >= 2) {
+                     var = var << 1;
+                     i++;
+             }
+             fprintf(f,"#define CHAR_BIT %d\n", i+1);
+          }
+#else
+          fprintf(f, "/* #define CHAR_BIT %d */\n", CHAR_BIT);
+#endif""")
+
+    testcode.append("""
+    fclose(f);
+
+    return 0;
+}
+""")
+    return "\n".join(testcode)
+
 if __name__=='__main__':
     from numpy.distutils.core import setup
     setup(configuration=configuration)

Copied: branches/maskedarray/numpy/core/setupscons.py (from rev 4776, trunk/numpy/core/setupscons.py)

Modified: branches/maskedarray/numpy/core/src/arraytypes.inc.src
===================================================================
--- branches/maskedarray/numpy/core/src/arraytypes.inc.src	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/src/arraytypes.inc.src	2008-02-09 00:45:11 UTC (rev 4777)
@@ -1,4 +1,5 @@
 /* -*- c -*- */
+#include "config.h"
 
 static longlong
 MyPyLong_AsLongLong(PyObject *vv)
@@ -934,7 +935,7 @@
 {
         @btype@ result;
 
-        result = PyOS_strto at func@(str, endptr, 0);
+        result = PyOS_strto at func@(str, endptr, 10);
         *ip = (@type@) result;
         return 0;
 }

Modified: branches/maskedarray/numpy/core/src/multiarraymodule.c
===================================================================
--- branches/maskedarray/numpy/core/src/multiarraymodule.c	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/src/multiarraymodule.c	2008-02-09 00:45:11 UTC (rev 4777)
@@ -3065,23 +3065,25 @@
     PyArrayObject *ap1=NULL;
     PyArrayObject *ap2=NULL;
     PyArrayObject *ret=NULL;
-    int typenum = 0;
+    PyArray_Descr *dtype;
 
     NPY_BEGIN_THREADS_DEF
 
-        typenum = PyArray_ObjectType((PyObject *)op1, 0);
-    typenum = PyArray_ObjectType(op2, typenum);
+    dtype = PyArray_DescrFromObject((PyObject *)op2, op1->descr);
+    
+    /* need ap1 as contiguous array and of right type */
+    Py_INCREF(dtype);
+    ap1 = (PyArrayObject *)PyArray_FromAny((PyObject *)op1, dtype, 
+					   1, 1, NPY_DEFAULT, NULL);
 
-    /* need ap1 as contiguous array and of right type */
-    ap1 = (PyArrayObject *)PyArray_ContiguousFromAny((PyObject *)op1,
-                                                     typenum,
-                                                     1, 1);
-    if (ap1 == NULL)
+    if (ap1 == NULL) {
+        Py_DECREF(dtype);
         return NULL;
+    }
 
     /* need ap2 as contiguous array and of right type */
-    ap2 = (PyArrayObject *)PyArray_ContiguousFromAny(op2, typenum,
-                                                     0, 0);
+    ap2 = (PyArrayObject *)PyArray_FromAny(op2, dtype, 0, 0, NPY_DEFAULT, NULL);
+
     if (ap2 == NULL)
         goto fail;
 
@@ -7267,7 +7269,7 @@
 }
 
 
-#ifndef NPY_NO_SIGNAL
+#ifndef __NPY_PRIVATE_NO_SIGNAL
 
 SIGJMP_BUF _NPY_SIGINT_BUF;
 

Modified: branches/maskedarray/numpy/core/src/umathmodule.c.src
===================================================================
--- branches/maskedarray/numpy/core/src/umathmodule.c.src	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/src/umathmodule.c.src	2008-02-09 00:45:11 UTC (rev 4777)
@@ -5,6 +5,7 @@
 #define _UMATHMODULE
 #include "numpy/ufuncobject.h"
 #include "abstract.h"
+#include "config.h"
 #include <math.h>
 
 /* A whole slew of basic math functions are provided originally

Modified: branches/maskedarray/numpy/core/tests/test_regression.py
===================================================================
--- branches/maskedarray/numpy/core/tests/test_regression.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/core/tests/test_regression.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -771,5 +771,14 @@
     def check_binary_repr_0_width(self, level=rlevel):
         assert_equal(np.binary_repr(0,width=3),'000')
 
+    def check_fromstring(self, level=rlevel):
+        assert_equal(np.fromstring("12:09:09", dtype=int, sep=":"),
+                     [12,9,9])
+
+    def check_searchsorted_variable_length(self, level=rlevel):
+        x = np.array(['a','aa','b'])
+        y = np.array(['d','e'])
+        assert_equal(x.searchsorted(y), [3,3])
+
 if __name__ == "__main__":
     NumpyTest().run()

Modified: branches/maskedarray/numpy/distutils/command/build.py
===================================================================
--- branches/maskedarray/numpy/distutils/command/build.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/distutils/command/build.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -32,3 +32,9 @@
         if build_scripts is None:
             self.build_scripts = os.path.join(self.build_base,
                                               'scripts' + plat_specifier)
+
+    def run(self):
+        # Make sure that scons based extensions are complete.
+        self.run_command('scons')
+
+        old_build.run(self)

Modified: branches/maskedarray/numpy/distutils/command/config.py
===================================================================
--- branches/maskedarray/numpy/distutils/command/config.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/distutils/command/config.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -101,6 +101,21 @@
                                  (body, headers, include_dirs,
                                   libraries, library_dirs, lang))
 
+    def check_decl(self, symbol,
+                   headers=None, include_dirs=None):
+        self._check_compiler()
+        body = """
+int main()
+{
+#ifndef %s
+    (void) %s;
+#endif
+    ;
+    return 0;
+}""" % (symbol, symbol)
+
+        return self.try_compile(body, headers, include_dirs)
+
     def check_func(self, func,
                    headers=None, include_dirs=None,
                    libraries=None, library_dirs=None,

Copied: branches/maskedarray/numpy/distutils/command/scons.py (from rev 4776, trunk/numpy/distutils/command/scons.py)

Modified: branches/maskedarray/numpy/distutils/core.py
===================================================================
--- branches/maskedarray/numpy/distutils/core.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/distutils/core.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -21,9 +21,10 @@
 import distutils.dist
 
 from numpy.distutils.extension import Extension
+from numpy.distutils.numpy_distribution import NumpyDistribution
 from numpy.distutils.command import config, config_compiler, \
      build, build_py, build_ext, build_clib, build_src, build_scripts, \
-     sdist, install_data, install_headers, install, bdist_rpm
+     sdist, install_data, install_headers, install, bdist_rpm, scons
 from numpy.distutils.misc_util import get_data_files, is_sequence, is_string
 
 numpy_cmdclass = {'build':            build.build,
@@ -36,6 +37,7 @@
                   'build_py':         build_py.build_py,
                   'build_clib':       build_clib.build_clib,
                   'sdist':            sdist.sdist,
+                  'scons':            scons.scons,
                   'install_data':     install_data.install_data,
                   'install_headers':  install_headers.install_headers,
                   'install':          install.install,
@@ -95,9 +97,10 @@
     # class is local to a function in setuptools.command.easy_install
     if dist is not None and \
             'DistributionWithoutHelpCommands' in repr(dist):
+        raise NotImplementedError("setuptools not supported yet for numpy.scons branch")
         dist = None
     if always and dist is None:
-        dist = distutils.dist.Distribution()
+        dist = NumpyDistribution()
     return dist
 
 def _exit_interactive_session(_cache=[]):
@@ -175,6 +178,9 @@
        and 'headers' not in new_attr:
         new_attr['headers'] = []
 
+    # Use our custom NumpyDistribution class instead of distutils' one
+    new_attr['distclass'] = NumpyDistribution
+
     return old_setup(**new_attr)
 
 def _check_append_library(libraries, item):

Modified: branches/maskedarray/numpy/distutils/misc_util.py
===================================================================
--- branches/maskedarray/numpy/distutils/misc_util.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/distutils/misc_util.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -112,11 +112,11 @@
     return minrelpath(joined)
 
 def get_mathlibs(path=None):
-    """Return the MATHLIB line from config.h
+    """Return the MATHLIB line from numpyconfig.h
     """
     if path is None:
         path = os.path.join(get_numpy_include_dirs()[0], 'numpy')
-    config_file = os.path.join(path,'config.h')
+    config_file = os.path.join(path,'numpyconfig.h')
     fid = open(config_file)
     mathlibs = []
     s = '#define MATHLIB'
@@ -574,7 +574,7 @@
 class Configuration(object):
 
     _list_keys = ['packages', 'ext_modules', 'data_files', 'include_dirs',
-                  'libraries', 'headers', 'scripts', 'py_modules']
+                  'libraries', 'headers', 'scripts', 'py_modules', 'scons_data']
     _dict_keys = ['package_dir']
     _extra_keys = ['name', 'version']
 
@@ -586,6 +586,7 @@
                  top_path=None,
                  package_path=None,
                  caller_level=1,
+                 setup_name='setup.py',
                  **attrs):
         """Construct configuration instance of a package.
 
@@ -674,6 +675,8 @@
             if caller_instance.options['delegate_options_to_subpackages']:
                 self.set_options(**caller_instance.options)
 
+        self.setup_name = setup_name
+
     def todict(self):
         """Return configuration distionary suitable for passing
         to distutils.core.setup() function.
@@ -795,7 +798,7 @@
         else:
             subpackage_path = njoin([subpackage_path] + l[:-1])
             subpackage_path = self.paths([subpackage_path])[0]
-        setup_py = njoin(subpackage_path, 'setup.py')
+        setup_py = njoin(subpackage_path, self.setup_name)
         if not self.options['ignore_setup_xxx_py']:
             if not os.path.isfile(setup_py):
                 setup_py = njoin(subpackage_path,
@@ -1165,6 +1168,55 @@
             self.warn('distutils distribution has been initialized,'\
                       ' it may be too late to add a library '+ name)
 
+    def add_sconscript(self, sconscript, subpackage_path=None,
+                       standalone = False, pre_hook = None,
+                       post_hook = None, source_files = None):
+        """Add a sconscript to configuration.
+
+        pre_hook and post hook should be sequences of callable, which will be
+        use before and after executing scons. """
+        if standalone:
+            parent_name = None
+        else:
+            parent_name = self.name
+
+        dist = self.get_distribution()
+        # Convert the sconscript name to a relative filename (relative from top
+        # setup.py's directory)
+        fullsconsname = self.paths(sconscript)[0]
+
+        # XXX: Think about a way to automatically register source files from
+        # scons...
+        full_source_files = []
+        if source_files:
+            full_source_files.extend([self.paths(i)[0] for i in source_files])
+
+        if dist is not None:
+            dist.scons_data.append((fullsconsname,
+                                    pre_hook,
+                                    post_hook,
+                                    full_source_files,
+                                    parent_name))
+            self.warn('distutils distribution has been initialized,'\
+                      ' it may be too late to add a subpackage '+ subpackage_name)
+            # XXX: we add a fake extension, to correctly initialize some
+            # options in distutils command.
+            dist.add_extension('', sources = [])
+        else:
+            self.scons_data.append((fullsconsname,
+                                    pre_hook,
+                                    post_hook,
+                                    full_source_files,
+                                    parent_name))
+            # XXX: we add a fake extension, to correctly initialize some
+            # options in distutils command.
+            self.add_extension('', sources = [])
+
+    def add_configres(self):
+        from numscons import get_scons_configres_dir, get_scons_configres_filename
+        file = os.path.join(get_scons_configres_dir(), self.local_path,
+                            get_scons_configres_filename())
+
     def add_scripts(self,*files):
         """Add scripts to configuration.
         """
@@ -1394,6 +1446,12 @@
         """
         self.py_modules.append((self.name,name,generate_config_py))
 
+    def scons_make_config_py(self, name = '__config__'):
+        """Generate package __config__.py file containing system_info
+        information used during building the package.
+        """
+        self.py_modules.append((self.name, name, scons_generate_config_py))
+
     def get_info(self,*names):
         """Get resources information.
         """
@@ -1425,6 +1483,50 @@
     # else running numpy/core/setup.py
     return include_dirs
 
+def scons_generate_config_py(target):
+    """generate config.py file containing system_info information
+    used during building the package.
+
+    usage:
+        config['py_modules'].append((packagename, '__config__',generate_config_py))
+    """
+    from distutils.dir_util import mkpath
+    from numscons import get_scons_configres_dir, get_scons_configres_filename
+    d = {}
+    mkpath(os.path.dirname(target))
+    f = open(target, 'w')
+    f.write('# this file is generated by %s\n' % (os.path.abspath(sys.argv[0])))
+    f.write('# it contains system_info results at the time of building this package.\n')
+    f.write('__all__ = ["show"]\n\n')
+    confdir = get_scons_configres_dir()
+    confilename = get_scons_configres_filename()
+    for root, dirs, files in os.walk(confdir):
+        if files:
+            file = os.path.join(root, confilename)
+            assert root.startswith(confdir)
+            pkg_name = '.'.join(root[len(confdir)+1:].split(os.sep))
+            fid = open(file, 'r')
+            try:
+                cnt = fid.read()
+                d[pkg_name] = eval(cnt)
+            finally:
+                fid.close()
+    # d is a dictionary whose keys are package names, and values the
+    # corresponding configuration. Each configuration is itself a dictionary
+    # (lib : libinfo)
+    f.write('_config = %s\n' % d)
+    f.write(r'''
+def show():
+    for pkg, config in _config.items():
+        print "package %s configuration:" % pkg
+        for lib, libc in config.items():
+            print '    %s' % lib
+            for line in libc.split('\n'):
+                print '\t%s' % line
+    ''')
+    f.close()
+    return target
+
 #########################
 
 def default_config_dict(name = None, parent_name = None, local_path=None):

Copied: branches/maskedarray/numpy/distutils/numpy_distribution.py (from rev 4776, trunk/numpy/distutils/numpy_distribution.py)

Copied: branches/maskedarray/numpy/distutils/setupscons.py (from rev 4776, trunk/numpy/distutils/setupscons.py)

Modified: branches/maskedarray/numpy/doc/example.py
===================================================================
--- branches/maskedarray/numpy/doc/example.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/doc/example.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -53,7 +53,7 @@
         Explanation
 
     See Also
-    --------    
+    --------
     otherfunc : relationship (optional)
     newfunc : relationship (optional)
 

Modified: branches/maskedarray/numpy/f2py/crackfortran.py
===================================================================
--- branches/maskedarray/numpy/f2py/crackfortran.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/f2py/crackfortran.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -791,7 +791,7 @@
             grouplist[groupcounter]=[]
         if needinterface:
             if verbose>1:
-                outmess('analyzeline: Creating additional interface block.\n',0)
+                outmess('analyzeline: Creating additional interface block (groupcounter=%s).\n' % (groupcounter),0)
             groupname[groupcounter]='interface'
             groupcache[groupcounter]['block']='interface'
             groupcache[groupcounter]['name']='unknown_interface'
@@ -892,6 +892,7 @@
             pl = ch[0]
             outmess('analyzeline: cannot handle multiple attributes without type specification. Ignoring %r.\n' % (','.join(ch[1:])))
         last_name = None
+
         for e in [x.strip() for x in markoutercomma(ll).split('@,@')]:
             m1=namepattern.match(e)
             if not m1:
@@ -910,11 +911,14 @@
                 ap=m.group('this')+pl
                 if _intentcallbackpattern.match(ap):
                     if k not in groupcache[groupcounter]['args']:
-                        if groupcounter>1 and \
-                               '__user__' in groupcache[groupcounter-2]['name']:
+                        if groupcounter>1:
                             outmess('analyzeline: appending intent(callback) %s'\
                                     ' to %s arguments\n' % (k,groupcache[groupcounter]['name']))
+                            if '__user__' not in groupcache[groupcounter-2]['name']:
+                                outmess('analyzeline: missing __user__ module (could be nothing)\n')
                             groupcache[groupcounter]['args'].append(k)
+                        else:
+                            errmess('analyzeline: intent(callback) %s is ignored' % (k))
                     else:
                         errmess('analyzeline: intent(callback) %s is already'\
                                 ' in argument list' % (k))

Copied: branches/maskedarray/numpy/f2py/setupscons.py (from rev 4776, trunk/numpy/f2py/setupscons.py)

Copied: branches/maskedarray/numpy/fft/SConstruct (from rev 4776, trunk/numpy/fft/SConstruct)

Copied: branches/maskedarray/numpy/fft/setupscons.py (from rev 4776, trunk/numpy/fft/setupscons.py)

Copied: branches/maskedarray/numpy/lib/SConstruct (from rev 4776, trunk/numpy/lib/SConstruct)

Modified: branches/maskedarray/numpy/lib/arraysetops.py
===================================================================
--- branches/maskedarray/numpy/lib/arraysetops.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/lib/arraysetops.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -207,7 +207,7 @@
     b1 = nm.zeros( ar1.shape, dtype = nm.int8 )
     b2 = nm.ones( ar2.shape, dtype = nm.int8 )
     tt = nm.concatenate( (b1, b2) )
-        
+
     # 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.

Modified: branches/maskedarray/numpy/lib/format.py
===================================================================
--- branches/maskedarray/numpy/lib/format.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/lib/format.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -227,7 +227,7 @@
         raise ValueError("Header does not contain the correct keys: %r" % (keys,))
 
     # Sanity-check the values.
-    if (not isinstance(d['shape'], tuple) or 
+    if (not isinstance(d['shape'], tuple) or
         not numpy.all([isinstance(x, int) for x in d['shape']])):
         raise ValueError("shape is not valid: %r" % (d['shape'],))
     if not isinstance(d['fortran_order'], bool):
@@ -407,6 +407,3 @@
         mode=mode, offset=offset)
 
     return marray
-
-
-

Modified: branches/maskedarray/numpy/lib/io.py
===================================================================
--- branches/maskedarray/numpy/lib/io.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/lib/io.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -19,8 +19,8 @@
 _file = file
 
 class BagObj(object):
-    """A simple class that converts attribute lookups to 
-    getitems on the class passed in. 
+    """A simple class that converts attribute lookups to
+    getitems on the class passed in.
     """
     def __init__(self, obj):
         self._obj = obj
@@ -31,8 +31,8 @@
             raise AttributeError, key
 
 class NpzFile(object):
-    """A dictionary-like object with lazy-loading of files in the zipped 
-    archive provided on construction. 
+    """A dictionary-like object with lazy-loading of files in the zipped
+    archive provided on construction.
 
     The arrays and file strings are lazily loaded on either
     getitem access using obj['key'] or attribute lookup using obj.f.key
@@ -54,13 +54,13 @@
 
     def __getitem__(self, key):
         # FIXME: This seems like it will copy strings around
-        #   more than is strictly necessary.  The zipfile 
+        #   more than is strictly necessary.  The zipfile
         #   will read the string and then
         #   the format.read_array will copy the string
-        #   to another place in memory. 
-        #   It would be better if the zipfile could read 
+        #   to another place in memory.
+        #   It would be better if the zipfile could read
         #   (or at least uncompress) the data
-        #   directly into the array memory. 
+        #   directly into the array memory.
         member = 0
         if key in self._files:
             member = 1
@@ -90,21 +90,21 @@
     memmap : bool
         If true, then memory-map the .npy file or unzip the .npz file into
            a temporary directory and memory-map each component
-        This has no effect for a pickle. 
+        This has no effect for a pickle.
 
     Returns
     -------
     result : array, tuple, dict, etc.
-        data stored in the file. 
+        data stored in the file.
         If file contains pickle data, then whatever is stored in the pickle is
           returned.
-        If the file is .npy file, then an array is returned.  
-        If the file is .npz file, then a dictionary-like object is returned 
+        If the file is .npy file, then an array is returned.
+        If the file is .npz file, then a dictionary-like object is returned
           which has a filename:array key:value pair for every file in the zip.
 
     Raises
     ------
-    IOError 
+    IOError
     """
     if isinstance(file, type("")):
         fid = _file(file,"rb")
@@ -124,7 +124,7 @@
     elif magic == format.MAGIC_PREFIX: # .npy file
         return format.read_array(fid)
     else:  # Try a pickle
-        try: 
+        try:
             return _cload(fid)
         except:
             raise IOError, \
@@ -133,8 +133,8 @@
 def save(file, arr):
     """Save an array to a binary file (a string or file-like object).
 
-    If the file is a string, then if it does not have the .npy extension, 
-        it is appended and a file open. 
+    If the file is a string, then if it does not have the .npy extension,
+        it is appended and a file open.
 
     Data is saved to the open file in NumPy-array format
 
@@ -144,7 +144,7 @@
     ...
     np.save('myfile', a)
     a = np.load('myfile.npy')
-    """    
+    """
     if isinstance(file, str):
         if not file.endswith('.npy'):
             file = file + '.npy'
@@ -158,15 +158,15 @@
 def savez(file, *args, **kwds):
     """Save several arrays into an .npz file format which is a zipped-archive
     of arrays
-    
-    If keyword arguments are given, then filenames are taken from the keywords. 
-    If arguments are passed in with no keywords, then stored file names are 
-    arr_0, arr_1, etc.  
+
+    If keyword arguments are given, then filenames are taken from the keywords.
+    If arguments are passed in with no keywords, then stored file names are
+    arr_0, arr_1, etc.
     """
 
     if isinstance(file, str):
         if not file.endswith('.npz'):
-            file = file + '.npz'        
+            file = file + '.npz'
 
     namedict = kwds
     for i, val in enumerate(args):
@@ -190,7 +190,7 @@
         format.write_array(fid, np.asanyarray(val))
         fid.close()
         zip.write(filename, arcname=fname)
-        
+
     zip.close()
     for name in todel:
         os.remove(name)
@@ -359,7 +359,3 @@
 
     if origShape is not None:
         X.shape = origShape
-
-
-
-

Modified: branches/maskedarray/numpy/lib/scimath.py
===================================================================
--- branches/maskedarray/numpy/lib/scimath.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/lib/scimath.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -93,7 +93,7 @@
     """Convert `x` to complex if it has real, negative components.
 
     Otherwise, output is just the array version of the input (via asarray).
-    
+
     Parameters
     ----------
     x : array_like
@@ -119,7 +119,7 @@
     """Convert `x` to double if it has real, negative components.
 
     Otherwise, output is just the array version of the input (via asarray).
-    
+
     Parameters
     ----------
     x : array_like
@@ -145,7 +145,7 @@
     """Convert `x` to complex if it has real components x_i with abs(x_i)>1.
 
     Otherwise, output is just the array version of the input (via asarray).
-    
+
     Parameters
     ----------
     x : array_like
@@ -203,7 +203,7 @@
 
     If x contains negative inputs, the answer is computed and returned in the
     complex domain.
-    
+
     Parameters
     ----------
     x : array_like
@@ -221,7 +221,7 @@
 
     Negative arguments are correctly handled (recall that for negative
     arguments, the identity exp(log(z))==z does not hold anymore):
-    
+
     >>> log(-math.exp(1)) == (1+1j*math.pi)
     True
     """
@@ -233,7 +233,7 @@
 
     If x contains negative inputs, the answer is computed and returned in the
     complex domain.
-    
+
     Parameters
     ----------
     x : array_like
@@ -263,7 +263,7 @@
 
     If x contains negative inputs, the answer is computed and returned in the
     complex domain.
-    
+
     Parameters
     ----------
     x : array_like
@@ -293,7 +293,7 @@
 
     If x contains negative inputs, the answer is computed and returned in the
     complex domain.
-    
+
     Parameters
     ----------
     x : array_like
@@ -307,7 +307,7 @@
 
     (We set the printing precision so the example can be auto-tested)
     >>> import numpy as np; np.set_printoptions(precision=4)
-    
+
     >>> log2([4,8])
     array([ 2.,  3.])
 
@@ -323,7 +323,7 @@
     If x contains negative values, it is converted to the complex domain.
 
     If p contains negative values, it is converted to floating point.
-    
+
     Parameters
     ----------
     x : array_like
@@ -332,7 +332,7 @@
     Returns
     -------
     array_like
-    
+
     Examples
     --------
     (We set the printing precision so the example can be auto-tested)
@@ -357,7 +357,7 @@
     For real x with abs(x)<=1, this returns the principal value.
 
     If abs(x)>1, the complex arccos() is computed.
-    
+
     Parameters
     ----------
     x : array_like
@@ -385,7 +385,7 @@
     For real x with abs(x)<=1, this returns the principal value.
 
     If abs(x)>1, the complex arcsin() is computed.
-    
+
     Parameters
     ----------
     x : array_like
@@ -414,7 +414,7 @@
     For real x with abs(x)<=1, this returns the principal value.
 
     If abs(x)>1, the complex arctanh() is computed.
-    
+
     Parameters
     ----------
     x : array_like

Copied: branches/maskedarray/numpy/lib/setupscons.py (from rev 4776, trunk/numpy/lib/setupscons.py)

Modified: branches/maskedarray/numpy/lib/tests/test_format.py
===================================================================
--- branches/maskedarray/numpy/lib/tests/test_format.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/lib/tests/test_format.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -21,9 +21,9 @@
     ...     np.complex128,
     ...     object,
     ... ]
-    >>> 
+    >>>
     >>> basic_arrays = []
-    >>> 
+    >>>
     >>> for scalar in scalars:
     ...     for endian in '<>':
     ...         dtype = np.dtype(scalar).newbyteorder(endian)
@@ -36,20 +36,20 @@
     ...             basic.reshape((3,5)).T,
     ...             basic.reshape((3,5))[::-1,::2],
     ...         ])
-    ... 
-    >>> 
+    ...
+    >>>
     >>> Pdescr = [
     ...     ('x', 'i4', (2,)),
     ...     ('y', 'f8', (2, 2)),
     ...     ('z', 'u1')]
-    >>> 
-    >>> 
+    >>>
+    >>>
     >>> PbufferT = [
     ...     ([3,2], [[6.,4.],[6.,4.]], 8),
     ...     ([4,3], [[7.,5.],[7.,5.]], 9),
     ...     ]
-    >>> 
-    >>> 
+    >>>
+    >>>
     >>> Ndescr = [
     ...     ('x', 'i4', (2,)),
     ...     ('Info', [
@@ -68,14 +68,14 @@
     ...         ('Value', 'c16')]),
     ...     ('y', 'f8', (2, 2)),
     ...     ('z', 'u1')]
-    >>> 
-    >>> 
+    >>>
+    >>>
     >>> NbufferT = [
     ...     ([3,2], (6j, 6., ('nn', [6j,4j], [6.,4.], [1,2]), 'NN', True), 'cc', ('NN', 6j), [[6.,4.],[6.,4.]], 8),
     ...     ([4,3], (7j, 7., ('oo', [7j,5j], [7.,5.], [2,1]), 'OO', False), 'dd', ('OO', 7j), [[7.,5.],[7.,5.]], 9),
     ...     ]
-    >>> 
-    >>> 
+    >>>
+    >>>
     >>> record_arrays = [
     ...     np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('<')),
     ...     np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('<')),
@@ -111,7 +111,7 @@
     ...     f = StringIO()
     ...     format.write_array_header_1_0(f, arr)
     ...     print repr(f.getvalue())
-    ... 
+    ...
     "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (0,)}              \n"
     "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': ()}                \n"
     "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (15,)}             \n"
@@ -506,5 +506,3 @@
     for magic in bad_version_magic + malformed_magic:
         f = StringIO(magic)
         yield raises(ValueError)(format.read_array), f
-
-

Modified: branches/maskedarray/numpy/lib/utils.py
===================================================================
--- branches/maskedarray/numpy/lib/utils.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/lib/utils.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -106,7 +106,7 @@
     else:
         str1 = "%s is deprecated, use %s" % (oldname, newname),
         depdoc = '%s is DEPRECATED!! -- use %s instead' % (oldname, newname,)
-        
+
     def newfunc(*args,**kwds):
         warnings.warn(str1, DeprecationWarning)
         return func(*args, **kwds)
@@ -487,28 +487,28 @@
 #   * raise SyntaxError instead of a custom exception.
 
 class SafeEval(object):
-    
+
     def visit(self, node, **kw):
         cls = node.__class__
         meth = getattr(self,'visit'+cls.__name__,self.default)
         return meth(node, **kw)
-            
+
     def default(self, node, **kw):
         raise SyntaxError("Unsupported source construct: %s" % node.__class__)
-            
+
     def visitExpression(self, node, **kw):
         for child in node.getChildNodes():
             return self.visit(child, **kw)
-    
+
     def visitConst(self, node, **kw):
         return node.value
 
     def visitDict(self, node,**kw):
         return dict([(self.visit(k),self.visit(v)) for k,v in node.items])
-        
+
     def visitTuple(self, node, **kw):
         return tuple([self.visit(i) for i in node.nodes])
-        
+
     def visitList(self, node, **kw):
         return [self.visit(i) for i in node.nodes]
 
@@ -578,5 +578,3 @@
         raise
 
 #-----------------------------------------------------------------------------
-
-

Copied: branches/maskedarray/numpy/linalg/SConstruct (from rev 4776, trunk/numpy/linalg/SConstruct)

Modified: branches/maskedarray/numpy/linalg/linalg.py
===================================================================
--- branches/maskedarray/numpy/linalg/linalg.py	2008-02-08 20:20:55 UTC (rev 4776)
+++ branches/maskedarray/numpy/linalg/linalg.py	2008-02-09 00:45:11 UTC (rev 4777)
@@ -138,11 +138,11 @@
 
 def tensorsolve(a, b, axes=None):
     """Solve the tensor equation a x = b for x
-    
+
     It is assumed that all indices of x are summed over in the product,
     together with the rightmost indices of a, similarly as in
     tensordot(a, x, axes=len(b.shape)).
-    
+
     Parameters
     ----------
     a : array, shape b.shape+Q
@@ -153,11 +153,11 @@
     axes : tuple of integers
         Axes in a to reorder to the right, before inversion.
         If None (default), no reordering is done.
-    
+
     Returns
     -------
     x : array, shape Q
-    
+
     Examples
     --------
     >>> from numpy import *
@@ -169,7 +169,7 @@
     (2, 3, 4)
     >>> allclose(tensordot(a, x, axes=3), b)
     True
-    
+
     """
     a = asarray(a)
     b = asarray(b)
@@ -206,7 +206,7 @@
     x : array, shape (M,)
 
     Raises LinAlgError if a is singular or not square
-    
+
     """
     one_eq = len(b.shape) == 1
     if one_eq:
@@ -239,10 +239,10 @@
 
     The result is an inverse corresponding to the operation
     tensordot(a, b, ind), ie.,
-    
+
         x == tensordot(tensordot(tensorinv(a), a, ind), x, ind)
           == tensordot(tensordot(a, tensorinv(a), ind), x, ind)
-    
+
     for all x (up to floating-point accuracy).
 
     Parameters
@@ -298,12 +298,12 @@
 
 def inv(a):
     """Compute the inverse of a matrix.
-    
+
     Parameters
     ----------
     a : array-like, shape (M, M)
         Matrix to be inverted
-    
+
     Returns
     -------
     ainv : array-like, shape (M, M)
@@ -330,20 +330,20 @@
 
 def cholesky(a):
     """Compute the Cholesky decomposition of a matrix.
-    
+
     Returns the Cholesky decomposition, :lm:`A = L L^*` of a Hermitian
     positive-definite matrix :lm:`A`.
-    
+
     Parameters
     ----------
     a : array, shape (M, M)
         Matrix to be decomposed
-    
+
     Returns
     -------
     L : array, shape (M, M)
         Lower-triangular Cholesky factor of A
-    
+
     Raises LinAlgError if decomposition fails
 
     Examples
@@ -357,7 +357,7 @@
     >>> dot(L, L.T.conj())
     array([[ 1.+0.j,  0.-2.j],
            [ 0.+2.j,  5.+0.j]])
-    
+
     """
     _assertRank2(a)
     _assertSquareness(a)
@@ -400,7 +400,7 @@
     Q : double or complex array, shape (M, K)
     R : double or complex array, shape (K, N)
         Size K = min(M, N)
-    
+
     mode = 'r'
     R : double or complex array, shape (K, N)
 
@@ -429,7 +429,7 @@
     True
     >>> allclose(r, triu(r3[:6,:6], k=0))
     True
-    
+
     """
     _assertRank2(a)
     m, n = a.shape
@@ -507,7 +507,7 @@
 
 def eigvals(a):
     """Compute the eigenvalues of a general matrix.
-    
+
     Parameters
     ----------
     a : array, shape (M, M)
@@ -520,7 +520,7 @@
         The eigenvalues, each repeated according to its multiplicity.
         They are not necessarily ordered, nor are they necessarily
         real for real matrices.
-    
+
     Raises LinAlgError if eigenvalue computation does not converge
 
     See Also
@@ -534,7 +534,7 @@
     This is a simple interface to the LAPACK routines dgeev and zgeev
     that sets the flags to return only the eigenvalues of general real
     and complex arrays respectively.
-    
+
     The number w is an eigenvalue of a if there exists a vector v
     satisfying the equation dot(a,v) = w*v. Alternately, if w is a root of
     the characteristic equation det(a - w[i]*I) = 0, where det is the
@@ -586,7 +586,7 @@
 
 def eigvalsh(a, UPLO='L'):
     """Compute the eigenvalues of a Hermitean or real symmetric matrix.
-    
+
     Parameters
     ----------
     a : array, shape (M, M)
@@ -596,7 +596,7 @@
         Specifies whether the pertinent array data is taken from the upper
         or lower triangular part of a. Possible values are 'L', and 'U' for
         upper and lower respectively. Default is 'L'.
-    
+
     Returns
     -------
     w : double array, shape (M,)
@@ -616,7 +616,7 @@
     This is a simple interface to the LAPACK routines dsyevd and
     zheevd that sets the flags to return only the eigenvalues of real
     symmetric and complex Hermetian arrays respectively.
-    
+
     The number w is an eigenvalue of a if there exists a vector v
     satisfying the equation dot(a,v) = w*v. Alternately, if w is a root of
     the characteristic equation det(a - w[i]*I) = 0, where det is the
@@ -714,10 +714,10 @@
     that fact. If the eigenvalues are all different, then theoretically the
     eigenvectors are independent. Likewise, the matrix of eigenvectors is
     unitary if the matrix a is normal, i.e., if dot(a, a.H) = dot(a.H, a).
-    
+
     The left and right eigenvectors are not necessarily the (Hermitian)
     transposes of each other.
-    
+
     """
     a, wrap = _makearray(a)
     _assertRank2(a)
@@ -775,7 +775,7 @@
 
 def eigh(a, UPLO='L'):
     """Compute eigenvalues for a Hermitian or real symmetric matrix.
-    
+
     Parameters
     ----------
     a : array, shape (M, M)
@@ -785,7 +785,7 @@
         Specifies whether the pertinent array date is taken from the upper
         or lower triangular part of a. Possible values are 'L', and 'U'.
         Default is 'L'.
-    
+
     Returns
     -------
     w : double array, shape (M,)
@@ -793,7 +793,7 @@
     v : double or complex double array, shape (M, M)
         The normalized eigenvector corresponding to the eigenvalue w[i] is
         the column v[:,i].
-    
+
     Raises LinAlgError if eigenvalue computation does not converge
 
     See Also
@@ -801,13 +801,13 @@
     eigvalsh : eigenvalues of symmetric or Hemitiean arrays.
     eig : eigenvalues and right eigenvectors for non-symmetric arrays
     eigvals : eigenvalues of non-symmetric array.
-    
+
     Notes
     -----
     A simple interface to the LAPACK routines dsyevd and zheevd that compute
     the eigenvalues and eigenvectors of real symmetric and complex Hermitian
     arrays respectively.
-    
+
     The number w is an eigenvalue of a if there exists a vector v
     satisfying the equation dot(a,v) = w*v. Alternately, if w is a root of
     the characteristic equation det(a - w[i]*I) = 0, where det is the
@@ -866,7 +866,7 @@
     an 1d-array s of singular values (real, non-negative) such that
     a == U S Vh  if S is an suitably shaped matrix of zeros whose
     main diagonal is s.
-    
+
     Parameters
     ----------
     a : array, shape (M, N)
@@ -876,7 +876,7 @@
         If false, the shapes are    (M,K), (K,N) where K = min(M,N)
     compute_uv : boolean
         Whether to compute also U, Vh in addition to s
-    
+
     Returns
     -------
     U:  array, shape (M,M) or (M,K) depending on full_matrices
@@ -884,7 +884,7 @@
         The singular values, sorted so that s[i] >= s[i+1]
         K = min(M, N)
     Vh: array, shape (N,N) or (K,N) depending on full_matrices
-    
+
     For compute_uv = False, only s is returned.
 
     Raises LinAlgError if SVD computation does not converge
@@ -895,14 +895,14 @@
     >>> U, s, Vh = linalg.svd(a)
     >>> U.shape, Vh.shape, s.shape
     ((9, 9), (6, 6), (6,))
-    
+
     >>> U, s, Vh = linalg.svd(a, full_matrices=False)
     >>> U.shape, Vh.shape, s.shape
     ((9, 6), (6, 6), (6,))
     >>> S = diag(s)
     >>> allclose(a, dot(U, dot(S, Vh)))
     True
-    
+
     >>> s2 = linalg.svd(a, compute_uv=False)
     >>> allclose(s, s2)
     True
@@ -969,11 +969,11 @@
 
 def pinv(a, rcond=1e-15 ):
     """Compute the (Moore-Penrose) pseudo-inverse of a matrix.
-    
+
     Calculate a generalized inverse of a matrix using its
     singular-value decomposition and including all 'large' singular
     values.
-    
+
     Parameters
     ----------
     a : array, shape (M, N)
@@ -982,11 +982,11 @@
         Cutoff for 'small' singular values.
         Singular values smaller than rcond*largest_singular_value are
         considered zero.
-    
+
     Returns
     -------
     B : array, shape (N, M)
-    
+
     Raises LinAlgError if SVD computation does not converge
 
     Examples
@@ -998,7 +998,7 @@
     True
     >>> allclose(B, dot(B, dot(a, B)))
     True
-    
+
     """
     a, wrap = _makearray(a)
     _assertNonEmpty(a)
@@ -1028,7 +1028,7 @@
     -------
     det : float or complex
         Determinant of a
-    
+
     Notes
     -----
     The determinant is computed via LU factorization, LAPACK routine z/dgetrf.
@@ -1057,9 +1057,9 @@
 
 def lstsq(a, b, rcond=-1):
     """Compute least-squares solution to equation :m:`a x = b`
-    
+
     Compute a vector x such that the 2-norm :m:`|b - a x|` is minimised.
-    
+
     Parameters
     ----------
     a : array, shape (M, N)
@@ -1068,9 +1068,9 @@
         Cutoff for 'small' singular values.
         Singular values smaller than rcond*largest_singular_value are
         considered zero.
-    
+
     Raises LinAlgError if computation does not converge
-    
+
     Returns
     -------
     x : array, shape (N,) or (N, K) depending on shape of b
@@ -1169,7 +1169,7 @@
         -2     smallest singular value       as below
         other  -                             sum(abs(x)**ord)**(1./ord)
         =====  ============================  ==========================
-    
+
     Returns
     -------
     n : float
@@ -1180,7 +1180,7 @@
     For values ord < 0, the result is, strictly speaking, not a
     mathematical 'norm', but it may still be useful for numerical
     purposes.
-    
+
     """
     x = asarray(x)
     nd = len(x.shape)

Copied: branches/maskedarray/numpy/linalg/setupscons.py (from rev 4776, trunk/numpy/linalg/setupscons.py)

Copied: branches/maskedarray/numpy/numarray/SConstruct (from rev 4776, trunk/numpy/numarray/SConstruct)

Copied: branches/maskedarray/numpy/numarray/setupscons.py (from rev 4776, trunk/numpy/numarray/setupscons.py)

Copied: branches/maskedarray/numpy/oldnumeric/setupscons.py (from rev 4776, trunk/numpy/oldnumeric/setupscons.py)

Copied: branches/maskedarray/numpy/random/SConstruct (from rev 4776, trunk/numpy/random/SConstruct)

Copied: branches/maskedarray/numpy/random/setupscons.py (from rev 4776, trunk/numpy/random/setupscons.py)

Copied: branches/maskedarray/numpy/setupscons.py (from rev 4776, trunk/numpy/setupscons.py)

Copied: branches/maskedarray/numpy/testing/setupscons.py (from rev 4776, trunk/numpy/testing/setupscons.py)

Copied: branches/maskedarray/setupscons.py (from rev 4776, trunk/setupscons.py)

Copied: branches/maskedarray/test.sh (from rev 4776, trunk/test.sh)



From numpy-svn at scipy.org  Fri Feb  8 20:36:57 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri,  8 Feb 2008 19:36:57 -0600 (CST)
Subject: [Numpy-svn] r4778 - in trunk: . numpy numpy/core numpy/core/tests
	numpy/ma numpy/ma/tests
Message-ID: <20080209013657.16F7139C114@new.scipy.org>

Author: stefan
Date: 2008-02-08 19:35:25 -0600 (Fri, 08 Feb 2008)
New Revision: 4778

Added:
   trunk/numpy/ma/
   trunk/numpy/ma/API_CHANGES.txt
   trunk/numpy/ma/LICENSE
   trunk/numpy/ma/__init__.py
   trunk/numpy/ma/core.py
   trunk/numpy/ma/extras.py
   trunk/numpy/ma/setup.py
   trunk/numpy/ma/tests/
   trunk/numpy/ma/tests/test_core.py
   trunk/numpy/ma/tests/test_extras.py
   trunk/numpy/ma/tests/test_old_ma.py
   trunk/numpy/ma/tests/test_subclassing.py
   trunk/numpy/ma/testutils.py
Removed:
   trunk/numpy/core/ma.py
   trunk/numpy/core/tests/test_ma.py
   trunk/numpy/ma/API_CHANGES.txt
   trunk/numpy/ma/LICENSE
   trunk/numpy/ma/__init__.py
   trunk/numpy/ma/core.py
   trunk/numpy/ma/extras.py
   trunk/numpy/ma/setup.py
   trunk/numpy/ma/tests/
   trunk/numpy/ma/tests/test_core.py
   trunk/numpy/ma/tests/test_extras.py
   trunk/numpy/ma/tests/test_old_ma.py
   trunk/numpy/ma/tests/test_subclassing.py
   trunk/numpy/ma/testutils.py
Modified:
   trunk/THANKS.txt
   trunk/numpy/__init__.py
   trunk/numpy/core/__init__.py
   trunk/numpy/core/tests/test_regression.py
   trunk/numpy/setup.py
Log:
Merge maskedarray branch.


Modified: trunk/THANKS.txt
===================================================================
--- trunk/THANKS.txt	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/THANKS.txt	2008-02-09 01:35:25 UTC (rev 4778)
@@ -35,3 +35,4 @@
 Stefan van der Walt for documentation, bug-fixes and regression-tests.
 Andrew Straw for help with http://www.scipy.org, documentation, and testing. 
 David Cournapeau for documentation, bug-fixes, and code contributions including fast_clipping.
+Pierre Gerard-Marchant for his rewrite of the masked array functionality.

Modified: trunk/numpy/__init__.py
===================================================================
--- trunk/numpy/__init__.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/__init__.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -38,6 +38,9 @@
         loader = PackageLoader(infunc=True)
         return loader(*packages, **options)
 
+    import add_newdocs
+    __all__ = ['add_newdocs',]
+
     pkgload.__doc__ = PackageLoader.__call__.__doc__
     import testing
     from testing import ScipyTest, NumpyTest
@@ -49,6 +52,7 @@
     import fft
     import random
     import ctypeslib
+    import ma
 
     # Make these accessible from numpy name-space
     #  but not imported in from numpy import *
@@ -56,11 +60,11 @@
          object, unicode, str
     from core import round, abs, max, min
 
-    __all__ = ['__version__', 'pkgload', 'PackageLoader',
-               'ScipyTest', 'NumpyTest', 'show_config']
-    __all__ += core.__all__
-    __all__ += lib.__all__
-    __all__ += ['linalg', 'fft', 'random', 'ctypeslib']
+    __all__.extend(['__version__', 'pkgload', 'PackageLoader',
+               'ScipyTest', 'NumpyTest', 'show_config'])
+    __all__.extend(core.__all__)
+    __all__.extend(lib.__all__)
+    __all__.extend(['linalg', 'fft', 'random', 'ctypeslib'])
 
     if __doc__ is not None:
         __doc__ += """
@@ -97,10 +101,6 @@
         return NumpyTest().test(*args, **kw)
     test.__doc__ = NumpyTest.test.__doc__
 
-    import add_newdocs
-
-    __all__.extend(['add_newdocs'])
-
     if __doc__ is not None:
         __doc__ += """
 

Modified: trunk/numpy/core/__init__.py
===================================================================
--- trunk/numpy/core/__init__.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/core/__init__.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -11,7 +11,6 @@
 from numeric import *
 from fromnumeric import *
 from defmatrix import *
-import ma
 import defchararray as char
 import records as rec
 from records import *
@@ -24,7 +23,7 @@
      round_ as round
 from numeric import absolute as abs
 
-__all__ = ['char','rec','memmap','ma']
+__all__ = ['char','rec','memmap']
 __all__ += numeric.__all__
 __all__ += fromnumeric.__all__
 __all__ += defmatrix.__all__

Deleted: trunk/numpy/core/ma.py
===================================================================
--- trunk/numpy/core/ma.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/core/ma.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,2255 +0,0 @@
-"""MA: a facility for dealing with missing observations
-MA is generally used as a numpy.array look-alike.
-by Paul F. Dubois.
-
-Copyright 1999, 2000, 2001 Regents of the University of California.
-Released for unlimited redistribution.
-Adapted for numpy_core 2005 by Travis Oliphant and
-(mainly) Paul Dubois.
-"""
-import types, sys
-
-import umath
-import fromnumeric
-from numeric import newaxis, ndarray, inf
-from fromnumeric import amax, amin
-from numerictypes import bool_, typecodes
-import numeric
-import warnings
-
-# Ufunc domain lookup for __array_wrap__
-ufunc_domain = {}
-# Ufunc fills lookup for __array__
-ufunc_fills = {}
-
-MaskType = bool_
-nomask = MaskType(0)
-divide_tolerance = 1.e-35
-
-class MAError (Exception):
-    def __init__ (self, args=None):
-        "Create an exception"
-
-        # The .args attribute must be a tuple.
-        if not isinstance(args, tuple):
-            args = (args,)
-        self.args = args
-    def __str__(self):
-        "Calculate the string representation"
-        return str(self.args[0])
-    __repr__ = __str__
-
-class _MaskedPrintOption:
-    "One instance of this class, masked_print_option, is created."
-    def __init__ (self, display):
-        "Create the masked print option object."
-        self.set_display(display)
-        self._enabled = 1
-
-    def display (self):
-        "Show what prints for masked values."
-        return self._display
-
-    def set_display (self, s):
-        "set_display(s) sets what prints for masked values."
-        self._display = s
-
-    def enabled (self):
-        "Is the use of the display value enabled?"
-        return self._enabled
-
-    def enable(self, flag=1):
-        "Set the enabling flag to flag."
-        self._enabled = flag
-
-    def __str__ (self):
-        return str(self._display)
-
-    __repr__ = __str__
-
-#if you single index into a masked location you get this object.
-masked_print_option = _MaskedPrintOption('--')
-
-# Use single element arrays or scalars.
-default_real_fill_value = 1.e20
-default_complex_fill_value = 1.e20 + 0.0j
-default_character_fill_value = '-'
-default_integer_fill_value = 999999
-default_object_fill_value = '?'
-
-def default_fill_value (obj):
-    "Function to calculate default fill value for an object."
-    if isinstance(obj, types.FloatType):
-        return default_real_fill_value
-    elif isinstance(obj, types.IntType) or isinstance(obj, types.LongType):
-        return default_integer_fill_value
-    elif isinstance(obj, types.StringType):
-        return default_character_fill_value
-    elif isinstance(obj, types.ComplexType):
-        return default_complex_fill_value
-    elif isinstance(obj, MaskedArray) or isinstance(obj, ndarray):
-        x = obj.dtype.char
-        if x in typecodes['Float']:
-            return default_real_fill_value
-        if x in typecodes['Integer']:
-            return default_integer_fill_value
-        if x in typecodes['Complex']:
-            return default_complex_fill_value
-        if x in typecodes['Character']:
-            return default_character_fill_value
-        if x in typecodes['UnsignedInteger']:
-            return umath.absolute(default_integer_fill_value)
-        return default_object_fill_value
-    else:
-        return default_object_fill_value
-
-def minimum_fill_value (obj):
-    "Function to calculate default fill value suitable for taking minima."
-    if isinstance(obj, types.FloatType):
-        return numeric.inf
-    elif isinstance(obj, types.IntType) or isinstance(obj, types.LongType):
-        return sys.maxint
-    elif isinstance(obj, MaskedArray) or isinstance(obj, ndarray):
-        x = obj.dtype.char
-        if x in typecodes['Float']:
-            return numeric.inf
-        if x in typecodes['Integer']:
-            return sys.maxint
-        if x in typecodes['UnsignedInteger']:
-            return sys.maxint
-    else:
-        raise TypeError, 'Unsuitable type for calculating minimum.'
-
-def maximum_fill_value (obj):
-    "Function to calculate default fill value suitable for taking maxima."
-    if isinstance(obj, types.FloatType):
-        return -inf
-    elif isinstance(obj, types.IntType) or isinstance(obj, types.LongType):
-        return -sys.maxint
-    elif isinstance(obj, MaskedArray) or isinstance(obj, ndarray):
-        x = obj.dtype.char
-        if x in typecodes['Float']:
-            return -inf
-        if x in typecodes['Integer']:
-            return -sys.maxint
-        if x in typecodes['UnsignedInteger']:
-            return 0
-    else:
-        raise TypeError, 'Unsuitable type for calculating maximum.'
-
-def set_fill_value (a, fill_value):
-    "Set fill value of a if it is a masked array."
-    if isMaskedArray(a):
-        a.set_fill_value (fill_value)
-
-def getmask (a):
-    """Mask of values in a; could be nomask.
-       Returns nomask if a is not a masked array.
-       To get an array for sure use getmaskarray."""
-    if isinstance(a, MaskedArray):
-        return a.raw_mask()
-    else:
-        return nomask
-
-def getmaskarray (a):
-    """Mask of values in a; an array of zeros if mask is nomask
-     or not a masked array, and is a byte-sized integer.
-     Do not try to add up entries, for example.
-    """
-    m = getmask(a)
-    if m is nomask:
-        return make_mask_none(shape(a))
-    else:
-        return m
-
-def is_mask (m):
-    """Is m a legal mask? Does not check contents, only type.
-    """
-    try:
-        return m.dtype.type is MaskType
-    except AttributeError:
-        return False
-
-def make_mask (m, copy=0, flag=0):
-    """make_mask(m, copy=0, flag=0)
-       return m as a mask, creating a copy if necessary or requested.
-       Can accept any sequence of integers or nomask. Does not check
-       that contents must be 0s and 1s.
-       if flag, return nomask if m contains no true elements.
-    """
-    if m is nomask:
-        return nomask
-    elif isinstance(m, ndarray):
-        if m.dtype.type is MaskType:
-            if copy:
-                result = numeric.array(m, dtype=MaskType, copy=copy)
-            else:
-                result = m
-        else:
-            result = m.astype(MaskType)
-    else:
-        result = filled(m, True).astype(MaskType)
-
-    if flag and not fromnumeric.sometrue(fromnumeric.ravel(result)):
-        return nomask
-    else:
-        return result
-
-def make_mask_none (s):
-    "Return a mask of all zeros of shape s."
-    result = numeric.zeros(s, dtype=MaskType)
-    result.shape = s
-    return result
-
-def mask_or (m1, m2):
-    """Logical or of the mask candidates m1 and m2, treating nomask as false.
-       Result may equal m1 or m2 if the other is nomask.
-     """
-    if m1 is nomask: return make_mask(m2)
-    if m2 is nomask: return make_mask(m1)
-    if m1 is m2 and is_mask(m1): return m1
-    return make_mask(umath.logical_or(m1, m2))
-
-def filled (a, value = None):
-    """a as a contiguous numeric array with any masked areas replaced by value
-    if value is None or the special element "masked", get_fill_value(a)
-    is used instead.
-
-    If a is already a contiguous numeric array, a itself is returned.
-
-    filled(a) can be used to be sure that the result is numeric when
-    passing an object a to other software ignorant of MA, in particular to
-    numeric itself.
-    """
-    if isinstance(a, MaskedArray):
-        return a.filled(value)
-    elif isinstance(a, ndarray) and a.flags['CONTIGUOUS']:
-        return a
-    elif isinstance(a, types.DictType):
-        return numeric.array(a, 'O')
-    else:
-        return numeric.array(a)
-
-def get_fill_value (a):
-    """
-    The fill value of a, if it has one; otherwise, the default fill value
-    for that type.
-    """
-    if isMaskedArray(a):
-        result = a.fill_value()
-    else:
-        result = default_fill_value(a)
-    return result
-
-def common_fill_value (a, b):
-    "The common fill_value of a and b, if there is one, or None"
-    t1 = get_fill_value(a)
-    t2 = get_fill_value(b)
-    if t1 == t2: return t1
-    return None
-
-# Domain functions return 1 where the argument(s) are not in the domain.
-class domain_check_interval:
-    "domain_check_interval(a,b)(x) = true where x < a or y > b"
-    def __init__(self, y1, y2):
-        "domain_check_interval(a,b)(x) = true where x < a or y > b"
-        self.y1 = y1
-        self.y2 = y2
-
-    def __call__ (self, x):
-        "Execute the call behavior."
-        return umath.logical_or(umath.greater (x, self.y2),
-                                   umath.less(x, self.y1)
-                                  )
-
-class domain_tan:
-    "domain_tan(eps) = true where abs(cos(x)) < eps)"
-    def __init__(self, eps):
-        "domain_tan(eps) = true where abs(cos(x)) < eps)"
-        self.eps = eps
-
-    def __call__ (self, x):
-        "Execute the call behavior."
-        return umath.less(umath.absolute(umath.cos(x)), self.eps)
-
-class domain_greater:
-    "domain_greater(v)(x) = true where x <= v"
-    def __init__(self, critical_value):
-        "domain_greater(v)(x) = true where x <= v"
-        self.critical_value = critical_value
-
-    def __call__ (self, x):
-        "Execute the call behavior."
-        return umath.less_equal (x, self.critical_value)
-
-class domain_greater_equal:
-    "domain_greater_equal(v)(x) = true where x < v"
-    def __init__(self, critical_value):
-        "domain_greater_equal(v)(x) = true where x < v"
-        self.critical_value = critical_value
-
-    def __call__ (self, x):
-        "Execute the call behavior."
-        return umath.less (x, self.critical_value)
-
-class masked_unary_operation:
-    def __init__ (self, aufunc, fill=0, domain=None):
-        """ masked_unary_operation(aufunc, fill=0, domain=None)
-            aufunc(fill) must be defined
-            self(x) returns aufunc(x)
-            with masked values where domain(x) is true or getmask(x) is true.
-        """
-        self.f = aufunc
-        self.fill = fill
-        self.domain = domain
-        self.__doc__ = getattr(aufunc, "__doc__", str(aufunc))
-        self.__name__ = getattr(aufunc, "__name__", str(aufunc))
-        ufunc_domain[aufunc] = domain
-        ufunc_fills[aufunc] = fill,
-
-    def __call__ (self, a, *args, **kwargs):
-        "Execute the call behavior."
-# numeric tries to return scalars rather than arrays when given scalars.
-        m = getmask(a)
-        d1 = filled(a, self.fill)
-        if self.domain is not None:
-            m = mask_or(m, self.domain(d1))
-        result = self.f(d1, *args, **kwargs)
-        return masked_array(result, m)
-
-    def __str__ (self):
-        return "Masked version of " + str(self.f)
-
-
-class domain_safe_divide:
-    def __init__ (self, tolerance=divide_tolerance):
-        self.tolerance = tolerance
-    def __call__ (self, a, b):
-        return umath.absolute(a) * self.tolerance >= umath.absolute(b)
-
-class domained_binary_operation:
-    """Binary operations that have a domain, like divide. These are complicated
-       so they are a separate class. They have no reduce, outer or accumulate.
-    """
-    def __init__ (self, abfunc, domain, fillx=0, filly=0):
-        """abfunc(fillx, filly) must be defined.
-           abfunc(x, filly) = x for all x to enable reduce.
-        """
-        self.f = abfunc
-        self.domain = domain
-        self.fillx = fillx
-        self.filly = filly
-        self.__doc__ = getattr(abfunc, "__doc__", str(abfunc))
-        self.__name__ = getattr(abfunc, "__name__", str(abfunc))
-        ufunc_domain[abfunc] = domain
-        ufunc_fills[abfunc] = fillx, filly
-
-    def __call__(self, a, b):
-        "Execute the call behavior."
-        ma = getmask(a)
-        mb = getmask(b)
-        d1 = filled(a, self.fillx)
-        d2 = filled(b, self.filly)
-        t = self.domain(d1, d2)
-
-        if fromnumeric.sometrue(t, None):
-            d2 = where(t, self.filly, d2)
-            mb = mask_or(mb, t)
-        m = mask_or(ma, mb)
-        result =  self.f(d1, d2)
-        return masked_array(result, m)
-
-    def __str__ (self):
-        return "Masked version of " + str(self.f)
-
-class masked_binary_operation:
-    def __init__ (self, abfunc, fillx=0, filly=0):
-        """abfunc(fillx, filly) must be defined.
-           abfunc(x, filly) = x for all x to enable reduce.
-        """
-        self.f = abfunc
-        self.fillx = fillx
-        self.filly = filly
-        self.__doc__ = getattr(abfunc, "__doc__", str(abfunc))
-        ufunc_domain[abfunc] = None
-        ufunc_fills[abfunc] = fillx, filly
-
-    def __call__ (self, a, b, *args, **kwargs):
-        "Execute the call behavior."
-        m = mask_or(getmask(a), getmask(b))
-        d1 = filled(a, self.fillx)
-        d2 = filled(b, self.filly)
-        result = self.f(d1, d2, *args, **kwargs)
-        if isinstance(result, ndarray) \
-               and m.ndim != 0 \
-               and m.shape != result.shape:
-            m = mask_or(getmaskarray(a), getmaskarray(b))
-        return masked_array(result, m)
-
-    def reduce (self, target, axis=0, dtype=None):
-        """Reduce target along the given axis with this function."""
-        m = getmask(target)
-        t = filled(target, self.filly)
-        if t.shape == ():
-            t = t.reshape(1)
-            if m is not nomask:
-                m = make_mask(m, copy=1)
-                m.shape = (1,)
-        if m is nomask:
-            t = self.f.reduce(t, axis)
-        else:
-            t = masked_array (t, m)
-            # XXX: "or t.dtype" below is a workaround for what appears
-            # XXX: to be a bug in reduce.
-            t = self.f.reduce(filled(t, self.filly), axis,
-                              dtype=dtype or t.dtype)
-            m = umath.logical_and.reduce(m, axis)
-        if isinstance(t, ndarray):
-            return masked_array(t, m, get_fill_value(target))
-        elif m:
-            return masked
-        else:
-            return t
-
-    def outer (self, a, b):
-        "Return the function applied to the outer product of a and b."
-        ma = getmask(a)
-        mb = getmask(b)
-        if ma is nomask and mb is nomask:
-            m = nomask
-        else:
-            ma = getmaskarray(a)
-            mb = getmaskarray(b)
-            m = logical_or.outer(ma, mb)
-        d = self.f.outer(filled(a, self.fillx), filled(b, self.filly))
-        return masked_array(d, m)
-
-    def accumulate (self, target, axis=0):
-        """Accumulate target along axis after filling with y fill value."""
-        t = filled(target, self.filly)
-        return masked_array (self.f.accumulate (t, axis))
-    def __str__ (self):
-        return "Masked version of " + str(self.f)
-
-sqrt = masked_unary_operation(umath.sqrt, 0.0, domain_greater_equal(0.0))
-log = masked_unary_operation(umath.log, 1.0, domain_greater(0.0))
-log10 = masked_unary_operation(umath.log10, 1.0, domain_greater(0.0))
-exp = masked_unary_operation(umath.exp)
-conjugate = masked_unary_operation(umath.conjugate)
-sin = masked_unary_operation(umath.sin)
-cos = masked_unary_operation(umath.cos)
-tan = masked_unary_operation(umath.tan, 0.0, domain_tan(1.e-35))
-arcsin = masked_unary_operation(umath.arcsin, 0.0, domain_check_interval(-1.0, 1.0))
-arccos = masked_unary_operation(umath.arccos, 0.0, domain_check_interval(-1.0, 1.0))
-arctan = masked_unary_operation(umath.arctan)
-# Missing from numeric
-arcsinh = masked_unary_operation(umath.arcsinh)
-arccosh = masked_unary_operation(umath.arccosh, 1.0, domain_greater_equal(1.0))
-arctanh = masked_unary_operation(umath.arctanh, 0.0, domain_check_interval(-1.0+1e-15, 1.0-1e-15))
-sinh = masked_unary_operation(umath.sinh)
-cosh = masked_unary_operation(umath.cosh)
-tanh = masked_unary_operation(umath.tanh)
-absolute = masked_unary_operation(umath.absolute)
-fabs = masked_unary_operation(umath.fabs)
-negative = masked_unary_operation(umath.negative)
-
-def nonzero(a):
-    """returns the indices of the elements of a which are not zero
-    and not masked
-    """
-    return numeric.asarray(filled(a, 0).nonzero())
-
-around = masked_unary_operation(fromnumeric.round_)
-floor = masked_unary_operation(umath.floor)
-ceil = masked_unary_operation(umath.ceil)
-logical_not = masked_unary_operation(umath.logical_not)
-
-add = masked_binary_operation(umath.add)
-subtract = masked_binary_operation(umath.subtract)
-subtract.reduce = None
-multiply = masked_binary_operation(umath.multiply, 1, 1)
-divide = domained_binary_operation(umath.divide, domain_safe_divide(), 0, 1)
-true_divide = domained_binary_operation(umath.true_divide, domain_safe_divide(), 0, 1)
-floor_divide = domained_binary_operation(umath.floor_divide, domain_safe_divide(), 0, 1)
-remainder = domained_binary_operation(umath.remainder, domain_safe_divide(), 0, 1)
-fmod = domained_binary_operation(umath.fmod, domain_safe_divide(), 0, 1)
-hypot = masked_binary_operation(umath.hypot)
-arctan2 = masked_binary_operation(umath.arctan2, 0.0, 1.0)
-arctan2.reduce = None
-equal = masked_binary_operation(umath.equal)
-equal.reduce = None
-not_equal = masked_binary_operation(umath.not_equal)
-not_equal.reduce = None
-less_equal = masked_binary_operation(umath.less_equal)
-less_equal.reduce = None
-greater_equal = masked_binary_operation(umath.greater_equal)
-greater_equal.reduce = None
-less = masked_binary_operation(umath.less)
-less.reduce = None
-greater = masked_binary_operation(umath.greater)
-greater.reduce = None
-logical_and = masked_binary_operation(umath.logical_and)
-alltrue = masked_binary_operation(umath.logical_and, 1, 1).reduce
-logical_or = masked_binary_operation(umath.logical_or)
-sometrue = logical_or.reduce
-logical_xor = masked_binary_operation(umath.logical_xor)
-bitwise_and = masked_binary_operation(umath.bitwise_and)
-bitwise_or = masked_binary_operation(umath.bitwise_or)
-bitwise_xor = masked_binary_operation(umath.bitwise_xor)
-
-def rank (object):
-    return fromnumeric.rank(filled(object))
-
-def shape (object):
-    return fromnumeric.shape(filled(object))
-
-def size (object, axis=None):
-    return fromnumeric.size(filled(object), axis)
-
-class MaskedArray (object):
-    """Arrays with possibly masked values.
-       Masked values of 1 exclude the corresponding element from
-       any computation.
-
-       Construction:
-           x = array(data, dtype=None, copy=True, order=False,
-                     mask = nomask, fill_value=None)
-
-       If copy=False, every effort is made not to copy the data:
-           If data is a MaskedArray, and argument mask=nomask,
-           then the candidate data is data.data and the
-           mask used is data.mask. If data is a numeric array,
-           it is used as the candidate raw data.
-           If dtype is not None and
-           is != data.dtype.char then a data copy is required.
-           Otherwise, the candidate is used.
-
-       If a data copy is required, raw data stored is the result of:
-       numeric.array(data, dtype=dtype.char, copy=copy)
-
-       If mask is nomask there are no masked values. Otherwise mask must
-       be convertible to an array of booleans with the same shape as x.
-
-       fill_value is used to fill in masked values when necessary,
-       such as when printing and in method/function filled().
-       The fill_value is not used for computation within this module.
-    """
-    __array_priority__ = 10.1
-    def __init__(self, data, dtype=None, copy=True, order=False,
-                 mask=nomask, fill_value=None):
-        """array(data, dtype=None, copy=True, order=False, mask=nomask, fill_value=None)
-           If data already a numeric array, its dtype becomes the default value of dtype.
-        """
-        if dtype is None:
-            tc = None
-        else:
-            tc = numeric.dtype(dtype)
-        need_data_copied = copy
-        if isinstance(data, MaskedArray):
-            c = data.data
-            if tc is None:
-                tc = c.dtype
-            elif tc != c.dtype:
-                need_data_copied = True
-            if mask is nomask:
-                mask = data.mask
-            elif mask is not nomask: #attempting to change the mask
-                need_data_copied = True
-
-        elif isinstance(data, ndarray):
-            c = data
-            if tc is None:
-                tc = c.dtype
-            elif tc != c.dtype:
-                need_data_copied = True
-        else:
-            need_data_copied = False #because I'll do it now
-            c = numeric.array(data, dtype=tc, copy=True, order=order)
-            tc = c.dtype
-
-        if need_data_copied:
-            if tc == c.dtype:
-                self._data = numeric.array(c, dtype=tc, copy=True, order=order)
-            else:
-                self._data = c.astype(tc)
-        else:
-            self._data = c
-
-        if mask is nomask:
-            self._mask = nomask
-            self._shared_mask = 0
-        else:
-            self._mask = make_mask (mask)
-            if self._mask is nomask:
-                self._shared_mask = 0
-            else:
-                self._shared_mask = (self._mask is mask)
-                nm = size(self._mask)
-                nd = size(self._data)
-                if nm != nd:
-                    if nm == 1:
-                        self._mask = fromnumeric.resize(self._mask, self._data.shape)
-                        self._shared_mask = 0
-                    elif nd == 1:
-                        self._data = fromnumeric.resize(self._data, self._mask.shape)
-                        self._data.shape = self._mask.shape
-                    else:
-                        raise MAError, "Mask and data not compatible."
-                elif nm == 1 and shape(self._mask) != shape(self._data):
-                    self.unshare_mask()
-                    self._mask.shape = self._data.shape
-
-        self.set_fill_value(fill_value)
-
-    def __array__ (self, t=None, context=None):
-        "Special hook for numeric. Converts to numeric if possible."
-        if self._mask is not nomask:
-            if fromnumeric.ravel(self._mask).any():
-                if context is None:
-                    warnings.warn("Cannot automatically convert masked array to "\
-                                  "numeric because data\n    is masked in one or "\
-                                  "more locations.");
-                    return self._data
-                    #raise MAError, \
-                    #      """Cannot automatically convert masked array to numeric because data
-                    #      is masked in one or more locations.
-                    #      """
-                else:
-                    func, args, i = context
-                    fills = ufunc_fills.get(func)
-                    if fills is None:
-                        raise MAError, "%s not known to ma" % func
-                    return self.filled(fills[i])
-            else:  # Mask is all false
-                   # Optimize to avoid future invocations of this section.
-                self._mask = nomask
-                self._shared_mask = 0
-        if t:
-            return self._data.astype(t)
-        else:
-            return self._data
-
-    def __array_wrap__ (self, array, context=None):
-        """Special hook for ufuncs.
-
-        Wraps the numpy array and sets the mask according to
-        context.
-        """
-        if context is None:
-            return MaskedArray(array, copy=False, mask=nomask)
-        func, args = context[:2]
-        domain = ufunc_domain[func]
-        m = reduce(mask_or, [getmask(a) for a in args])
-        if domain is not None:
-            m = mask_or(m, domain(*[getattr(a, '_data', a)
-                                    for a in args]))
-        if m is not nomask:
-            try:
-                shape = array.shape
-            except AttributeError:
-                pass
-            else:
-                if m.shape != shape:
-                    m = reduce(mask_or, [getmaskarray(a) for a in args])
-
-        return MaskedArray(array, copy=False, mask=m)
-
-    def _get_shape(self):
-        "Return the current shape."
-        return self._data.shape
-
-    def _set_shape (self, newshape):
-        "Set the array's shape."
-        self._data.shape = newshape
-        if self._mask is not nomask:
-            self._mask = self._mask.copy()
-            self._mask.shape = newshape
-
-    def _get_flat(self):
-        """Calculate the flat value.
-        """
-        if self._mask is nomask:
-            return masked_array(self._data.ravel(), mask=nomask,
-                                fill_value = self.fill_value())
-        else:
-            return masked_array(self._data.ravel(),
-                                mask=self._mask.ravel(),
-                                fill_value = self.fill_value())
-
-    def _set_flat (self, value):
-        "x.flat = value"
-        y = self.ravel()
-        y[:] = value
-
-    def _get_real(self):
-        "Get the real part of a complex array."
-        if self._mask is nomask:
-            return masked_array(self._data.real, mask=nomask,
-                            fill_value = self.fill_value())
-        else:
-            return masked_array(self._data.real, mask=self._mask,
-                            fill_value = self.fill_value())
-
-    def _set_real (self, value):
-        "x.real = value"
-        y = self.real
-        y[...] = value
-
-    def _get_imaginary(self):
-        "Get the imaginary part of a complex array."
-        if self._mask is nomask:
-            return masked_array(self._data.imag, mask=nomask,
-                            fill_value = self.fill_value())
-        else:
-            return masked_array(self._data.imag, mask=self._mask,
-                            fill_value = self.fill_value())
-
-    def _set_imaginary (self, value):
-        "x.imaginary = value"
-        y = self.imaginary
-        y[...] = value
-
-    def __str__(self):
-        """Calculate the str representation, using masked for fill if
-           it is enabled. Otherwise fill with fill value.
-        """
-        if masked_print_option.enabled():
-            f = masked_print_option
-            # XXX: Without the following special case masked
-            # XXX: would print as "[--]", not "--". Can we avoid
-            # XXX: checks for masked by choosing a different value
-            # XXX: for the masked singleton? 2005-01-05 -- sasha
-            if self is masked:
-                return str(f)
-            m = self._mask
-            if m is not nomask and m.shape == () and m:
-                return str(f)
-            # convert to object array to make filled work
-            self = self.astype(object)
-        else:
-            f = self.fill_value()
-        res = self.filled(f)
-        return str(res)
-
-    def __repr__(self):
-        """Calculate the repr representation, using masked for fill if
-           it is enabled. Otherwise fill with fill value.
-        """
-        with_mask = """\
-array(data =
- %(data)s,
-      mask =
- %(mask)s,
-      fill_value=%(fill)s)
-"""
-        with_mask1 = """\
-array(data = %(data)s,
-      mask = %(mask)s,
-      fill_value=%(fill)s)
-"""
-        without_mask = """array(
- %(data)s)"""
-        without_mask1 = """array(%(data)s)"""
-
-        n = len(self.shape)
-        if self._mask is nomask:
-            if n <= 1:
-                return without_mask1 % {'data':str(self.filled())}
-            return without_mask % {'data':str(self.filled())}
-        else:
-            if n <= 1:
-                return with_mask % {
-                    'data': str(self.filled()),
-                    'mask': str(self._mask),
-                    'fill': str(self.fill_value())
-                    }
-            return with_mask % {
-                'data': str(self.filled()),
-                'mask': str(self._mask),
-                'fill': str(self.fill_value())
-                }
-        without_mask1 = """array(%(data)s)"""
-        if self._mask is nomask:
-            return without_mask % {'data':str(self.filled())}
-        else:
-            return with_mask % {
-                'data': str(self.filled()),
-                'mask': str(self._mask),
-                'fill': str(self.fill_value())
-                }
-
-    def __float__(self):
-        "Convert self to float."
-        self.unmask()
-        if self._mask is not nomask:
-            raise MAError, 'Cannot convert masked element to a Python float.'
-        return float(self.data.item())
-
-    def __int__(self):
-        "Convert self to int."
-        self.unmask()
-        if self._mask is not nomask:
-            raise MAError, 'Cannot convert masked element to a Python int.'
-        return int(self.data.item())
-
-    def __getitem__(self, i):
-        "Get item described by i. Not a copy as in previous versions."
-        self.unshare_mask()
-        m = self._mask
-        dout = self._data[i]
-        if m is nomask:
-            try:
-                if dout.size == 1:
-                    return dout
-                else:
-                    return masked_array(dout, fill_value=self._fill_value)
-            except AttributeError:
-                return dout
-        mi = m[i]
-        if mi.size == 1:
-            if mi:
-                return masked
-            else:
-                return dout
-        else:
-            return masked_array(dout, mi, fill_value=self._fill_value)
-
-# --------
-# setitem and setslice notes
-# note that if value is masked, it means to mask those locations.
-# setting a value changes the mask to match the value in those locations.
-
-    def __setitem__(self, index, value):
-        "Set item described by index. If value is masked, mask those locations."
-        d = self._data
-        if self is masked:
-            raise MAError, 'Cannot alter masked elements.'
-        if value is masked:
-            if self._mask is nomask:
-                self._mask = make_mask_none(d.shape)
-                self._shared_mask = False
-            else:
-                self.unshare_mask()
-            self._mask[index] = True
-            return
-        m = getmask(value)
-        value = filled(value).astype(d.dtype)
-        d[index] = value
-        if m is nomask:
-            if self._mask is not nomask:
-                self.unshare_mask()
-                self._mask[index] = False
-        else:
-            if self._mask is nomask:
-                self._mask = make_mask_none(d.shape)
-                self._shared_mask = True
-            else:
-                self.unshare_mask()
-            self._mask[index] = m
-
-    def __nonzero__(self):
-        """returns true if any element is non-zero or masked
-
-        """
-        # XXX: This changes bool conversion logic from MA.
-        # XXX: In MA bool(a) == len(a) != 0, but in numpy
-        # XXX: scalars do not have len
-        m = self._mask
-        d = self._data
-        return bool(m is not nomask and m.any()
-                    or d is not nomask and d.any())
-
-    def __len__ (self):
-        """Return length of first dimension. This is weird but Python's
-         slicing behavior depends on it."""
-        return len(self._data)
-
-    def __and__(self, other):
-        "Return bitwise_and"
-        return bitwise_and(self, other)
-
-    def __or__(self, other):
-        "Return bitwise_or"
-        return bitwise_or(self, other)
-
-    def __xor__(self, other):
-        "Return bitwise_xor"
-        return bitwise_xor(self, other)
-
-    __rand__ = __and__
-    __ror__ = __or__
-    __rxor__ = __xor__
-
-    def __abs__(self):
-        "Return absolute(self)"
-        return absolute(self)
-
-    def __neg__(self):
-        "Return negative(self)"
-        return negative(self)
-
-    def __pos__(self):
-        "Return array(self)"
-        return array(self)
-
-    def __add__(self, other):
-        "Return add(self, other)"
-        return add(self, other)
-
-    __radd__ = __add__
-
-    def __mod__ (self, other):
-        "Return remainder(self, other)"
-        return remainder(self, other)
-
-    def __rmod__ (self, other):
-        "Return remainder(other, self)"
-        return remainder(other, self)
-
-    def __lshift__ (self, n):
-        return left_shift(self, n)
-
-    def __rshift__ (self, n):
-        return right_shift(self, n)
-
-    def __sub__(self, other):
-        "Return subtract(self, other)"
-        return subtract(self, other)
-
-    def __rsub__(self, other):
-        "Return subtract(other, self)"
-        return subtract(other, self)
-
-    def __mul__(self, other):
-        "Return multiply(self, other)"
-        return multiply(self, other)
-
-    __rmul__ = __mul__
-
-    def __div__(self, other):
-        "Return divide(self, other)"
-        return divide(self, other)
-
-    def __rdiv__(self, other):
-        "Return divide(other, self)"
-        return divide(other, self)
-
-    def __truediv__(self, other):
-        "Return divide(self, other)"
-        return true_divide(self, other)
-
-    def __rtruediv__(self, other):
-        "Return divide(other, self)"
-        return true_divide(other, self)
-
-    def __floordiv__(self, other):
-        "Return divide(self, other)"
-        return floor_divide(self, other)
-
-    def __rfloordiv__(self, other):
-        "Return divide(other, self)"
-        return floor_divide(other, self)
-
-    def __pow__(self, other, third=None):
-        "Return power(self, other, third)"
-        return power(self, other, third)
-
-    def __sqrt__(self):
-        "Return sqrt(self)"
-        return sqrt(self)
-
-    def __iadd__(self, other):
-        "Add other to self in place."
-        t = self._data.dtype.char
-        f = filled(other, 0)
-        t1 = f.dtype.char
-        if t == t1:
-            pass
-        elif t in typecodes['Integer']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        elif t in typecodes['Float']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            elif t1 in typecodes['Float']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        elif t in typecodes['Complex']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            elif t1 in typecodes['Float']:
-                f = f.astype(t)
-            elif t1 in typecodes['Complex']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        else:
-            raise TypeError, 'Incorrect type for in-place operation.'
-
-        if self._mask is nomask:
-            self._data += f
-            m = getmask(other)
-            self._mask = m
-            self._shared_mask = m is not nomask
-        else:
-            result = add(self, masked_array(f, mask=getmask(other)))
-            self._data = result.data
-            self._mask = result.mask
-            self._shared_mask = 1
-        return self
-
-    def __imul__(self, other):
-        "Add other to self in place."
-        t = self._data.dtype.char
-        f = filled(other, 0)
-        t1 = f.dtype.char
-        if t == t1:
-            pass
-        elif t in typecodes['Integer']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        elif t in typecodes['Float']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            elif t1 in typecodes['Float']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        elif t in typecodes['Complex']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            elif t1 in typecodes['Float']:
-                f = f.astype(t)
-            elif t1 in typecodes['Complex']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        else:
-            raise TypeError, 'Incorrect type for in-place operation.'
-
-        if self._mask is nomask:
-            self._data *= f
-            m = getmask(other)
-            self._mask = m
-            self._shared_mask = m is not nomask
-        else:
-            result = multiply(self, masked_array(f, mask=getmask(other)))
-            self._data = result.data
-            self._mask = result.mask
-            self._shared_mask = 1
-        return self
-
-    def __isub__(self, other):
-        "Subtract other from self in place."
-        t = self._data.dtype.char
-        f = filled(other, 0)
-        t1 = f.dtype.char
-        if t == t1:
-            pass
-        elif t in typecodes['Integer']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        elif t in typecodes['Float']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            elif t1 in typecodes['Float']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        elif t in typecodes['Complex']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            elif t1 in typecodes['Float']:
-                f = f.astype(t)
-            elif t1 in typecodes['Complex']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        else:
-            raise TypeError, 'Incorrect type for in-place operation.'
-
-        if self._mask is nomask:
-            self._data -= f
-            m = getmask(other)
-            self._mask = m
-            self._shared_mask = m is not nomask
-        else:
-            result = subtract(self, masked_array(f, mask=getmask(other)))
-            self._data = result.data
-            self._mask = result.mask
-            self._shared_mask = 1
-        return self
-
-
-
-    def __idiv__(self, other):
-        "Divide self by other in place."
-        t = self._data.dtype.char
-        f = filled(other, 0)
-        t1 = f.dtype.char
-        if t == t1:
-            pass
-        elif t in typecodes['Integer']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        elif t in typecodes['Float']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            elif t1 in typecodes['Float']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        elif t in typecodes['Complex']:
-            if t1 in typecodes['Integer']:
-                f = f.astype(t)
-            elif t1 in typecodes['Float']:
-                f = f.astype(t)
-            elif t1 in typecodes['Complex']:
-                f = f.astype(t)
-            else:
-                raise TypeError, 'Incorrect type for in-place operation.'
-        else:
-            raise TypeError, 'Incorrect type for in-place operation.'
-        mo = getmask(other)
-        result = divide(self, masked_array(f, mask=mo))
-        self._data = result.data
-        dm = result.raw_mask()
-        if dm is not self._mask:
-            self._mask = dm
-            self._shared_mask = 1
-        return self
-
-    def __eq__(self, other):
-        return equal(self,other)
-
-    def __ne__(self, other):
-        return not_equal(self,other)
-
-    def __lt__(self, other):
-        return less(self,other)
-
-    def __le__(self, other):
-        return less_equal(self,other)
-
-    def __gt__(self, other):
-        return greater(self,other)
-
-    def __ge__(self, other):
-        return greater_equal(self,other)
-
-    def astype (self, tc):
-        "return self as array of given type."
-        d = self._data.astype(tc)
-        return array(d, mask=self._mask)
-
-    def byte_swapped(self):
-        """Returns the raw data field, byte_swapped. Included for consistency
-         with numeric but doesn't make sense in this context.
-        """
-        return self._data.byte_swapped()
-
-    def compressed (self):
-        "A 1-D array of all the non-masked data."
-        d = fromnumeric.ravel(self._data)
-        if self._mask is nomask:
-            return array(d)
-        else:
-            m = 1 - fromnumeric.ravel(self._mask)
-            c = fromnumeric.compress(m, d)
-            return array(c, copy=0)
-
-    def count (self, axis = None):
-        "Count of the non-masked elements in a, or along a certain axis."
-        m = self._mask
-        s = self._data.shape
-        ls = len(s)
-        if m is nomask:
-            if ls == 0:
-                return 1
-            if ls == 1:
-                return s[0]
-            if axis is None:
-                return reduce(lambda x, y:x*y, s)
-            else:
-                n = s[axis]
-                t = list(s)
-                del t[axis]
-                return ones(t) * n
-        if axis is None:
-            w = fromnumeric.ravel(m).astype(int)
-            n1 = size(w)
-            if n1 == 1:
-                n2 = w[0]
-            else:
-                n2 = umath.add.reduce(w)
-            return n1 - n2
-        else:
-            n1 = size(m, axis)
-            n2 = sum(m.astype(int), axis)
-            return n1 - n2
-
-    def dot (self, other):
-        "s.dot(other) = innerproduct(s, other)"
-        return innerproduct(self, other)
-
-    def fill_value(self):
-        "Get the current fill value."
-        return self._fill_value
-
-    def filled (self, fill_value=None):
-        """A numeric array with masked values filled. If fill_value is None,
-           use self.fill_value().
-
-           If mask is nomask, copy data only if not contiguous.
-           Result is always a contiguous, numeric array.
-# Is contiguous really necessary now?
-        """
-        d = self._data
-        m = self._mask
-        if m is nomask:
-            if d.flags['CONTIGUOUS']:
-                return d
-            else:
-                return d.copy()
-        else:
-            if fill_value is None:
-                value = self._fill_value
-            else:
-                value = fill_value
-
-            if self is masked:
-                result = numeric.array(value)
-            else:
-                try:
-                    result = numeric.array(d, dtype=d.dtype, copy=1)
-                    result[m] = value
-                except (TypeError, AttributeError):
-                    #ok, can't put that value in here
-                    value = numeric.array(value, dtype=object)
-                    d = d.astype(object)
-                    result = fromnumeric.choose(m, (d, value))
-            return result
-
-    def ids (self):
-        """Return the ids of the data and mask areas"""
-        return (id(self._data), id(self._mask))
-
-    def iscontiguous (self):
-        "Is the data contiguous?"
-        return self._data.flags['CONTIGUOUS']
-
-    def itemsize(self):
-        "Item size of each data item."
-        return self._data.itemsize
-
-
-    def outer(self, other):
-        "s.outer(other) = outerproduct(s, other)"
-        return outerproduct(self, other)
-
-    def put (self, values):
-        """Set the non-masked entries of self to filled(values).
-           No change to mask
-        """
-        iota = numeric.arange(self.size)
-        d = self._data
-        if self._mask is nomask:
-            ind = iota
-        else:
-            ind = fromnumeric.compress(1 - self._mask, iota)
-        d[ind] =  filled(values).astype(d.dtype)
-
-    def putmask (self, values):
-        """Set the masked entries of self to filled(values).
-           Mask changed to nomask.
-        """
-        d = self._data
-        if self._mask is not nomask:
-            d[self._mask] = filled(values).astype(d.dtype)
-            self._shared_mask = 0
-            self._mask = nomask
-
-    def ravel (self):
-        """Return a 1-D view of self."""
-        if self._mask is nomask:
-            return masked_array(self._data.ravel())
-        else:
-            return masked_array(self._data.ravel(), self._mask.ravel())
-
-    def raw_data (self):
-        """ Obsolete; use data property instead.
-            The raw data; portions may be meaningless.
-            May be noncontiguous. Expert use only."""
-        return self._data
-    data = property(fget=raw_data,
-           doc="The data, but values at masked locations are meaningless.")
-
-    def raw_mask (self):
-        """ Obsolete; use mask property instead.
-            May be noncontiguous. Expert use only.
-        """
-        return self._mask
-    mask = property(fget=raw_mask,
-           doc="The mask, may be nomask. Values where mask true are meaningless.")
-
-    def reshape (self, *s):
-        """This array reshaped to shape s"""
-        d = self._data.reshape(*s)
-        if self._mask is nomask:
-            return masked_array(d)
-        else:
-            m = self._mask.reshape(*s)
-        return masked_array(d, m)
-
-    def set_fill_value (self, v=None):
-        "Set the fill value to v. Omit v to restore default."
-        if v is None:
-            v = default_fill_value (self.raw_data())
-        self._fill_value = v
-
-    def _get_ndim(self):
-        return self._data.ndim
-    ndim = property(_get_ndim, doc=numeric.ndarray.ndim.__doc__)
-
-    def _get_size (self):
-        return self._data.size
-    size = property(fget=_get_size, doc="Number of elements in the array.")
-## CHECK THIS: signature of numeric.array.size?
-
-    def _get_dtype(self):
-        return self._data.dtype
-    dtype = property(fget=_get_dtype, doc="type of the array elements.")
-
-    def item(self, *args):
-        "Return Python scalar if possible"
-        if self._mask is not nomask:
-            m = self._mask.item(*args)
-            try:
-                if m[0]:
-                    return masked
-            except IndexError:
-                return masked
-        return self._data.item(*args)
-
-    def itemset(self, *args):
-        "Set Python scalar into array"
-        item = args[-1]
-        args = args[:-1]
-        self[args] = item
-
-    def tolist(self, fill_value=None):
-        "Convert to list"
-        return self.filled(fill_value).tolist()
-
-    def tostring(self, fill_value=None):
-        "Convert to string"
-        return self.filled(fill_value).tostring()
-
-    def unmask (self):
-        "Replace the mask by nomask if possible."
-        if self._mask is nomask: return
-        m = make_mask(self._mask, flag=1)
-        if m is nomask:
-            self._mask = nomask
-            self._shared_mask = 0
-
-    def unshare_mask (self):
-        "If currently sharing mask, make a copy."
-        if self._shared_mask:
-            self._mask = make_mask (self._mask, copy=1, flag=0)
-            self._shared_mask = 0
-
-    def _get_ctypes(self):
-        return self._data.ctypes
-
-    def _get_T(self):
-        if (self.ndim < 2):
-            return self
-        return self.transpose()
-
-    shape = property(_get_shape, _set_shape,
-           doc = 'tuple giving the shape of the array')
-
-    flat = property(_get_flat, _set_flat,
-           doc = 'Access array in flat form.')
-
-    real = property(_get_real, _set_real,
-           doc = 'Access the real part of the array')
-
-    imaginary = property(_get_imaginary, _set_imaginary,
-           doc = 'Access the imaginary part of the array')
-
-    imag = imaginary
-
-    ctypes = property(_get_ctypes, None, doc="ctypes")
-
-    T = property(_get_T, None, doc="get transpose")
-
-#end class MaskedArray
-
-array = MaskedArray
-
-def isMaskedArray (x):
-    "Is x a masked array, that is, an instance of MaskedArray?"
-    return isinstance(x, MaskedArray)
-
-isarray = isMaskedArray
-isMA = isMaskedArray  #backward compatibility
-
-def allclose (a, b, fill_value=1, rtol=1.e-5, atol=1.e-8):
-    """ Returns true if all components of a and b are equal
-        subject to given tolerances.
-        If fill_value is 1, masked values considered equal.
-        If fill_value is 0, masked values considered unequal.
-        The relative error rtol should be positive and << 1.0
-        The absolute error atol comes into play for those elements
-        of b that are very small or zero; it says how small a must be also.
-    """
-    m = mask_or(getmask(a), getmask(b))
-    d1 = filled(a)
-    d2 = filled(b)
-    x = filled(array(d1, copy=0, mask=m), fill_value).astype(float)
-    y = filled(array(d2, copy=0, mask=m), 1).astype(float)
-    d = umath.less_equal(umath.absolute(x-y), atol + rtol * umath.absolute(y))
-    return fromnumeric.alltrue(fromnumeric.ravel(d))
-
-def allequal (a, b, fill_value=1):
-    """
-        True if all entries of  a and b are equal, using
-        fill_value as a truth value where either or both are masked.
-    """
-    m = mask_or(getmask(a), getmask(b))
-    if m is nomask:
-        x = filled(a)
-        y = filled(b)
-        d = umath.equal(x, y)
-        return fromnumeric.alltrue(fromnumeric.ravel(d))
-    elif fill_value:
-        x = filled(a)
-        y = filled(b)
-        d = umath.equal(x, y)
-        dm = array(d, mask=m, copy=0)
-        return fromnumeric.alltrue(fromnumeric.ravel(filled(dm, 1)))
-    else:
-        return 0
-
-def masked_values (data, value, rtol=1.e-5, atol=1.e-8, copy=1):
-    """
-       masked_values(data, value, rtol=1.e-5, atol=1.e-8)
-       Create a masked array; mask is nomask if possible.
-       If copy==0, and otherwise possible, result
-       may share data values with original array.
-       Let d = filled(data, value). Returns d
-       masked where abs(data-value)<= atol + rtol * abs(value)
-       if d is of a floating point type. Otherwise returns
-       masked_object(d, value, copy)
-    """
-    abs = umath.absolute
-    d = filled(data, value)
-    if issubclass(d.dtype.type, numeric.floating):
-        m = umath.less_equal(abs(d-value), atol+rtol*abs(value))
-        m = make_mask(m, flag=1)
-        return array(d, mask = m, copy=copy,
-                      fill_value=value)
-    else:
-        return masked_object(d, value, copy=copy)
-
-def masked_object (data, value, copy=1):
-    "Create array masked where exactly data equal to value"
-    d = filled(data, value)
-    dm = make_mask(umath.equal(d, value), flag=1)
-    return array(d, mask=dm, copy=copy, fill_value=value)
-
-def arange(start, stop=None, step=1, dtype=None):
-    """Just like range() except it returns a array whose type can be specified
-    by the keyword argument dtype.
-    """
-    return array(numeric.arange(start, stop, step, dtype))
-
-arrayrange = arange
-
-def fromstring (s, t):
-    "Construct a masked array from a string. Result will have no mask."
-    return masked_array(numeric.fromstring(s, t))
-
-def left_shift (a, n):
-    "Left shift n bits"
-    m = getmask(a)
-    if m is nomask:
-        d = umath.left_shift(filled(a), n)
-        return masked_array(d)
-    else:
-        d = umath.left_shift(filled(a, 0), n)
-        return masked_array(d, m)
-
-def right_shift (a, n):
-    "Right shift n bits"
-    m = getmask(a)
-    if m is nomask:
-        d = umath.right_shift(filled(a), n)
-        return masked_array(d)
-    else:
-        d = umath.right_shift(filled(a, 0), n)
-        return masked_array(d, m)
-
-def resize (a, new_shape):
-    """resize(a, new_shape) returns a new array with the specified shape.
-    The original array's total size can be any size."""
-    m = getmask(a)
-    if m is not nomask:
-        m = fromnumeric.resize(m, new_shape)
-    result = array(fromnumeric.resize(filled(a), new_shape), mask=m)
-    result.set_fill_value(get_fill_value(a))
-    return result
-
-def repeat(a, repeats, axis=None):
-    """repeat elements of a repeats times along axis
-       repeats is a sequence of length a.shape[axis]
-       telling how many times to repeat each element.
-    """
-    af = filled(a)
-    if isinstance(repeats, types.IntType):
-        if axis is None:
-            num = af.size
-        else:
-            num = af.shape[axis]
-        repeats = tuple([repeats]*num)
-
-    m = getmask(a)
-    if m is not nomask:
-        m = fromnumeric.repeat(m, repeats, axis)
-    d = fromnumeric.repeat(af, repeats, axis)
-    result = masked_array(d, m)
-    result.set_fill_value(get_fill_value(a))
-    return result
-
-def identity(n):
-    """identity(n) returns the identity matrix of shape n x n.
-    """
-    return array(numeric.identity(n))
-
-def indices (dimensions, dtype=None):
-    """indices(dimensions,dtype=None) returns an array representing a grid
-    of indices with row-only, and column-only variation.
-    """
-    return array(numeric.indices(dimensions, dtype))
-
-def zeros (shape, dtype=float):
-    """zeros(n, dtype=float) =
-     an array of all zeros of the given length or shape."""
-    return array(numeric.zeros(shape, dtype))
-
-def ones (shape, dtype=float):
-    """ones(n, dtype=float) =
-     an array of all ones of the given length or shape."""
-    return array(numeric.ones(shape, dtype))
-
-def count (a, axis = None):
-    "Count of the non-masked elements in a, or along a certain axis."
-    a = masked_array(a)
-    return a.count(axis)
-
-def power (a, b, third=None):
-    "a**b"
-    if third is not None:
-        raise MAError, "3-argument power not supported."
-    ma = getmask(a)
-    mb = getmask(b)
-    m = mask_or(ma, mb)
-    fa = filled(a, 1)
-    fb = filled(b, 1)
-    if fb.dtype.char in typecodes["Integer"]:
-        return masked_array(umath.power(fa, fb), m)
-    md = make_mask(umath.less(fa, 0), flag=1)
-    m = mask_or(m, md)
-    if m is nomask:
-        return masked_array(umath.power(fa, fb))
-    else:
-        fa = numeric.where(m, 1, fa)
-        return masked_array(umath.power(fa, fb), m)
-
-def masked_array (a, mask=nomask, fill_value=None):
-    """masked_array(a, mask=nomask) =
-       array(a, mask=mask, copy=0, fill_value=fill_value)
-    """
-    return array(a, mask=mask, copy=0, fill_value=fill_value)
-
-def sum (target, axis=None, dtype=None):
-    if axis is None:
-        target = ravel(target)
-        axis = 0
-    return add.reduce(target, axis, dtype)
-
-def product (target, axis=None, dtype=None):
-    if axis is None:
-        target = ravel(target)
-        axis = 0
-    return multiply.reduce(target, axis, dtype)
-
-def average (a, axis=None, weights=None, returned = 0):
-    """average(a, axis=None, weights=None)
-       Computes average along indicated axis.
-       If axis is None, average over the entire array
-       Inputs can be integer or floating types; result is of type float.
-
-       If weights are given, result is sum(a*weights,axis=0)/(sum(weights,axis=0)*1.0)
-       weights must have a's shape or be the 1-d with length the size
-       of a in the given axis.
-
-       If returned, return a tuple: the result and the sum of the weights
-       or count of values. Results will have the same shape.
-
-       masked values in the weights will be set to 0.0
-    """
-    a = masked_array(a)
-    mask = a.mask
-    ash = a.shape
-    if ash == ():
-        ash = (1,)
-    if axis is None:
-        if mask is nomask:
-            if weights is None:
-                n = add.reduce(a.raw_data().ravel())
-                d = reduce(lambda x, y: x * y, ash, 1.0)
-            else:
-                w = filled(weights, 0.0).ravel()
-                n = umath.add.reduce(a.raw_data().ravel() * w)
-                d = umath.add.reduce(w)
-                del w
-        else:
-            if weights is None:
-                n = add.reduce(a.ravel())
-                w = fromnumeric.choose(mask, (1.0, 0.0)).ravel()
-                d = umath.add.reduce(w)
-                del w
-            else:
-                w = array(filled(weights, 0.0), float, mask=mask).ravel()
-                n = add.reduce(a.ravel() * w)
-                d = add.reduce(w)
-                del w
-    else:
-        if mask is nomask:
-            if weights is None:
-                d = ash[axis] * 1.0
-                n = umath.add.reduce(a.raw_data(), axis)
-            else:
-                w = filled(weights, 0.0)
-                wsh = w.shape
-                if wsh == ():
-                    wsh = (1,)
-                if wsh == ash:
-                    w = numeric.array(w, float, copy=0)
-                    n = add.reduce(a*w, axis)
-                    d = add.reduce(w, axis)
-                    del w
-                elif wsh == (ash[axis],):
-                    r = [newaxis]*len(ash)
-                    r[axis] = slice(None, None, 1)
-                    w = eval ("w["+ repr(tuple(r)) + "] * ones(ash, float)")
-                    n = add.reduce(a*w, axis)
-                    d = add.reduce(w, axis)
-                    del w, r
-                else:
-                    raise ValueError, 'average: weights wrong shape.'
-        else:
-            if weights is None:
-                n = add.reduce(a, axis)
-                w = numeric.choose(mask, (1.0, 0.0))
-                d = umath.add.reduce(w, axis)
-                del w
-            else:
-                w = filled(weights, 0.0)
-                wsh = w.shape
-                if wsh == ():
-                    wsh = (1,)
-                if wsh == ash:
-                    w = array(w, float, mask=mask, copy=0)
-                    n = add.reduce(a*w, axis)
-                    d = add.reduce(w, axis)
-                elif wsh == (ash[axis],):
-                    r = [newaxis]*len(ash)
-                    r[axis] = slice(None, None, 1)
-                    w = eval ("w["+ repr(tuple(r)) + "] * masked_array(ones(ash, float), mask)")
-                    n = add.reduce(a*w, axis)
-                    d = add.reduce(w, axis)
-                else:
-                    raise ValueError, 'average: weights wrong shape.'
-                del w
-    #print n, d, repr(mask), repr(weights)
-    if n is masked or d is masked: return masked
-    result = divide (n, d)
-    del n
-
-    if isinstance(result, MaskedArray):
-        result.unmask()
-        if returned:
-            if not isinstance(d, MaskedArray):
-                d = masked_array(d)
-            if not d.shape == result.shape:
-                d = ones(result.shape, float) * d
-            d.unmask()
-    if returned:
-        return result, d
-    else:
-        return result
-
-def where (condition, x, y):
-    """where(condition, x, y) is x where condition is nonzero, y otherwise.
-       condition must be convertible to an integer array.
-       Answer is always the shape of condition.
-       The type depends on x and y. It is integer if both x and y are
-       the value masked.
-    """
-    fc = filled(not_equal(condition, 0), 0)
-    xv = filled(x)
-    xm = getmask(x)
-    yv = filled(y)
-    ym = getmask(y)
-    d = numeric.choose(fc, (yv, xv))
-    md = numeric.choose(fc, (ym, xm))
-    m = getmask(condition)
-    m = make_mask(mask_or(m, md), copy=0, flag=1)
-    return masked_array(d, m)
-
-def choose (indices, t, out=None, mode='raise'):
-    "Returns array shaped like indices with elements chosen from t"
-    def fmask (x):
-        if x is masked: return 1
-        return filled(x)
-    def nmask (x):
-        if x is masked: return 1
-        m = getmask(x)
-        if m is nomask: return 0
-        return m
-    c = filled(indices, 0)
-    masks = [nmask(x) for x in t]
-    a = [fmask(x) for x in t]
-    d = numeric.choose(c, a)
-    m = numeric.choose(c, masks)
-    m = make_mask(mask_or(m, getmask(indices)), copy=0, flag=1)
-    return masked_array(d, m)
-
-def masked_where(condition, x, copy=1):
-    """Return x as an array masked where condition is true.
-       Also masked where x or condition masked.
-    """
-    cm = filled(condition,1)
-    m = mask_or(getmask(x), cm)
-    return array(filled(x), copy=copy, mask=m)
-
-def masked_greater(x, value, copy=1):
-    "masked_greater(x, value) = x masked where x > value"
-    return masked_where(greater(x, value), x, copy)
-
-def masked_greater_equal(x, value, copy=1):
-    "masked_greater_equal(x, value) = x masked where x >= value"
-    return masked_where(greater_equal(x, value), x, copy)
-
-def masked_less(x, value, copy=1):
-    "masked_less(x, value) = x masked where x < value"
-    return masked_where(less(x, value), x, copy)
-
-def masked_less_equal(x, value, copy=1):
-    "masked_less_equal(x, value) = x masked where x <= value"
-    return masked_where(less_equal(x, value), x, copy)
-
-def masked_not_equal(x, value, copy=1):
-    "masked_not_equal(x, value) = x masked where x != value"
-    d = filled(x, 0)
-    c = umath.not_equal(d, value)
-    m = mask_or(c, getmask(x))
-    return array(d, mask=m, copy=copy)
-
-def masked_equal(x, value, copy=1):
-    """masked_equal(x, value) = x masked where x == value
-       For floating point consider masked_values(x, value) instead.
-    """
-    d = filled(x, 0)
-    c = umath.equal(d, value)
-    m = mask_or(c, getmask(x))
-    return array(d, mask=m, copy=copy)
-
-def masked_inside(x, v1, v2, copy=1):
-    """x with mask of all values of x that are inside [v1,v2]
-       v1 and v2 can be given in either order.
-    """
-    if v2 < v1:
-        t = v2
-        v2 = v1
-        v1 = t
-    d = filled(x, 0)
-    c = umath.logical_and(umath.less_equal(d, v2), umath.greater_equal(d, v1))
-    m = mask_or(c, getmask(x))
-    return array(d, mask = m, copy=copy)
-
-def masked_outside(x, v1, v2, copy=1):
-    """x with mask of all values of x that are outside [v1,v2]
-       v1 and v2 can be given in either order.
-    """
-    if v2 < v1:
-        t = v2
-        v2 = v1
-        v1 = t
-    d = filled(x, 0)
-    c = umath.logical_or(umath.less(d, v1), umath.greater(d, v2))
-    m = mask_or(c, getmask(x))
-    return array(d, mask = m, copy=copy)
-
-def reshape (a, *newshape):
-    "Copy of a with a new shape."
-    m = getmask(a)
-    d = filled(a).reshape(*newshape)
-    if m is nomask:
-        return masked_array(d)
-    else:
-        return masked_array(d, mask=numeric.reshape(m, *newshape))
-
-def ravel (a):
-    "a as one-dimensional, may share data and mask"
-    m = getmask(a)
-    d = fromnumeric.ravel(filled(a))
-    if m is nomask:
-        return masked_array(d)
-    else:
-        return masked_array(d, mask=numeric.ravel(m))
-
-def concatenate (arrays, axis=0):
-    "Concatenate the arrays along the given axis"
-    d = []
-    for x in arrays:
-        d.append(filled(x))
-    d = numeric.concatenate(d, axis)
-    for x in arrays:
-        if getmask(x) is not nomask: break
-    else:
-        return masked_array(d)
-    dm = []
-    for x in arrays:
-        dm.append(getmaskarray(x))
-    dm = numeric.concatenate(dm, axis)
-    return masked_array(d, mask=dm)
-
-def swapaxes (a, axis1, axis2):
-    m = getmask(a)
-    d = masked_array(a).data
-    if m is nomask:
-        return masked_array(data=numeric.swapaxes(d, axis1, axis2))
-    else:
-        return masked_array(data=numeric.swapaxes(d, axis1, axis2),
-                            mask=numeric.swapaxes(m, axis1, axis2),)
-
-
-def take (a, indices, axis=None, out=None, mode='raise'):
-    "returns selection of items from a."
-    m = getmask(a)
-    # d = masked_array(a).raw_data()
-    d = masked_array(a).data
-    if m is nomask:
-        return masked_array(numeric.take(d, indices, axis))
-    else:
-        return masked_array(numeric.take(d, indices, axis),
-                     mask = numeric.take(m, indices, axis))
-
-def transpose(a, axes=None):
-    "reorder dimensions per tuple axes"
-    m = getmask(a)
-    d = filled(a)
-    if m is nomask:
-        return masked_array(numeric.transpose(d, axes))
-    else:
-        return masked_array(numeric.transpose(d, axes),
-                     mask = numeric.transpose(m, axes))
-
-
-def put(a, indices, values, mode='raise'):
-    """sets storage-indexed locations to corresponding values.
-
-    Values and indices are filled if necessary.
-
-    """
-    d = a.raw_data()
-    ind = filled(indices)
-    v = filled(values)
-    numeric.put (d, ind, v)
-    m = getmask(a)
-    if m is not nomask:
-        a.unshare_mask()
-        numeric.put(a.raw_mask(), ind, 0)
-
-def putmask(a, mask, values):
-    "putmask(a, mask, values) sets a where mask is true."
-    if mask is nomask:
-        return
-    numeric.putmask(a.raw_data(), mask, values)
-    m = getmask(a)
-    if m is nomask: return
-    a.unshare_mask()
-    numeric.putmask(a.raw_mask(), mask, 0)
-
-def inner(a, b):
-    """inner(a,b) returns the dot product of two arrays, which has
-    shape a.shape[:-1] + b.shape[:-1] with elements computed by summing the
-    product of the elements from the last dimensions of a and b.
-    Masked elements are replace by zeros.
-    """
-    fa = filled(a, 0)
-    fb = filled(b, 0)
-    if len(fa.shape) == 0: fa.shape = (1,)
-    if len(fb.shape) == 0: fb.shape = (1,)
-    return masked_array(numeric.inner(fa, fb))
-
-innerproduct = inner
-
-def outer(a, b):
-    """outer(a,b) = {a[i]*b[j]}, has shape (len(a),len(b))"""
-    fa = filled(a, 0).ravel()
-    fb = filled(b, 0).ravel()
-    d = numeric.outer(fa, fb)
-    ma = getmask(a)
-    mb = getmask(b)
-    if ma is nomask and mb is nomask:
-        return masked_array(d)
-    ma = getmaskarray(a)
-    mb = getmaskarray(b)
-    m = make_mask(1-numeric.outer(1-ma, 1-mb), copy=0)
-    return masked_array(d, m)
-
-outerproduct = outer
-
-def dot(a, b):
-    """dot(a,b) returns matrix-multiplication between a and b.  The product-sum
-    is over the last dimension of a and the second-to-last dimension of b.
-    Masked values are replaced by zeros. See also innerproduct.
-    """
-    return innerproduct(filled(a, 0), numeric.swapaxes(filled(b, 0), -1, -2))
-
-def compress(condition, x, dimension=-1, out=None):
-    """Select those parts of x for which condition is true.
-       Masked values in condition are considered false.
-    """
-    c = filled(condition, 0)
-    m = getmask(x)
-    if m is not nomask:
-        m = numeric.compress(c, m, dimension)
-    d = numeric.compress(c, filled(x), dimension)
-    return masked_array(d, m)
-
-class _minimum_operation:
-    "Object to calculate minima"
-    def __init__ (self):
-        """minimum(a, b) or minimum(a)
-           In one argument case returns the scalar minimum.
-        """
-        pass
-
-    def __call__ (self, a, b=None):
-        "Execute the call behavior."
-        if b is None:
-            m = getmask(a)
-            if m is nomask:
-                d = amin(filled(a).ravel())
-                return d
-            ac = a.compressed()
-            if len(ac) == 0:
-                return masked
-            else:
-                return amin(ac.raw_data())
-        else:
-            return where(less(a, b), a, b)
-
-    def reduce (self, target, axis=0):
-        """Reduce target along the given axis."""
-        m = getmask(target)
-        if m is nomask:
-            t = filled(target)
-            return masked_array (umath.minimum.reduce (t, axis))
-        else:
-            t = umath.minimum.reduce(filled(target, minimum_fill_value(target)), axis)
-            m = umath.logical_and.reduce(m, axis)
-            return masked_array(t, m, get_fill_value(target))
-
-    def outer (self, a, b):
-        "Return the function applied to the outer product of a and b."
-        ma = getmask(a)
-        mb = getmask(b)
-        if ma is nomask and mb is nomask:
-            m = nomask
-        else:
-            ma = getmaskarray(a)
-            mb = getmaskarray(b)
-            m = logical_or.outer(ma, mb)
-        d = umath.minimum.outer(filled(a), filled(b))
-        return masked_array(d, m)
-
-minimum = _minimum_operation ()
-
-class _maximum_operation:
-    "Object to calculate maxima"
-    def __init__ (self):
-        """maximum(a, b) or maximum(a)
-           In one argument case returns the scalar maximum.
-        """
-        pass
-
-    def __call__ (self, a, b=None):
-        "Execute the call behavior."
-        if b is None:
-            m = getmask(a)
-            if m is nomask:
-                d = amax(filled(a).ravel())
-                return d
-            ac = a.compressed()
-            if len(ac) == 0:
-                return masked
-            else:
-                return amax(ac.raw_data())
-        else:
-            return where(greater(a, b), a, b)
-
-    def reduce (self, target, axis=0):
-        """Reduce target along the given axis."""
-        m = getmask(target)
-        if m is nomask:
-            t = filled(target)
-            return masked_array (umath.maximum.reduce (t, axis))
-        else:
-            t = umath.maximum.reduce(filled(target, maximum_fill_value(target)), axis)
-            m = umath.logical_and.reduce(m, axis)
-            return masked_array(t, m, get_fill_value(target))
-
-    def outer (self, a, b):
-        "Return the function applied to the outer product of a and b."
-        ma = getmask(a)
-        mb = getmask(b)
-        if ma is nomask and mb is nomask:
-            m = nomask
-        else:
-            ma = getmaskarray(a)
-            mb = getmaskarray(b)
-            m = logical_or.outer(ma, mb)
-        d = umath.maximum.outer(filled(a), filled(b))
-        return masked_array(d, m)
-
-maximum = _maximum_operation ()
-
-def sort (x, axis = -1, fill_value=None):
-    """If x does not have a mask, return a masked array formed from the
-       result of numeric.sort(x, axis).
-       Otherwise, fill x with fill_value. Sort it.
-       Set a mask where the result is equal to fill_value.
-       Note that this may have unintended consequences if the data contains the
-       fill value at a non-masked site.
-
-       If fill_value is not given the default fill value for x's type will be
-       used.
-    """
-    if fill_value is None:
-        fill_value = default_fill_value (x)
-    d = filled(x, fill_value)
-    s = fromnumeric.sort(d, axis)
-    if getmask(x) is nomask:
-        return masked_array(s)
-    return masked_values(s, fill_value, copy=0)
-
-def diagonal(a, k = 0, axis1=0, axis2=1):
-    """diagonal(a,k=0,axis1=0, axis2=1) = the k'th diagonal of a"""
-    d = fromnumeric.diagonal(filled(a), k, axis1, axis2)
-    m = getmask(a)
-    if m is nomask:
-        return masked_array(d, m)
-    else:
-        return masked_array(d, fromnumeric.diagonal(m, k, axis1, axis2))
-
-def trace (a, offset=0, axis1=0, axis2=1, dtype=None, out=None):
-    """trace(a,offset=0, axis1=0, axis2=1) returns the sum along diagonals
-    (defined by the last two dimenions) of the array.
-    """
-    return diagonal(a, offset, axis1, axis2).sum(dtype=dtype)
-
-def argsort (x, axis = -1, out=None, fill_value=None):
-    """Treating masked values as if they have the value fill_value,
-       return sort indices for sorting along given axis.
-       if fill_value is None, use get_fill_value(x)
-       Returns a numpy array.
-    """
-    d = filled(x, fill_value)
-    return fromnumeric.argsort(d, axis)
-
-def argmin (x, axis = -1, out=None, fill_value=None):
-    """Treating masked values as if they have the value fill_value,
-       return indices for minimum values along given axis.
-       if fill_value is None, use get_fill_value(x).
-       Returns a numpy array if x has more than one dimension.
-       Otherwise, returns a scalar index.
-    """
-    d = filled(x, fill_value)
-    return fromnumeric.argmin(d, axis)
-
-def argmax (x, axis = -1, out=None, fill_value=None):
-    """Treating masked values as if they have the value fill_value,
-       return sort indices for maximum along given axis.
-       if fill_value is None, use -get_fill_value(x) if it exists.
-       Returns a numpy array if x has more than one dimension.
-       Otherwise, returns a scalar index.
-    """
-    if fill_value is None:
-        fill_value = default_fill_value (x)
-        try:
-            fill_value = - fill_value
-        except:
-            pass
-    d = filled(x, fill_value)
-    return fromnumeric.argmax(d, axis)
-
-def fromfunction (f, s):
-    """apply f to s to create array as in umath."""
-    return masked_array(numeric.fromfunction(f, s))
-
-def asarray(data, dtype=None):
-    """asarray(data, dtype) = array(data, dtype, copy=0)
-    """
-    if isinstance(data, MaskedArray) and \
-        (dtype is None or dtype == data.dtype):
-        return data
-    return array(data, dtype=dtype, copy=0)
-
-# Add methods to support ndarray interface
-# XXX: I is better to to change the masked_*_operation adaptors
-# XXX: to wrap ndarray methods directly to create ma.array methods.
-from types import MethodType
-def _m(f):
-    return MethodType(f, None, array)
-def not_implemented(*args, **kwds):
-    raise NotImplementedError, "not yet implemented for numpy.ma arrays"
-array.all = _m(alltrue)
-array.any = _m(sometrue)
-array.argmax = _m(argmax)
-array.argmin = _m(argmin)
-array.argsort = _m(argsort)
-array.base = property(_m(not_implemented))
-array.byteswap = _m(not_implemented)
-
-def _choose(self, *args, **kwds):
-    return choose(self, args)
-array.choose = _m(_choose)
-del _choose
-
-def _clip(self,a_min,a_max,out=None):
-    return MaskedArray(data = self.data.clip(asarray(a_min).data,
-                                             asarray(a_max).data),
-                       mask = mask_or(self.mask,
-                                      mask_or(getmask(a_min),getmask(a_max))))
-array.clip = _m(_clip)
-
-def _compress(self, cond, axis=None, out=None):
-    return compress(cond, self, axis)
-array.compress = _m(_compress)
-del _compress
-
-array.conj = array.conjugate = _m(conjugate)
-array.copy = _m(not_implemented)
-
-def _cumprod(self, axis=None, dtype=None, out=None):
-    m = self.mask
-    if m is not nomask:
-        m = umath.logical_or.accumulate(self.mask, axis)
-    return MaskedArray(data = self.filled(1).cumprod(axis, dtype), mask=m)
-array.cumprod = _m(_cumprod)
-
-def _cumsum(self, axis=None, dtype=None, out=None):
-    m = self.mask
-    if m is not nomask:
-        m = umath.logical_or.accumulate(self.mask, axis)
-    return MaskedArray(data=self.filled(0).cumsum(axis, dtype), mask=m)
-array.cumsum = _m(_cumsum)
-
-array.diagonal = _m(diagonal)
-array.dump = _m(not_implemented)
-array.dumps = _m(not_implemented)
-array.fill = _m(not_implemented)
-array.flags = property(_m(not_implemented))
-array.flatten = _m(ravel)
-array.getfield = _m(not_implemented)
-
-def _max(a, axis=None, out=None):
-    if out is not None:
-        raise TypeError("Output arrays Unsupported for masked arrays")
-    if axis is None:
-        return maximum(a)
-    else:
-        return maximum.reduce(a, axis)
-array.max = _m(_max)
-del _max
-def _min(a, axis=None, out=None):
-    if out is not None:
-        raise TypeError("Output arrays Unsupported for masked arrays")
-    if axis is None:
-        return minimum(a)
-    else:
-        return minimum.reduce(a, axis)
-array.min = _m(_min)
-del _min
-array.mean = _m(average)
-array.nbytes = property(_m(not_implemented))
-array.newbyteorder = _m(not_implemented)
-array.nonzero = _m(nonzero)
-array.prod = _m(product)
-
-def _ptp(a,axis=None,out=None):
-    return a.max(axis,out)-a.min(axis)
-array.ptp = _m(_ptp)
-array.repeat = _m(repeat)
-array.resize = _m(resize)
-array.searchsorted = _m(not_implemented)
-array.setfield = _m(not_implemented)
-array.setflags = _m(not_implemented)
-array.sort = _m(not_implemented)  # NB: ndarray.sort is inplace
-
-def _squeeze(self):
-    try:
-        result = MaskedArray(data = self.data.squeeze(),
-                             mask = self.mask.squeeze())
-    except AttributeError:
-        result = _wrapit(self, 'squeeze')
-    return result
-array.squeeze = _m(_squeeze)
-
-array.strides = property(_m(not_implemented))
-array.sum = _m(sum)
-def _swapaxes(self,axis1,axis2):
-    return MaskedArray(data = self.data.swapaxes(axis1, axis2),
-                       mask = self.mask.swapaxes(axis1, axis2))
-array.swapaxes = _m(_swapaxes)
-array.take = _m(take)
-array.tofile = _m(not_implemented)
-array.trace = _m(trace)
-array.transpose = _m(transpose)
-
-def _var(self,axis=None,dtype=None, out=None):
-    if axis is None:
-        return numeric.asarray(self.compressed()).var()
-    a = self.swapaxes(axis,0)
-    a = a - a.mean(axis=0)
-    a *= a
-    a /= a.count(axis=0)
-    return a.swapaxes(0,axis).sum(axis)
-def _std(self,axis=None, dtype=None, out=None):
-    return (self.var(axis,dtype))**0.5
-array.var = _m(_var)
-array.std = _m(_std)
-
-array.view =  _m(not_implemented)
-array.round = _m(around)
-del _m, MethodType, not_implemented
-
-
-masked = MaskedArray(0, int, mask=1)

Deleted: trunk/numpy/core/tests/test_ma.py
===================================================================
--- trunk/numpy/core/tests/test_ma.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/core/tests/test_ma.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,873 +0,0 @@
-import numpy
-import types, time
-from numpy.core.ma import *
-from numpy.core.numerictypes import float32
-from numpy.testing import NumpyTestCase, NumpyTest
-pi = numpy.pi
-def eq(v,w, msg=''):
-    result = allclose(v,w)
-    if not result:
-        print """Not eq:%s
-%s
-----
-%s"""% (msg, str(v), str(w))
-    return result
-
-class TestMa(NumpyTestCase):
-    def __init__(self, *args, **kwds):
-        NumpyTestCase.__init__(self, *args, **kwds)
-        self.setUp()
-
-    def setUp (self):
-        x=numpy.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
-        y=numpy.array([5.,0.,3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
-        a10 = 10.
-        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 ,0, 1]
-        xm = array(x, mask=m1)
-        ym = array(y, mask=m2)
-        z = numpy.array([-.5, 0., .5, .8])
-        zm = array(z, mask=[0,1,0,0])
-        xf = numpy.where(m1, 1.e+20, x)
-        s = x.shape
-        xm.set_fill_value(1.e+20)
-        self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf, s)
-
-    def check_testBasic1d(self):
-        "Test of basic array creation and properties in 1 dimension."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        self.failIf(isMaskedArray(x))
-        self.failUnless(isMaskedArray(xm))
-        self.assertEqual(shape(xm), s)
-        self.assertEqual(xm.shape, s)
-        self.assertEqual(xm.dtype, x.dtype)
-        self.assertEqual( xm.size , reduce(lambda x,y:x*y, s))
-        self.assertEqual(count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
-        self.failUnless(eq(xm, xf))
-        self.failUnless(eq(filled(xm, 1.e20), xf))
-        self.failUnless(eq(x, xm))
-
-    def check_testBasic2d(self):
-        "Test of basic array creation and properties in 2 dimensions."
-        for s in [(4,3), (6,2)]:
-            (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-            x.shape = s
-            y.shape = s
-            xm.shape = s
-            ym.shape = s
-            xf.shape = s
-
-            self.failIf(isMaskedArray(x))
-            self.failUnless(isMaskedArray(xm))
-            self.assertEqual(shape(xm), s)
-            self.assertEqual(xm.shape, s)
-            self.assertEqual( xm.size , reduce(lambda x,y:x*y, s))
-            self.assertEqual( count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
-            self.failUnless(eq(xm, xf))
-            self.failUnless(eq(filled(xm, 1.e20), xf))
-            self.failUnless(eq(x, xm))
-            self.setUp()
-
-    def check_testArithmetic (self):
-        "Test of basic arithmetic."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        a2d = array([[1,2],[0,4]])
-        a2dm = masked_array(a2d, [[0,0],[1,0]])
-        self.failUnless(eq (a2d * a2d, a2d * a2dm))
-        self.failUnless(eq (a2d + a2d, a2d + a2dm))
-        self.failUnless(eq (a2d - a2d, a2d - a2dm))
-        for s in [(12,), (4,3), (2,6)]:
-            x = x.reshape(s)
-            y = y.reshape(s)
-            xm = xm.reshape(s)
-            ym = ym.reshape(s)
-            xf = xf.reshape(s)
-            self.failUnless(eq(-x, -xm))
-            self.failUnless(eq(x + y, xm + ym))
-            self.failUnless(eq(x - y, xm - ym))
-            self.failUnless(eq(x * y, xm * ym))
-            olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.failUnless(eq(x / y, xm / ym))
-            numpy.seterr(**olderr)
-            self.failUnless(eq(a10 + y, a10 + ym))
-            self.failUnless(eq(a10 - y, a10 - ym))
-            self.failUnless(eq(a10 * y, a10 * ym))
-            olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.failUnless(eq(a10 / y, a10 / ym))
-            numpy.seterr(**olderr)
-            self.failUnless(eq(x + a10, xm + a10))
-            self.failUnless(eq(x - a10, xm - a10))
-            self.failUnless(eq(x * a10, xm * a10))
-            self.failUnless(eq(x / a10, xm / a10))
-            self.failUnless(eq(x**2, xm**2))
-            self.failUnless(eq(abs(x)**2.5, abs(xm) **2.5))
-            self.failUnless(eq(x**y, xm**ym))
-            self.failUnless(eq(numpy.add(x,y), add(xm, ym)))
-            self.failUnless(eq(numpy.subtract(x,y), subtract(xm, ym)))
-            self.failUnless(eq(numpy.multiply(x,y), multiply(xm, ym)))
-            olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.failUnless(eq(numpy.divide(x,y), divide(xm, ym)))
-            numpy.seterr(**olderr)
-
-
-    def check_testMixedArithmetic(self):
-        na = numpy.array([1])
-        ma = array([1])
-        self.failUnless(isinstance(na + ma, MaskedArray))
-        self.failUnless(isinstance(ma + na, MaskedArray))
-
-    def check_testUfuncs1 (self):
-        "Test various functions such as sin, cos."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        self.failUnless (eq(numpy.cos(x), cos(xm)))
-        self.failUnless (eq(numpy.cosh(x), cosh(xm)))
-        self.failUnless (eq(numpy.sin(x), sin(xm)))
-        self.failUnless (eq(numpy.sinh(x), sinh(xm)))
-        self.failUnless (eq(numpy.tan(x), tan(xm)))
-        self.failUnless (eq(numpy.tanh(x), tanh(xm)))
-        olderr = numpy.seterr(divide='ignore', invalid='ignore')
-        self.failUnless (eq(numpy.sqrt(abs(x)), sqrt(xm)))
-        self.failUnless (eq(numpy.log(abs(x)), log(xm)))
-        self.failUnless (eq(numpy.log10(abs(x)), log10(xm)))
-        numpy.seterr(**olderr)
-        self.failUnless (eq(numpy.exp(x), exp(xm)))
-        self.failUnless (eq(numpy.arcsin(z), arcsin(zm)))
-        self.failUnless (eq(numpy.arccos(z), arccos(zm)))
-        self.failUnless (eq(numpy.arctan(z), arctan(zm)))
-        self.failUnless (eq(numpy.arctan2(x, y), arctan2(xm, ym)))
-        self.failUnless (eq(numpy.absolute(x), absolute(xm)))
-        self.failUnless (eq(numpy.equal(x,y), equal(xm, ym)))
-        self.failUnless (eq(numpy.not_equal(x,y), not_equal(xm, ym)))
-        self.failUnless (eq(numpy.less(x,y), less(xm, ym)))
-        self.failUnless (eq(numpy.greater(x,y), greater(xm, ym)))
-        self.failUnless (eq(numpy.less_equal(x,y), less_equal(xm, ym)))
-        self.failUnless (eq(numpy.greater_equal(x,y), greater_equal(xm, ym)))
-        self.failUnless (eq(numpy.conjugate(x), conjugate(xm)))
-        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((xm,ym))))
-        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((x,y))))
-        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((xm,y))))
-        self.failUnless (eq(numpy.concatenate((x,y,x)), concatenate((x,ym,x))))
-
-    def check_xtestCount (self):
-        "Test count"
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        self.failUnless( isinstance(count(ott), types.IntType))
-        self.assertEqual(3, count(ott))
-        self.assertEqual(1, count(1))
-        self.failUnless (eq(0, array(1,mask=[1])))
-        ott=ott.reshape((2,2))
-        assert isMaskedArray(count(ott,0))
-        assert isinstance(count(ott), types.IntType)
-        self.failUnless (eq(3, count(ott)))
-        assert getmask(count(ott,0)) is nomask
-        self.failUnless (eq([1,2],count(ott,0)))
-
-    def check_testMinMax (self):
-        "Test minimum and maximum."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        xr = numpy.ravel(x) #max doesn't work if shaped
-        xmr = ravel(xm)
-        self.failUnless (eq(max(xr), maximum(xmr))) #true because of careful selection of data
-        self.failUnless (eq(min(xr), minimum(xmr))) #true because of careful selection of data
-
-    def check_testAddSumProd (self):
-        "Test add, sum, product."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        self.failUnless (eq(numpy.add.reduce(x), add.reduce(x)))
-        self.failUnless (eq(numpy.add.accumulate(x), add.accumulate(x)))
-        self.failUnless (eq(4, sum(array(4),axis=0)))
-        self.failUnless (eq(4, sum(array(4), axis=0)))
-        self.failUnless (eq(numpy.sum(x,axis=0), sum(x,axis=0)))
-        self.failUnless (eq(numpy.sum(filled(xm,0),axis=0), sum(xm,axis=0)))
-        self.failUnless (eq(numpy.sum(x,0), sum(x,0)))
-        self.failUnless (eq(numpy.product(x,axis=0), product(x,axis=0)))
-        self.failUnless (eq(numpy.product(x,0), product(x,0)))
-        self.failUnless (eq(numpy.product(filled(xm,1),axis=0), product(xm,axis=0)))
-        if len(s) > 1:
-            self.failUnless (eq(numpy.concatenate((x,y),1), concatenate((xm,ym),1)))
-            self.failUnless (eq(numpy.add.reduce(x,1), add.reduce(x,1)))
-            self.failUnless (eq(numpy.sum(x,1), sum(x,1)))
-            self.failUnless (eq(numpy.product(x,1), product(x,1)))
-
-
-    def check_testCI(self):
-        "Test of conversions and indexing"
-        x1 = numpy.array([1,2,4,3])
-        x2 = array(x1, mask = [1,0,0,0])
-        x3 = array(x1, mask = [0,1,0,1])
-        x4 = array(x1)
-    # test conversion to strings
-        junk, garbage = str(x2), repr(x2)
-        assert eq(numpy.sort(x1),sort(x2, fill_value=0))
-    # tests of indexing
-        assert type(x2[1]) is type(x1[1])
-        assert x1[1] == x2[1]
-        assert x2[0] is masked
-        assert eq(x1[2],x2[2])
-        assert eq(x1[2:5],x2[2:5])
-        assert eq(x1[:],x2[:])
-        assert eq(x1[1:], x3[1:])
-        x1[2]=9
-        x2[2]=9
-        assert eq(x1,x2)
-        x1[1:3] = 99
-        x2[1:3] = 99
-        assert eq(x1,x2)
-        x2[1] = masked
-        assert eq(x1,x2)
-        x2[1:3]=masked
-        assert eq(x1,x2)
-        x2[:] = x1
-        x2[1] = masked
-        assert allequal(getmask(x2),array([0,1,0,0]))
-        x3[:] = masked_array([1,2,3,4],[0,1,1,0])
-        assert allequal(getmask(x3), array([0,1,1,0]))
-        x4[:] = masked_array([1,2,3,4],[0,1,1,0])
-        assert allequal(getmask(x4), array([0,1,1,0]))
-        assert allequal(x4, array([1,2,3,4]))
-        x1 = numpy.arange(5)*1.0
-        x2 = masked_values(x1, 3.0)
-        assert eq(x1,x2)
-        assert allequal(array([0,0,0,1,0],MaskType), x2.mask)
-        assert eq(3.0, x2.fill_value())
-        x1 = array([1,'hello',2,3],object)
-        x2 = numpy.array([1,'hello',2,3],object)
-        s1 = x1[1]
-        s2 = x2[1]
-        self.assertEqual(type(s2), str)
-        self.assertEqual(type(s1), str)
-        self.assertEqual(s1, s2)
-        assert x1[1:1].shape == (0,)
-
-    def check_testCopySize(self):
-        "Tests of some subtle points of copying and sizing."
-        n = [0,0,1,0,0]
-        m = make_mask(n)
-        m2 = make_mask(m)
-        self.failUnless(m is m2)
-        m3 = make_mask(m, copy=1)
-        self.failUnless(m is not m3)
-
-        x1 = numpy.arange(5)
-        y1 = array(x1, mask=m)
-        self.failUnless( y1.raw_data() is not x1)
-        self.failUnless( allequal(x1,y1.raw_data()))
-        self.failUnless( y1.mask is m)
-
-        y1a = array(y1, copy=0)
-        self.failUnless( y1a.raw_data() is y1.raw_data())
-        self.failUnless( y1a.mask is y1.mask)
-
-        y2 = array(x1, mask=m, copy=0)
-        self.failUnless( y2.raw_data() is x1)
-        self.failUnless( y2.mask is m)
-        self.failUnless( y2[2] is masked)
-        y2[2]=9
-        self.failUnless( y2[2] is not masked)
-        self.failUnless( y2.mask is not m)
-        self.failUnless( allequal(y2.mask, 0))
-
-        y3 = array(x1*1.0, mask=m)
-        self.failUnless(filled(y3).dtype is (x1*1.0).dtype)
-
-        x4 = arange(4)
-        x4[2] = masked
-        y4 = resize(x4, (8,))
-        self.failUnless( eq(concatenate([x4,x4]), y4))
-        self.failUnless( eq(getmask(y4),[0,0,1,0,0,0,1,0]))
-        y5 = repeat(x4, (2,2,2,2), axis=0)
-        self.failUnless( eq(y5, [0,0,1,1,2,2,3,3]))
-        y6 = repeat(x4, 2, axis=0)
-        self.failUnless( eq(y5, y6))
-
-    def check_testPut(self):
-        "Test of put"
-        d = arange(5)
-        n = [0,0,0,1,1]
-        m = make_mask(n)
-        x = array(d, mask = m)
-        self.failUnless( x[3] is masked)
-        self.failUnless( x[4] is masked)
-        x[[1,4]] = [10,40]
-        self.failUnless( x.mask is not m)
-        self.failUnless( x[3] is masked)
-        self.failUnless( x[4] is not masked)
-        self.failUnless( eq(x, [0,10,2,-1,40]))
-
-        x = array(d, mask = m)
-        x.put([-1,100,200])
-        self.failUnless( eq(x, [-1,100,200,0,0]))
-        self.failUnless( x[3] is masked)
-        self.failUnless( x[4] is masked)
-
-        x = array(d, mask = m)
-        x.putmask([30,40])
-        self.failUnless( eq(x, [0,1,2,30,40]))
-        self.failUnless( x.mask is nomask)
-
-        x = array(d, mask = m)
-        y = x.compressed()
-        z = array(x, mask = m)
-        z.put(y)
-        assert eq (x, z)
-
-    def check_testMaPut(self):
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]
-        i = numpy.nonzero(m)[0]
-        putmask(xm, m, z)
-        assert take(xm, i,axis=0) == z
-        put(ym, i, zm)
-        assert take(ym, i,axis=0) == zm
-
-    def check_testOddFeatures(self):
-        "Test of other odd features"
-        x = arange(20); x=x.reshape(4,5)
-        x.flat[5] = 12
-        assert x[1,0] == 12
-        z = x + 10j * x
-        assert eq(z.real, x)
-        assert eq(z.imag, 10*x)
-        assert eq((z*conjugate(z)).real, 101*x*x)
-        z.imag[...] = 0.0
-
-        x = arange(10)
-        x[3] = masked
-        assert str(x[3]) == str(masked)
-        c = x >= 8
-        assert count(where(c,masked,masked)) == 0
-        assert shape(where(c,masked,masked)) == c.shape
-        z = where(c , x, masked)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is masked
-        assert z[7] is masked
-        assert z[8] is not masked
-        assert z[9] is not masked
-        assert eq(x,z)
-        z = where(c , masked, x)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is not masked
-        assert z[7] is not masked
-        assert z[8] is masked
-        assert z[9] is masked
-        z = masked_where(c, x)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is not masked
-        assert z[7] is not masked
-        assert z[8] is masked
-        assert z[9] is masked
-        assert eq(x,z)
-        x = array([1.,2.,3.,4.,5.])
-        c = array([1,1,1,0,0])
-        x[2] = masked
-        z = where(c, x, -x)
-        assert eq(z, [1.,2.,0., -4., -5])
-        c[0] = masked
-        z = where(c, x, -x)
-        assert eq(z, [1.,2.,0., -4., -5])
-        assert z[0] is masked
-        assert z[1] is not masked
-        assert z[2] is masked
-        assert eq(masked_where(greater(x, 2), x), masked_greater(x,2))
-        assert eq(masked_where(greater_equal(x, 2), x), masked_greater_equal(x,2))
-        assert eq(masked_where(less(x, 2), x), masked_less(x,2))
-        assert eq(masked_where(less_equal(x, 2), x), masked_less_equal(x,2))
-        assert eq(masked_where(not_equal(x, 2), x), masked_not_equal(x,2))
-        assert eq(masked_where(equal(x, 2), x), masked_equal(x,2))
-        assert eq(masked_where(not_equal(x,2), x), masked_not_equal(x,2))
-        assert eq(masked_inside(range(5), 1, 3), [0, 199, 199, 199, 4])
-        assert eq(masked_outside(range(5), 1, 3),[199,1,2,3,199])
-        assert eq(masked_inside(array(range(5), mask=[1,0,0,0,0]), 1, 3).mask, [1,1,1,1,0])
-        assert eq(masked_outside(array(range(5), mask=[0,1,0,0,0]), 1, 3).mask, [1,1,0,0,1])
-        assert eq(masked_equal(array(range(5), mask=[1,0,0,0,0]), 2).mask, [1,0,1,0,0])
-        assert eq(masked_not_equal(array([2,2,1,2,1], mask=[1,0,0,0,0]), 2).mask, [1,0,1,0,1])
-        assert eq(masked_where([1,1,0,0,0], [1,2,3,4,5]), [99,99,3,4,5])
-        atest = ones((10,10,10), dtype=float32)
-        btest = zeros(atest.shape, MaskType)
-        ctest = masked_where(btest,atest)
-        assert eq(atest,ctest)
-        z = choose(c, (-x, x))
-        assert eq(z, [1.,2.,0., -4., -5])
-        assert z[0] is masked
-        assert z[1] is not masked
-        assert z[2] is masked
-        x = arange(6)
-        x[5] = masked
-        y = arange(6)*10
-        y[2]= masked
-        c = array([1,1,1,0,0,0], mask=[1,0,0,0,0,0])
-        cm = c.filled(1)
-        z = where(c,x,y)
-        zm = where(cm,x,y)
-        assert eq(z, zm)
-        assert getmask(zm) is nomask
-        assert eq(zm, [0,1,2,30,40,50])
-        z = where(c, masked, 1)
-        assert eq(z, [99,99,99,1,1,1])
-        z = where(c, 1, masked)
-        assert eq(z, [99, 1, 1, 99, 99, 99])
-
-    def check_testMinMax(self):
-        "Test of minumum, maximum."
-        assert eq(minimum([1,2,3],[4,0,9]), [1,0,3])
-        assert eq(maximum([1,2,3],[4,0,9]), [4,2,9])
-        x = arange(5)
-        y = arange(5) - 2
-        x[3] = masked
-        y[0] = masked
-        assert eq(minimum(x,y), where(less(x,y), x, y))
-        assert eq(maximum(x,y), where(greater(x,y), x, y))
-        assert minimum(x) == 0
-        assert maximum(x) == 4
-
-    def check_testTakeTransposeInnerOuter(self):
-        "Test of take, transpose, inner, outer products"
-        x = arange(24)
-        y = numpy.arange(24)
-        x[5:6] = masked
-        x=x.reshape(2,3,4)
-        y=y.reshape(2,3,4)
-        assert eq(numpy.transpose(y,(2,0,1)), transpose(x,(2,0,1)))
-        assert eq(numpy.take(y, (2,0,1), 1), take(x, (2,0,1), 1))
-        assert eq(numpy.inner(filled(x,0),filled(y,0)),
-                                inner(x, y))
-        assert eq(numpy.outer(filled(x,0),filled(y,0)),
-                                outer(x, y))
-        y = array(['abc', 1, 'def', 2, 3], object)
-        y[2] = masked
-        t = take(y,[0,3,4])
-        assert t[0] == 'abc'
-        assert t[1] == 2
-        assert t[2] == 3
-
-    def check_testInplace(self):
-        """Test of inplace operations and rich comparisons"""
-        y = arange(10)
-
-        x = arange(10)
-        xm = arange(10)
-        xm[2] = masked
-        x += 1
-        assert eq(x, y+1)
-        xm += 1
-        assert eq(x, y+1)
-
-        x = arange(10)
-        xm = arange(10)
-        xm[2] = masked
-        x -= 1
-        assert eq(x, y-1)
-        xm -= 1
-        assert eq(xm, y-1)
-
-        x = arange(10)*1.0
-        xm = arange(10)*1.0
-        xm[2] = masked
-        x *= 2.0
-        assert eq(x, y*2)
-        xm *= 2.0
-        assert eq(xm, y*2)
-
-        x = arange(10)*2
-        xm = arange(10)
-        xm[2] = masked
-        x /= 2
-        assert eq(x, y)
-        xm /= 2
-        assert eq(x, y)
-
-        x = arange(10)*1.0
-        xm = arange(10)*1.0
-        xm[2] = masked
-        x /= 2.0
-        assert eq(x, y/2.0)
-        xm /= arange(10)
-        assert eq(xm, ones((10,)))
-
-        x = arange(10).astype(float32)
-        xm = arange(10)
-        xm[2] = masked
-        id1 = id(x.raw_data())
-        x += 1.
-        assert id1 == id(x.raw_data())
-        assert eq(x, y+1.)
-
-    def check_testPickle(self):
-        "Test of pickling"
-        import pickle
-        x = arange(12)
-        x[4:10:2] = masked
-        x = x.reshape(4,3)
-        s = pickle.dumps(x)
-        y = pickle.loads(s)
-        assert eq(x,y)
-
-    def check_testMasked(self):
-        "Test of masked element"
-        xx=arange(6)
-        xx[1] = masked
-        self.failUnless(str(masked) ==  '--')
-        self.failUnless(xx[1] is masked)
-        self.failUnlessEqual(filled(xx[1], 0), 0)
-        # don't know why these should raise an exception...
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, masked)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, 2)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, xx)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, xx, masked)
-
-    def check_testAverage1(self):
-        "Test of average."
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        self.failUnless(eq(2.0, average(ott,axis=0)))
-        self.failUnless(eq(2.0, average(ott, weights=[1., 1., 2., 1.])))
-        result, wts = average(ott, weights=[1.,1.,2.,1.], returned=1)
-        self.failUnless(eq(2.0, result))
-        self.failUnless(wts == 4.0)
-        ott[:] = masked
-        self.failUnless(average(ott,axis=0) is masked)
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        ott=ott.reshape(2,2)
-        ott[:,1] = masked
-        self.failUnless(eq(average(ott,axis=0), [2.0, 0.0]))
-        self.failUnless(average(ott,axis=1)[0] is masked)
-        self.failUnless(eq([2.,0.], average(ott, axis=0)))
-        result, wts = average(ott, axis=0, returned=1)
-        self.failUnless(eq(wts, [1., 0.]))
-
-    def check_testAverage2(self):
-        "More tests of average."
-        w1 = [0,1,1,1,1,0]
-        w2 = [[0,1,1,1,1,0],[1,0,0,0,0,1]]
-        x=arange(6)
-        self.failUnless(allclose(average(x, axis=0), 2.5))
-        self.failUnless(allclose(average(x, axis=0, weights=w1), 2.5))
-        y=array([arange(6), 2.0*arange(6)])
-        self.failUnless(allclose(average(y, None), numpy.add.reduce(numpy.arange(6))*3./12.))
-        self.failUnless(allclose(average(y, axis=0), numpy.arange(6) * 3./2.))
-        self.failUnless(allclose(average(y, axis=1), [average(x,axis=0), average(x,axis=0) * 2.0]))
-        self.failUnless(allclose(average(y, None, weights=w2), 20./6.))
-        self.failUnless(allclose(average(y, axis=0, weights=w2), [0.,1.,2.,3.,4.,10.]))
-        self.failUnless(allclose(average(y, axis=1), [average(x,axis=0), average(x,axis=0) * 2.0]))
-        m1 = zeros(6)
-        m2 = [0,0,1,1,0,0]
-        m3 = [[0,0,1,1,0,0],[0,1,1,1,1,0]]
-        m4 = ones(6)
-        m5 = [0, 1, 1, 1, 1, 1]
-        self.failUnless(allclose(average(masked_array(x, m1),axis=0), 2.5))
-        self.failUnless(allclose(average(masked_array(x, m2),axis=0), 2.5))
-        self.failUnless(average(masked_array(x, m4),axis=0) is masked)
-        self.assertEqual(average(masked_array(x, m5),axis=0), 0.0)
-        self.assertEqual(count(average(masked_array(x, m4),axis=0)), 0)
-        z = masked_array(y, m3)
-        self.failUnless(allclose(average(z, None), 20./6.))
-        self.failUnless(allclose(average(z, axis=0), [0.,1.,99.,99.,4.0, 7.5]))
-        self.failUnless(allclose(average(z, axis=1), [2.5, 5.0]))
-        self.failUnless(allclose( average(z,axis=0, weights=w2), [0.,1., 99., 99., 4.0, 10.0]))
-
-        a = arange(6)
-        b = arange(6) * 3
-        r1, w1 = average([[a,b],[b,a]], axis=1, returned=1)
-        self.assertEqual(shape(r1) , shape(w1))
-        self.assertEqual(r1.shape , w1.shape)
-        r2, w2 = average(ones((2,2,3)), axis=0, weights=[3,1], returned=1)
-        self.assertEqual(shape(w2) , shape(r2))
-        r2, w2 = average(ones((2,2,3)), returned=1)
-        self.assertEqual(shape(w2) , shape(r2))
-        r2, w2 = average(ones((2,2,3)), weights=ones((2,2,3)), returned=1)
-        self.failUnless(shape(w2) == shape(r2))
-        a2d = array([[1,2],[0,4]], float)
-        a2dm = masked_array(a2d, [[0,0],[1,0]])
-        a2da = average(a2d, axis=0)
-        self.failUnless(eq (a2da, [0.5, 3.0]))
-        a2dma = average(a2dm, axis=0)
-        self.failUnless(eq( a2dma, [1.0, 3.0]))
-        a2dma = average(a2dm, axis=None)
-        self.failUnless(eq(a2dma, 7./3.))
-        a2dma = average(a2dm, axis=1)
-        self.failUnless(eq(a2dma, [1.5, 4.0]))
-
-    def check_testToPython(self):
-        self.assertEqual(1, int(array(1)))
-        self.assertEqual(1.0, float(array(1)))
-        self.assertEqual(1, int(array([[[1]]])))
-        self.assertEqual(1.0, float(array([[1]])))
-        self.failUnlessRaises(ValueError, float, array([1,1]))
-        self.failUnlessRaises(MAError, float, array([1],mask=[1]))
-        self.failUnless(bool(array([0,1])))
-        self.failUnless(bool(array([0,0],mask=[0,1])))
-        self.failIf(bool(array([0,0])))
-        self.failIf(bool(array([0,0],mask=[0,0])))
-
-    def check_testScalarArithmetic(self):
-        xm = array(0, mask=1)
-        self.failUnless((1/array(0)).mask)
-        self.failUnless((1 + xm).mask)
-        self.failUnless((-xm).mask)
-        self.failUnless((-xm).mask)
-        self.failUnless(maximum(xm, xm).mask)
-        self.failUnless(minimum(xm, xm).mask)
-        self.failUnless(xm.filled().dtype is xm.data.dtype)
-        x = array(0, mask=0)
-        self.failUnless(x.filled() == x.data)
-        self.failUnlessEqual(str(xm), str(masked_print_option))
-
-    def check_testArrayMethods(self):
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        self.failUnless(eq(a.any(), a.data.any()))
-        self.failUnless(eq(a.all(), a.data.all()))
-        self.failUnless(eq(a.argmax(), a.data.argmax()))
-        self.failUnless(eq(a.argmin(), a.data.argmin()))
-        self.failUnless(eq(a.choose(0,1,2,3,4), a.data.choose(0,1,2,3,4)))
-        self.failUnless(eq(a.compress([1,0,1]), a.data.compress([1,0,1])))
-        self.failUnless(eq(a.conj(), a.data.conj()))
-        self.failUnless(eq(a.conjugate(), a.data.conjugate()))
-        m = array([[1,2],[3,4]])
-        self.failUnless(eq(m.diagonal(), m.data.diagonal()))
-        self.failUnless(eq(a.sum(), a.data.sum()))
-        self.failUnless(eq(a.take([1,2]), a.data.take([1,2])))
-        self.failUnless(eq(m.transpose(), m.data.transpose()))
-
-    def check_testArrayAttributes(self):
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        self.failUnlessEqual(a.ndim, 1)
-
-    def check_testAPI(self):
-        self.failIf([m for m in dir(numpy.ndarray)
-                     if m not in dir(array) and not m.startswith('_')])
-
-    def check_testSingleElementSubscript(self):
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        self.failUnlessEqual(a[0].shape, ())
-        self.failUnlessEqual(b[0].shape, ())
-        self.failUnlessEqual(b[1].shape, ())
-
-class TestUfuncs(NumpyTestCase):
-    def setUp(self):
-        self.d = (array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
-                  array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
-
-
-    def check_testUfuncRegression(self):
-        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
-                  'sin', 'cos', 'tan',
-                  'arcsin', 'arccos', 'arctan',
-                  'sinh', 'cosh', 'tanh',
-                  'arcsinh',
-                  'arccosh',
-                  'arctanh',
-                  'absolute', 'fabs', 'negative',
-                  # 'nonzero', 'around',
-                  'floor', 'ceil',
-                  # 'sometrue', 'alltrue',
-                  'logical_not',
-                  'add', 'subtract', 'multiply',
-                  'divide', 'true_divide', 'floor_divide',
-                  'remainder', 'fmod', 'hypot', 'arctan2',
-                  'equal', 'not_equal', 'less_equal', 'greater_equal',
-                  'less', 'greater',
-                  'logical_and', 'logical_or', 'logical_xor',
-                  ]:
-            try:
-                uf = getattr(umath, f)
-            except AttributeError:
-                uf = getattr(fromnumeric, f)
-            mf = getattr(numpy.ma, f)
-            args = self.d[:uf.nin]
-            olderr = numpy.geterr()
-            if f in ['sqrt', 'arctanh', 'arcsin', 'arccos', 'arccosh', 'arctanh', 'log',
-                     'log10','divide','true_divide', 'floor_divide', 'remainder', 'fmod']:
-                numpy.seterr(invalid='ignore')
-            if f in ['arctanh', 'log', 'log10']:
-                numpy.seterr(divide='ignore')
-            ur = uf(*args)
-            mr = mf(*args)
-            numpy.seterr(**olderr)
-            self.failUnless(eq(ur.filled(0), mr.filled(0), f))
-            self.failUnless(eqmask(ur.mask, mr.mask))
-
-    def test_reduce(self):
-        a = self.d[0]
-        self.failIf(alltrue(a,axis=0))
-        self.failUnless(sometrue(a,axis=0))
-        self.failUnlessEqual(sum(a[:3],axis=0), 0)
-        self.failUnlessEqual(product(a,axis=0), 0)
-
-    def test_minmax(self):
-        a = arange(1,13).reshape(3,4)
-        amask = masked_where(a < 5,a)
-        self.failUnlessEqual(amask.max(), a.max())
-        self.failUnlessEqual(amask.min(), 5)
-        self.failUnless((amask.max(0) == a.max(0)).all())
-        self.failUnless((amask.min(0) == [5,6,7,8]).all())
-        self.failUnless(amask.max(1)[0].mask)
-        self.failUnless(amask.min(1)[0].mask)
-
-    def test_nonzero(self):
-        for t in "?bhilqpBHILQPfdgFDGO":
-            x = array([1,0,2,0], mask=[0,0,1,1])
-            self.failUnless(eq(nonzero(x), [0]))
-
-
-class TestArrayMethods(NumpyTestCase):
-
-    def setUp(self):
-        x = numpy.array([ 8.375,  7.545,  8.828,  8.5  ,  1.757,  5.928,
-                          8.43 ,  7.78 ,  9.865,  5.878,  8.979,  4.732,
-                          3.012,  6.022,  5.095,  3.116,  5.238,  3.957,
-                          6.04 ,  9.63 ,  7.712,  3.382,  4.489,  6.479,
-                          7.189,  9.645,  5.395,  4.961,  9.894,  2.893,
-                          7.357,  9.828,  6.272,  3.758,  6.693,  0.993])
-        X = x.reshape(6,6)
-        XX = x.reshape(3,2,2,3)
-
-        m = numpy.array([0, 1, 0, 1, 0, 0,
-                         1, 0, 1, 1, 0, 1,
-                         0, 0, 0, 1, 0, 1,
-                         0, 0, 0, 1, 1, 1,
-                         1, 0, 0, 1, 0, 0,
-                         0, 0, 1, 0, 1, 0])
-        mx = array(data=x,mask=m)
-        mX = array(data=X,mask=m.reshape(X.shape))
-        mXX = array(data=XX,mask=m.reshape(XX.shape))
-
-        m2 = numpy.array([1, 1, 0, 1, 0, 0,
-                          1, 1, 1, 1, 0, 1,
-                          0, 0, 1, 1, 0, 1,
-                          0, 0, 0, 1, 1, 1,
-                          1, 0, 0, 1, 1, 0,
-                          0, 0, 1, 0, 1, 1])
-        m2x = array(data=x,mask=m2)
-        m2X = array(data=X,mask=m2.reshape(X.shape))
-        m2XX = array(data=XX,mask=m2.reshape(XX.shape))
-        self.d =  (x,X,XX,m,mx,mX,mXX)
-
-    #------------------------------------------------------
-    def test_trace(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        mXdiag = mX.diagonal()
-        self.assertEqual(mX.trace(), mX.diagonal().compressed().sum())
-        self.failUnless(eq(mX.trace(),
-                           X.trace() - sum(mXdiag.mask*X.diagonal(),axis=0)))
-
-    def test_clip(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        clipped = mx.clip(2,8)
-        self.failUnless(eq(clipped.mask,mx.mask))
-        self.failUnless(eq(clipped.data,x.clip(2,8)))
-        self.failUnless(eq(clipped.data,mx.data.clip(2,8)))
-
-    def test_ptp(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        (n,m) = X.shape
-        self.assertEqual(mx.ptp(),mx.compressed().ptp())
-        rows = numpy.zeros(n,numpy.float_)
-        cols = numpy.zeros(m,numpy.float_)
-        for k in range(m):
-            cols[k] = mX[:,k].compressed().ptp()
-        for k in range(n):
-            rows[k] = mX[k].compressed().ptp()
-        self.failUnless(eq(mX.ptp(0),cols))
-        self.failUnless(eq(mX.ptp(1),rows))
-
-    def test_swapaxes(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        mXswapped = mX.swapaxes(0,1)
-        self.failUnless(eq(mXswapped[-1],mX[:,-1]))
-        mXXswapped = mXX.swapaxes(0,2)
-        self.assertEqual(mXXswapped.shape,(2,2,3,3))
-
-
-    def test_cumprod(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        mXcp = mX.cumprod(0)
-        self.failUnless(eq(mXcp.data,mX.filled(1).cumprod(0)))
-        mXcp = mX.cumprod(1)
-        self.failUnless(eq(mXcp.data,mX.filled(1).cumprod(1)))
-
-    def test_cumsum(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        mXcp = mX.cumsum(0)
-        self.failUnless(eq(mXcp.data,mX.filled(0).cumsum(0)))
-        mXcp = mX.cumsum(1)
-        self.failUnless(eq(mXcp.data,mX.filled(0).cumsum(1)))
-
-    def test_varstd(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        self.failUnless(eq(mX.var(axis=None),mX.compressed().var()))
-        self.failUnless(eq(mX.std(axis=None),mX.compressed().std()))
-        self.failUnless(eq(mXX.var(axis=3).shape,XX.var(axis=3).shape))
-        self.failUnless(eq(mX.var().shape,X.var().shape))
-        (mXvar0,mXvar1) = (mX.var(axis=0), mX.var(axis=1))
-        for k in range(6):
-            self.failUnless(eq(mXvar1[k],mX[k].compressed().var()))
-            self.failUnless(eq(mXvar0[k],mX[:,k].compressed().var()))
-            self.failUnless(eq(numpy.sqrt(mXvar0[k]),
-                               mX[:,k].compressed().std()))
-
-
-def eqmask(m1, m2):
-    if m1 is nomask:
-        return m2 is nomask
-    if m2 is nomask:
-        return m1 is nomask
-    return (m1 == m2).all()
-
-def timingTest():
-    for f in [testf, testinplace]:
-        for n in [1000,10000,50000]:
-            t = testta(n, f)
-            t1 = testtb(n, f)
-            t2 = testtc(n, f)
-            print f.test_name
-            print """\
-n = %7d
-numpy time (ms) %6.1f
-MA maskless ratio %6.1f
-MA masked ratio %6.1f
-""" % (n, t*1000.0, t1/t, t2/t)
-
-def testta(n, f):
-    x=numpy.arange(n) + 1.0
-    tn0 = time.time()
-    z = f(x)
-    return time.time() - tn0
-
-def testtb(n, f):
-    x=arange(n) + 1.0
-    tn0 = time.time()
-    z = f(x)
-    return time.time() - tn0
-
-def testtc(n, f):
-    x=arange(n) + 1.0
-    x[0] = masked
-    tn0 = time.time()
-    z = f(x)
-    return time.time() - tn0
-
-def testf(x):
-    for i in range(25):
-        y = x **2 +  2.0 * x - 1.0
-        w = x **2 +  1.0
-        z = (y / w) ** 2
-    return z
-testf.test_name = 'Simple arithmetic'
-
-def testinplace(x):
-    for i in range(25):
-        y = x**2
-        y += 2.0*x
-        y -= 1.0
-        y /= x
-    return y
-testinplace.test_name = 'Inplace operations'
-
-if __name__ == "__main__":
-    NumpyTest('numpy.core.ma').run()
-    #timingTest()

Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/core/tests/test_regression.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -110,11 +110,11 @@
 
     def check_masked_array(self,level=rlevel):
         """Ticket #61"""
-        x = np.core.ma.array(1,mask=[1])
+        x = np.ma.array(1,mask=[1])
 
     def check_mem_masked_where(self,level=rlevel):
         """Ticket #62"""
-        from numpy.core.ma import masked_where, MaskType
+        from numpy.ma import masked_where, MaskType
         a = np.zeros((1,1))
         b = np.zeros(a.shape, MaskType)
         c = masked_where(b,a)

Copied: trunk/numpy/ma (from rev 4777, branches/maskedarray/numpy/ma)

Deleted: trunk/numpy/ma/API_CHANGES.txt
===================================================================
--- branches/maskedarray/numpy/ma/API_CHANGES.txt	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/API_CHANGES.txt	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,68 +0,0 @@
-.. -*- rest -*-
-
-==================================================
-API changes in the new masked array implementation
-==================================================
-
-``put``, ``putmask`` behave like their ndarray counterparts
------------------------------------------------------------
-
-Previously, ``putmask`` was used like this::
-
-  mask = [False,True,True]
-  x = array([1,4,7],mask=mask)
-  putmask(x,mask,[3])
-
-which translated to::
-  
-  x[~mask] = [3]
-
-(Note that a ``True``-value in a mask suppresses a value.)
-
-In other words, the mask had the same length as ``x``, whereas
-``values`` had ``sum(~mask)`` elements.
-
-Now, the behaviour is similar to that of ``ndarray.putmask``, where
-the mask and the values are both the same length as ``x``, i.e.
-
-::
-
-  putmask(x,mask,[3,0,0])
-
-
-``fill_value`` is a property
-----------------------------
-
-``fill_value`` is no longer a method, but a property::
-
-  >>> print x.fill_value
-  999999
-
-``cumsum`` and ``cumprod`` ignore missing values
-------------------------------------------------
-
-Missing values are assumed to be the identity element, i.e. 0 for
-``cumsum`` and 1 for ``cumprod``::
-
-  >>> x = N.ma.array([1,2,3,4],mask=[False,True,False,False])
-  >>> print x
-  [1 -- 3 4]
-  >>> print x.cumsum()
-  [1 -- 4 8]
-  >> print x.cumprod()
-  [1 -- 3 12]
-
-``bool(x)`` raises a ValueError
--------------------------------
-
-Masked arrays now behave like regular ``ndarrays``, in that they cannot be
-converted to booleans:
-
-::
-
-  >>> x = N.ma.array([1,2,3])
-  >>> bool(x)
-  Traceback (most recent call last):
-    File "<stdin>", line 1, in <module>
-  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
-

Copied: trunk/numpy/ma/API_CHANGES.txt (from rev 4777, branches/maskedarray/numpy/ma/API_CHANGES.txt)

Deleted: trunk/numpy/ma/LICENSE
===================================================================
--- branches/maskedarray/numpy/ma/LICENSE	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/LICENSE	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,24 +0,0 @@
-* Copyright (c) 2006, University of Georgia and Pierre G.F. Gerard-Marchant
-* All rights reserved.
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following conditions are met:
-*
-*     * Redistributions of source code must retain the above copyright
-*       notice, this list of conditions and the following disclaimer.
-*     * Redistributions in binary form must reproduce the above copyright
-*       notice, this list of conditions and the following disclaimer in the
-*       documentation and/or other materials provided with the distribution.
-*     * Neither the name of the University of Georgia nor the
-*       names of its contributors may be used to endorse or promote products
-*       derived from this software without specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
-* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file

Copied: trunk/numpy/ma/LICENSE (from rev 4777, branches/maskedarray/numpy/ma/LICENSE)

Deleted: trunk/numpy/ma/__init__.py
===================================================================
--- branches/maskedarray/numpy/ma/__init__.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/__init__.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,22 +0,0 @@
-"""Masked arrays add-ons.
-
-A collection of utilities for maskedarray
-
-:author: Pierre GF Gerard-Marchant
-:contact: pierregm_at_uga_dot_edu
-:version: $Id: __init__.py 3473 2007-10-29 15:18:13Z jarrod.millman $
-"""
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
-import core
-from core import *
-
-import extras
-from extras import *
-
-__all__ = ['core', 'extras']
-__all__ += core.__all__
-__all__ += extras.__all__

Copied: trunk/numpy/ma/__init__.py (from rev 4777, branches/maskedarray/numpy/ma/__init__.py)

Deleted: trunk/numpy/ma/core.py
===================================================================
--- branches/maskedarray/numpy/ma/core.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/core.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,3307 +0,0 @@
-# pylint: disable-msg=E1002
-"""MA: a facility for dealing with missing observations
-MA is generally used as a numpy.array look-alike.
-by Paul F. Dubois.
-
-Copyright 1999, 2000, 2001 Regents of the University of California.
-Released for unlimited redistribution.
-Adapted for numpy_core 2005 by Travis Oliphant and
-(mainly) Paul Dubois.
-
-Subclassing of the base ndarray 2006 by Pierre Gerard-Marchant.
-pgmdevlist_AT_gmail_DOT_com
-Improvements suggested by Reggie Dugard (reggie_AT_merfinllc_DOT_com)
-
-:author: Pierre Gerard-Marchant
-:contact: pierregm_at_uga_dot_edu
-"""
-__author__ = "Pierre GF Gerard-Marchant"
-__docformat__ = "restructuredtext en"
-
-__all__ = ['MAError', 'MaskType', 'MaskedArray',
-           'bool_', 'complex_', 'float_', 'int_', 'object_',
-           'abs', 'absolute', 'add', 'all', 'allclose', 'allequal', 'alltrue',
-           'amax', 'amin', 'anom', 'anomalies', 'any', 'arange',
-           'arccos', 'arccosh', 'arcsin', 'arcsinh', 'arctan', 'arctan2',
-           'arctanh', 'argmax', 'argmin', 'argsort', 'around',
-           'array', 'asarray','asanyarray',
-           'bitwise_and', 'bitwise_or', 'bitwise_xor',
-           'ceil', 'choose', 'compress', 'compressed', 'concatenate',
-           'conjugate', 'cos', 'cosh', 'count',
-           'default_fill_value', 'diagonal', 'divide', 'dump', 'dumps',
-           'empty', 'empty_like', 'equal', 'exp',
-           'fabs', 'fmod', 'filled', 'floor', 'floor_divide','fix_invalid',
-           'getdata','getmask', 'getmaskarray', 'greater', 'greater_equal', 
-           'hypot',
-           'ids', 'inner', 'innerproduct',
-           'isMA', 'isMaskedArray', 'is_mask', 'is_masked', 'isarray',
-           'left_shift', 'less', 'less_equal', 'load', 'loads', 'log', 'log10',
-           'logical_and', 'logical_not', 'logical_or', 'logical_xor',
-           'make_mask', 'make_mask_none', 'mask_or', 'masked',
-           'masked_array', 'masked_equal', 'masked_greater',
-           'masked_greater_equal', 'masked_inside', 'masked_less',
-           'masked_less_equal', 'masked_not_equal', 'masked_object',
-           'masked_outside', 'masked_print_option', 'masked_singleton',
-           'masked_values', 'masked_where', 'max', 'maximum', 'mean', 'min',
-           'minimum', 'multiply',
-           'negative', 'nomask', 'nonzero', 'not_equal',
-           'ones', 'outer', 'outerproduct',
-           'power', 'product', 'ptp', 'put', 'putmask',
-           'rank', 'ravel', 'remainder', 'repeat', 'reshape', 'resize',
-           'right_shift', 'round_',
-           'shape', 'sin', 'sinh', 'size', 'sometrue', 'sort', 'sqrt', 'std',
-           'subtract', 'sum', 'swapaxes',
-           'take', 'tan', 'tanh', 'transpose', 'true_divide',
-           'var', 'where',
-           'zeros']
-
-import sys
-import types
-import cPickle
-import operator
-
-import numpy
-from numpy.core import bool_, complex_, float_, int_, object_, str_
-
-import numpy.core.umath as umath
-import numpy.core.fromnumeric  as fromnumeric
-import numpy.core.numeric as numeric
-import numpy.core.numerictypes as ntypes
-from numpy import bool_, dtype, typecodes, amax, amin, ndarray
-from numpy import expand_dims as n_expand_dims
-from numpy import array as narray
-import warnings
-
-
-MaskType = bool_
-nomask = MaskType(0)
-
-divide_tolerance = 1.e-35
-numpy.seterr(all='ignore')
-
-def doc_note(note):
-    return "\nNotes\n-----\n%s" % note
-
-#####--------------------------------------------------------------------------
-#---- --- Exceptions ---
-#####--------------------------------------------------------------------------
-class MAError(Exception):
-    "Class for MA related errors."
-    def __init__ (self, args=None):
-        "Creates an exception."
-        Exception.__init__(self,args)
-        self.args = args
-    def __str__(self):
-        "Calculates the string representation."
-        return str(self.args)
-    __repr__ = __str__
-
-#####--------------------------------------------------------------------------
-#---- --- Filling options ---
-#####--------------------------------------------------------------------------
-# b: boolean - c: complex - f: floats - i: integer - O: object - S: string
-default_filler = {'b': True,
-                  'c' : 1.e20 + 0.0j,
-                  'f' : 1.e20,
-                  'i' : 999999,
-                  'O' : '?',
-                  'S' : 'N/A',
-                  'u' : 999999,
-                  'V' : '???',
-                  }
-max_filler = ntypes._minvals
-max_filler.update([(k,-numpy.inf) for k in [numpy.float32, numpy.float64]])
-min_filler = ntypes._maxvals
-min_filler.update([(k,numpy.inf) for k in [numpy.float32, numpy.float64]])
-if 'float128' in ntypes.typeDict:
-    max_filler.update([(numpy.float128,-numpy.inf)])
-    min_filler.update([(numpy.float128, numpy.inf)])
-
-def default_fill_value(obj):
-    """Calculate the default fill value for the argument object.
-
-    """
-    if hasattr(obj,'dtype'):
-        defval = default_filler[obj.dtype.kind]
-    elif isinstance(obj, numeric.dtype):
-        defval = default_filler[obj.kind]
-    elif isinstance(obj, float):
-        defval = default_filler['f']
-    elif isinstance(obj, int) or isinstance(obj, long):
-        defval = default_filler['i']
-    elif isinstance(obj, str):
-        defval = default_filler['S']
-    elif isinstance(obj, complex):
-        defval = default_filler['c']
-    else:
-        defval = default_filler['O']
-    return defval
-
-def minimum_fill_value(obj):
-    """Calculate the default fill value suitable for taking the
-    minimum of ``obj``.
-
-    """
-    if hasattr(obj, 'dtype'):
-        objtype = obj.dtype
-        filler = min_filler[objtype]
-        if filler is None:
-            raise TypeError, 'Unsuitable type for calculating minimum.'
-        return filler
-    elif isinstance(obj, float):
-        return min_filler[ntypes.typeDict['float_']]
-    elif isinstance(obj, int):
-        return min_filler[ntypes.typeDict['int_']]
-    elif isinstance(obj, long):
-        return min_filler[ntypes.typeDict['uint']]
-    elif isinstance(obj, numeric.dtype):
-        return min_filler[obj]
-    else:
-        raise TypeError, 'Unsuitable type for calculating minimum.'
-
-def maximum_fill_value(obj):
-    """Calculate the default fill value suitable for taking the maximum
-    of ``obj``.
-
-    """
-    if hasattr(obj, 'dtype'):
-        objtype = obj.dtype
-        filler = max_filler[objtype]
-        if filler is None:
-            raise TypeError, 'Unsuitable type for calculating minimum.'
-        return filler
-    elif isinstance(obj, float):
-        return max_filler[ntypes.typeDict['float_']]
-    elif isinstance(obj, int):
-        return max_filler[ntypes.typeDict['int_']]
-    elif isinstance(obj, long):
-        return max_filler[ntypes.typeDict['uint']]
-    elif isinstance(obj, numeric.dtype):
-        return max_filler[obj]
-    else:
-        raise TypeError, 'Unsuitable type for calculating minimum.'
-
-
-def _check_fill_value(fill_value, dtype):
-    descr = numpy.dtype(dtype).descr
-    if fill_value is None:
-        if len(descr) > 1:
-            fill_value = [default_fill_value(numeric.dtype(d[1]))
-                          for d in descr]
-        else:
-            fill_value = default_fill_value(dtype)
-    else:
-        fill_value = narray(fill_value).tolist() 
-        fval = numpy.resize(fill_value, len(descr))
-        if len(descr) > 1:
-            fill_value = [numpy.asarray(f).astype(d[1]).item()
-                          for (f,d) in zip(fval, descr)]
-        else:
-            fill_value = narray(fval, copy=False, dtype=dtype).item()
-    return fill_value
-
-
-def set_fill_value(a, fill_value):
-    """Set the filling value of a, if a is a masked array.  Otherwise,
-    do nothing.
-
-    Returns
-    -------
-    None
-
-    """
-    if isinstance(a, MaskedArray):
-        a._fill_value = _check_fill_value(fill_value, a.dtype)
-    return
-
-def get_fill_value(a):
-    """Return the filling value of a, if any.  Otherwise, returns the
-    default filling value for that type.
-
-    """
-    if isinstance(a, MaskedArray):
-        result = a.fill_value
-    else:
-        result = default_fill_value(a)
-    return result
-
-def common_fill_value(a, b):
-    """Return the common filling value of a and b, if any.
-    If a and b have different filling values, returns None.
-
-    """
-    t1 = get_fill_value(a)
-    t2 = get_fill_value(b)
-    if t1 == t2:
-        return t1
-    return None
-
-
-#####--------------------------------------------------------------------------
-def filled(a, value = None):
-    """Return a as an array with masked data replaced by value.  If
-    value is None, get_fill_value(a) is used instead.  If a is already
-    a ndarray, a itself is returned.
-
-    Parameters
-    ----------
-    a : maskedarray or array_like
-        An input object.
-    value : {var}, optional
-        Filling value. If not given, the output of get_fill_value(a)
-        is used instead.
-
-    Returns
-    -------
-    a : array_like
-
-    """
-    if hasattr(a, 'filled'):
-        return a.filled(value)
-    elif isinstance(a, ndarray): 
-        # Should we check for contiguity ? and a.flags['CONTIGUOUS']:
-        return a
-    elif isinstance(a, dict):
-        return narray(a, 'O')
-    else:
-        return narray(a)
-
-#####--------------------------------------------------------------------------
-def get_masked_subclass(*arrays):
-    """Return the youngest subclass of MaskedArray from a list of
-    (masked) arrays.  In case of siblings, the first takes over.
-
-    """
-    if len(arrays) == 1:
-        arr = arrays[0]
-        if isinstance(arr, MaskedArray):
-            rcls = type(arr)
-        else:
-            rcls = MaskedArray
-    else:
-        arrcls = [type(a) for a in arrays]
-        rcls = arrcls[0]
-        if not issubclass(rcls, MaskedArray):
-            rcls = MaskedArray
-        for cls in arrcls[1:]:
-            if issubclass(cls, rcls):
-                rcls = cls
-    return rcls
-
-#####--------------------------------------------------------------------------
-def get_data(a, subok=True):
-    """Return the _data part of a (if any), or a as a ndarray.
-
-    Parameters
-    ----------
-    a : array_like
-        A ndarray or a subclass of.
-    subok : bool
-        Whether to force the output to a 'pure' ndarray (False) or to
-        return a subclass of ndarray if approriate (True).
-
-    """
-    data = getattr(a, '_data', numpy.array(a, subok=subok))
-    if not subok:
-        return data.view(ndarray)
-    return data
-getdata = get_data
-
-def fix_invalid(a, copy=True, fill_value=None):
-    """Return (a copy of) a where invalid data (nan/inf) are masked
-    and replaced by fill_value.
-
-    Note that a copy is performed by default (just in case...).
-
-    Parameters
-    ----------
-    a : array_like
-        A (subclass of) ndarray.
-    copy : bool
-        Whether to use a copy of a (True) or to fix a in place (False).
-    fill_value : {var}, optional
-        Value used for fixing invalid data.  If not given, the output
-        of get_fill_value(a) is used instead.
-
-    Returns
-    -------
-    b : MaskedArray
-
-    """
-    a = masked_array(a, copy=copy, subok=True)
-    invalid = (numpy.isnan(a._data) | numpy.isinf(a._data))
-    a._mask |= invalid
-    if fill_value is None:
-        fill_value = a.fill_value
-    a._data[invalid] = fill_value
-    return a
-
-
-
-#####--------------------------------------------------------------------------
-#---- --- Ufuncs ---
-#####--------------------------------------------------------------------------
-ufunc_domain = {}
-ufunc_fills = {}
-
-class _DomainCheckInterval:
-    """Define a valid interval, so that :
-
-    ``domain_check_interval(a,b)(x) = true`` where
-    ``x < a`` or ``x > b``.
-
-    """
-    def __init__(self, a, b):
-        "domain_check_interval(a,b)(x) = true where x < a or y > b"
-        if (a > b):
-            (a, b) = (b, a)
-        self.a = a
-        self.b = b
-
-    def __call__ (self, x):
-        "Execute the call behavior."
-        return umath.logical_or(umath.greater (x, self.b),
-                                umath.less(x, self.a))
-#............................
-class _DomainTan:
-    """Define a valid interval for the `tan` function, so that:
-
-    ``domain_tan(eps) = True`` where ``abs(cos(x)) < eps``
-
-    """
-    def __init__(self, eps):
-        "domain_tan(eps) = true where abs(cos(x)) < eps)"
-        self.eps = eps
-    def __call__ (self, x):
-        "Executes the call behavior."
-        return umath.less(umath.absolute(umath.cos(x)), self.eps)
-#............................
-class _DomainSafeDivide:
-    """Define a domain for safe division."""
-    def __init__ (self, tolerance=divide_tolerance):
-        self.tolerance = tolerance
-    def __call__ (self, a, b):
-        return umath.absolute(a) * self.tolerance >= umath.absolute(b)
-#............................
-class _DomainGreater:
-    "DomainGreater(v)(x) = true where x <= v"
-    def __init__(self, critical_value):
-        "DomainGreater(v)(x) = true where x <= v"
-        self.critical_value = critical_value
-
-    def __call__ (self, x):
-        "Executes the call behavior."
-        return umath.less_equal(x, self.critical_value)
-#............................
-class _DomainGreaterEqual:
-    "DomainGreaterEqual(v)(x) = true where x < v"
-    def __init__(self, critical_value):
-        "DomainGreaterEqual(v)(x) = true where x < v"
-        self.critical_value = critical_value
-
-    def __call__ (self, x):
-        "Executes the call behavior."
-        return umath.less(x, self.critical_value)
-
-#..............................................................................
-class _MaskedUnaryOperation:
-    """Defines masked version of unary operations, where invalid
-    values are pre-masked.
-
-    Parameters
-    ----------
-    f : callable
-    fill :
-        Default filling value (0).
-    domain :
-        Default domain (None).
-
-    """
-    def __init__ (self, mufunc, fill=0, domain=None):
-        """ _MaskedUnaryOperation(aufunc, fill=0, domain=None)
-            aufunc(fill) must be defined
-            self(x) returns aufunc(x)
-            with masked values where domain(x) is true or getmask(x) is true.
-        """
-        self.f = mufunc
-        self.fill = fill
-        self.domain = domain
-        self.__doc__ = getattr(mufunc, "__doc__", str(mufunc))
-        self.__name__ = getattr(mufunc, "__name__", str(mufunc))
-        ufunc_domain[mufunc] = domain
-        ufunc_fills[mufunc] = fill
-    #
-    def __call__ (self, a, *args, **kwargs):
-        "Execute the call behavior."
-        #
-        m = getmask(a)
-        d1 = get_data(a)
-        #
-        if self.domain is not None:
-            dm = narray(self.domain(d1), copy=False)
-            m = numpy.logical_or(m, dm)
-            # The following two lines control the domain filling methods.
-            d1 = d1.copy()
-            # We could use smart indexing : d1[dm] = self.fill ...
-            # ... but numpy.putmask looks more efficient, despite the copy.
-            numpy.putmask(d1, dm, self.fill)
-        # Take care of the masked singletong first ...
-        if not m.ndim and m:
-            return masked
-        # Get the result class .......................
-        if isinstance(a, MaskedArray):
-            subtype = type(a)
-        else:
-            subtype = MaskedArray
-        # Get the result  as a view of the subtype ...
-        result = self.f(d1, *args, **kwargs).view(subtype)
-        # Fix the mask if we don't have a scalar
-        if result.ndim > 0:
-            result._mask = m
-            result._update_from(a)
-        return result
-    #
-    def __str__ (self):
-        return "Masked version of %s. [Invalid values are masked]" % str(self.f)
-
-#..............................................................................
-class _MaskedBinaryOperation:
-    """Define masked version of binary operations, where invalid
-    values are pre-masked.
-
-    Parameters
-    ----------
-    f : callable
-    fillx :
-        Default filling value for the first argument (0).
-    filly :
-        Default filling value for the second argument (0).
-    domain :
-        Default domain (None).
-
-    """
-    def __init__ (self, mbfunc, fillx=0, filly=0):
-        """abfunc(fillx, filly) must be defined.
-           abfunc(x, filly) = x for all x to enable reduce.
-        """
-        self.f = mbfunc
-        self.fillx = fillx
-        self.filly = filly
-        self.__doc__ = getattr(mbfunc, "__doc__", str(mbfunc))
-        self.__name__ = getattr(mbfunc, "__name__", str(mbfunc))
-        ufunc_domain[mbfunc] = None
-        ufunc_fills[mbfunc] = (fillx, filly)
-    #
-    def __call__ (self, a, b, *args, **kwargs):
-        "Execute the call behavior."
-        m = mask_or(getmask(a), getmask(b))
-        (d1, d2) = (get_data(a), get_data(b))
-        result = self.f(d1, d2, *args, **kwargs).view(get_masked_subclass(a,b))
-        if result.size > 1:
-            if m is not nomask:
-                result._mask = make_mask_none(result.shape)
-                result._mask.flat = m
-            if isinstance(a,MaskedArray):
-                result._update_from(a)
-            if isinstance(b,MaskedArray):
-                result._update_from(b)
-        elif m:
-            return masked
-        return result
-    #
-    def reduce (self, target, axis=0, dtype=None):
-        """Reduce `target` along the given `axis`."""
-        if isinstance(target, MaskedArray):
-            tclass = type(target)
-        else:
-            tclass = MaskedArray
-        m = getmask(target)
-        t = filled(target, self.filly)
-        if t.shape == ():
-            t = t.reshape(1)
-            if m is not nomask:
-                m = make_mask(m, copy=1)
-                m.shape = (1,)
-        if m is nomask:
-            return self.f.reduce(t, axis).view(tclass)
-        t = t.view(tclass)
-        t._mask = m
-        tr = self.f.reduce(getdata(t), axis, dtype=dtype or t.dtype)
-        mr = umath.logical_and.reduce(m, axis)
-        tr = tr.view(tclass)
-        if mr.ndim > 0:
-            tr._mask = mr
-            return tr
-        elif mr:
-            return masked
-        return tr
-
-    def outer (self, a, b):
-        """Return the function applied to the outer product of a and b.
-
-        """
-        ma = getmask(a)
-        mb = getmask(b)
-        if ma is nomask and mb is nomask:
-            m = nomask
-        else:
-            ma = getmaskarray(a)
-            mb = getmaskarray(b)
-            m = umath.logical_or.outer(ma, mb)
-        if (not m.ndim) and m:
-            return masked
-        rcls = get_masked_subclass(a,b)
-        # We could fill the arguments first, butis it useful ?
-        # d = self.f.outer(filled(a, self.fillx), filled(b, self.filly)).view(rcls)
-        d = self.f.outer(getdata(a), getdata(b)).view(rcls)
-        if d.ndim > 0:
-            d._mask = m
-        return d
-
-    def accumulate (self, target, axis=0):
-        """Accumulate `target` along `axis` after filling with y fill
-        value.
-
-        """
-        if isinstance(target, MaskedArray):
-            tclass = type(target)
-        else:
-            tclass = masked_array
-        t = filled(target, self.filly)
-        return self.f.accumulate(t, axis).view(tclass)
-
-    def __str__ (self):
-        return "Masked version of " + str(self.f)
-
-#..............................................................................
-class _DomainedBinaryOperation:
-    """Define binary operations that have a domain, like divide.
-
-    They have no reduce, outer or accumulate.
-
-    Parameters
-    ----------
-    f : function.
-    domain : Default domain.
-    fillx : Default filling value for the first argument (0).
-    filly : Default filling value for the second argument (0).
-
-    """
-    def __init__ (self, dbfunc, domain, fillx=0, filly=0):
-        """abfunc(fillx, filly) must be defined.
-           abfunc(x, filly) = x for all x to enable reduce.
-        """
-        self.f = dbfunc
-        self.domain = domain
-        self.fillx = fillx
-        self.filly = filly
-        self.__doc__ = getattr(dbfunc, "__doc__", str(dbfunc))
-        self.__name__ = getattr(dbfunc, "__name__", str(dbfunc))
-        ufunc_domain[dbfunc] = domain
-        ufunc_fills[dbfunc] = (fillx, filly)
-
-    def __call__(self, a, b):
-        "Execute the call behavior."
-        ma = getmask(a)
-        mb = getmask(b)
-        d1 = getdata(a)
-        d2 = get_data(b)
-        t = narray(self.domain(d1, d2), copy=False)
-        if t.any(None):
-            mb = mask_or(mb, t)
-            # The following two lines control the domain filling
-            d2 = d2.copy()
-            numpy.putmask(d2, t, self.filly)
-        m = mask_or(ma, mb)
-        if (not m.ndim) and m:
-            return masked
-        result =  self.f(d1, d2).view(get_masked_subclass(a,b))
-        if result.ndim > 0:
-            result._mask = m
-            if isinstance(a,MaskedArray):
-                result._update_from(a)
-            if isinstance(b,MaskedArray):
-                result._update_from(b)
-        return result
-
-    def __str__ (self):
-        return "Masked version of " + str(self.f)
-
-#..............................................................................
-# Unary ufuncs
-exp = _MaskedUnaryOperation(umath.exp)
-conjugate = _MaskedUnaryOperation(umath.conjugate)
-sin = _MaskedUnaryOperation(umath.sin)
-cos = _MaskedUnaryOperation(umath.cos)
-tan = _MaskedUnaryOperation(umath.tan)
-arctan = _MaskedUnaryOperation(umath.arctan)
-arcsinh = _MaskedUnaryOperation(umath.arcsinh)
-sinh = _MaskedUnaryOperation(umath.sinh)
-cosh = _MaskedUnaryOperation(umath.cosh)
-tanh = _MaskedUnaryOperation(umath.tanh)
-abs = absolute = _MaskedUnaryOperation(umath.absolute)
-fabs = _MaskedUnaryOperation(umath.fabs)
-negative = _MaskedUnaryOperation(umath.negative)
-floor = _MaskedUnaryOperation(umath.floor)
-ceil = _MaskedUnaryOperation(umath.ceil)
-around = _MaskedUnaryOperation(fromnumeric.round_)
-logical_not = _MaskedUnaryOperation(umath.logical_not)
-# Domained unary ufuncs .......................................................
-sqrt = _MaskedUnaryOperation(umath.sqrt, 0.0,
-                             _DomainGreaterEqual(0.0))
-log = _MaskedUnaryOperation(umath.log, 1.0,
-                            _DomainGreater(0.0))
-log10 = _MaskedUnaryOperation(umath.log10, 1.0,
-                              _DomainGreater(0.0))
-tan = _MaskedUnaryOperation(umath.tan, 0.0,
-                            _DomainTan(1.e-35))
-arcsin = _MaskedUnaryOperation(umath.arcsin, 0.0,
-                               _DomainCheckInterval(-1.0, 1.0))
-arccos = _MaskedUnaryOperation(umath.arccos, 0.0,
-                               _DomainCheckInterval(-1.0, 1.0))
-arccosh = _MaskedUnaryOperation(umath.arccosh, 1.0,
-                                _DomainGreaterEqual(1.0))
-arctanh = _MaskedUnaryOperation(umath.arctanh, 0.0,
-                                _DomainCheckInterval(-1.0+1e-15, 1.0-1e-15))
-# Binary ufuncs ...............................................................
-add = _MaskedBinaryOperation(umath.add)
-subtract = _MaskedBinaryOperation(umath.subtract)
-multiply = _MaskedBinaryOperation(umath.multiply, 1, 1)
-arctan2 = _MaskedBinaryOperation(umath.arctan2, 0.0, 1.0)
-equal = _MaskedBinaryOperation(umath.equal)
-equal.reduce = None
-not_equal = _MaskedBinaryOperation(umath.not_equal)
-not_equal.reduce = None
-less_equal = _MaskedBinaryOperation(umath.less_equal)
-less_equal.reduce = None
-greater_equal = _MaskedBinaryOperation(umath.greater_equal)
-greater_equal.reduce = None
-less = _MaskedBinaryOperation(umath.less)
-less.reduce = None
-greater = _MaskedBinaryOperation(umath.greater)
-greater.reduce = None
-logical_and = _MaskedBinaryOperation(umath.logical_and)
-alltrue = _MaskedBinaryOperation(umath.logical_and, 1, 1).reduce
-logical_or = _MaskedBinaryOperation(umath.logical_or)
-sometrue = logical_or.reduce
-logical_xor = _MaskedBinaryOperation(umath.logical_xor)
-bitwise_and = _MaskedBinaryOperation(umath.bitwise_and)
-bitwise_or = _MaskedBinaryOperation(umath.bitwise_or)
-bitwise_xor = _MaskedBinaryOperation(umath.bitwise_xor)
-hypot = _MaskedBinaryOperation(umath.hypot)
-# Domained binary ufuncs ......................................................
-divide = _DomainedBinaryOperation(umath.divide, _DomainSafeDivide(), 0, 1)
-true_divide = _DomainedBinaryOperation(umath.true_divide,
-                                        _DomainSafeDivide(), 0, 1)
-floor_divide = _DomainedBinaryOperation(umath.floor_divide,
-                                         _DomainSafeDivide(), 0, 1)
-remainder = _DomainedBinaryOperation(umath.remainder,
-                                      _DomainSafeDivide(), 0, 1)
-fmod = _DomainedBinaryOperation(umath.fmod, _DomainSafeDivide(), 0, 1)
-
-
-#####--------------------------------------------------------------------------
-#---- --- Mask creation functions ---
-#####--------------------------------------------------------------------------
-def get_mask(a):
-    """Return the mask of a, if any, or nomask.
-
-    To get a full array of booleans of the same shape as a, use
-    getmaskarray.
-
-    """
-    return getattr(a, '_mask', nomask)
-getmask = get_mask
-
-def getmaskarray(a):
-    """Return the mask of a, if any, or a boolean array of the shape
-    of a, full of False.
-
-    """
-    m = getmask(a)
-    if m is nomask:
-        m = make_mask_none(fromnumeric.shape(a))
-    return m
-
-def is_mask(m):
-    """Return True if m is a legal mask.
-
-    Does not check contents, only type.
-
-    """
-    try:
-        return m.dtype.type is MaskType
-    except AttributeError:
-        return False
-#
-def make_mask(m, copy=False, shrink=True, flag=None):
-    """Return m as a mask, creating a copy if necessary or requested.
-
-    The function can accept any sequence of integers or nomask.  Does
-    not check that contents must be 0s and 1s.
-
-    Parameters
-    ----------
-    m : array_like
-        Potential mask.
-    copy : bool
-        Whether to return a copy of m (True) or m itself (False).
-    shrink : bool
-        Whether to shrink m to nomask if all its values are False.
-
-    """
-    if flag is not None:
-        warnings.warn("The flag 'flag' is now called 'shrink'!",
-                      DeprecationWarning)
-        shrink = flag
-    if m is nomask:
-        return nomask
-    elif isinstance(m, ndarray):
-        m = filled(m, True)
-        if m.dtype.type is MaskType:
-            if copy:
-                result = narray(m, dtype=MaskType, copy=copy)
-            else:
-                result = m
-        else:
-            result = narray(m, dtype=MaskType)
-    else:
-        result = narray(filled(m, True), dtype=MaskType)
-    # Bas les masques !
-    if shrink and not result.any():
-        return nomask
-    else:
-        return result
-
-def make_mask_none(s):
-    """Return a mask of shape s, filled with False.
-
-    Parameters
-    ----------
-    s : tuple
-        A tuple indicating the shape of the final mask.
-
-    """
-    result = numeric.zeros(s, dtype=MaskType)
-    return result
-
-def mask_or (m1, m2, copy=False, shrink=True):
-    """Return the combination of two masks m1 and m2.
-
-    The masks are combined with the *logical_or* operator, treating
-    nomask as False.  The result may equal m1 or m2 if the other is
-    nomask.
-
-    Parameters
-    ----------
-    m1 : array_like
-        First mask.
-    m2 : array_like
-        Second mask
-    copy : bool
-        Whether to return a copy.
-    shrink : bool
-        Whether to shrink m to nomask if all its values are False.
-
-     """
-    if m1 is nomask:
-        return make_mask(m2, copy=copy, shrink=shrink)
-    if m2 is nomask:
-        return make_mask(m1, copy=copy, shrink=shrink)
-    if m1 is m2 and is_mask(m1):
-        return m1
-    return make_mask(umath.logical_or(m1, m2), copy=copy, shrink=shrink)
-
-#####--------------------------------------------------------------------------
-#--- --- Masking functions ---
-#####--------------------------------------------------------------------------
-def masked_where(condition, a, copy=True):
-    """Return a as an array masked where condition is true.
-
-    Masked values of a or condition are kept.
-
-    Parameters
-    ----------
-    condition : array_like
-        Masking condition.
-    a : array_like
-        Array to mask.
-    copy : bool
-        Whether to return a copy of a (True) or modify a in place.
-
-    """
-    cond = filled(condition,1)
-    a = narray(a, copy=copy, subok=True)
-    if hasattr(a, '_mask'):
-        cond = mask_or(cond, a._mask)
-        cls = type(a)
-    else:
-        cls = MaskedArray
-    result = a.view(cls)
-    result._mask = cond
-    return result
-
-def masked_greater(x, value, copy=True):
-    "Shortcut to masked_where, with condition = (x > value)."
-    return masked_where(greater(x, value), x, copy=copy)
-
-def masked_greater_equal(x, value, copy=True):
-    "Shortcut to masked_where, with condition = (x >= value)."
-    return masked_where(greater_equal(x, value), x, copy=copy)
-
-def masked_less(x, value, copy=True):
-    "Shortcut to masked_where, with condition = (x < value)."
-    return masked_where(less(x, value), x, copy=copy)
-
-def masked_less_equal(x, value, copy=True):
-    "Shortcut to masked_where, with condition = (x <= value)."
-    return masked_where(less_equal(x, value), x, copy=copy)
-
-def masked_not_equal(x, value, copy=True):
-    "Shortcut to masked_where, with condition = (x != value)."
-    return masked_where((x != value), x, copy=copy)
-
-#
-def masked_equal(x, value, copy=True):
-    """Shortcut to masked_where, with condition = (x == value).  For
-    floating point, consider `masked_values(x, value)` instead.
-
-    """
-    # An alternative implementation relies on filling first: probably not needed.
-    # d = filled(x, 0)
-    # c = umath.equal(d, value)
-    # m = mask_or(c, getmask(x))
-    # return array(d, mask=m, copy=copy)
-    return masked_where((x == value), x, copy=copy)
-
-def masked_inside(x, v1, v2, copy=True):
-    """Shortcut to masked_where, where condition is True for x inside
-    the interval [v1,v2] (v1 <= x <= v2).  The boundaries v1 and v2
-    can be given in either order.
-
-    Notes
-    -----
-    The array x is prefilled with its filling value.
-
-    """
-    if v2 < v1:
-        (v1, v2) = (v2, v1)
-    xf = filled(x)
-    condition = (xf >= v1) & (xf <= v2)
-    return masked_where(condition, x, copy=copy)
-
-def masked_outside(x, v1, v2, copy=True):
-    """Shortcut to masked_where, where condition is True for x outside
-    the interval [v1,v2] (x < v1)|(x > v2).  The boundaries v1 and v2
-    can be given in either order.
-
-    Notes
-    -----
-    The array x is prefilled with its filling value.
-
-    """
-    if v2 < v1:
-        (v1, v2) = (v2, v1)
-    xf = filled(x)
-    condition = (xf < v1) | (xf > v2)
-    return masked_where(condition, x, copy=copy)
-
-#
-def masked_object(x, value, copy=True):
-    """Mask the array x where the data are exactly equal to value.
-
-    This function is suitable only for object arrays: for floating
-    point, please use ``masked_values`` instead.
-
-    Notes
-    -----
-    The mask is set to `nomask` if posible.
-
-    """
-    if isMaskedArray(x):
-        condition = umath.equal(x._data, value)
-        mask = x._mask
-    else:
-        condition = umath.equal(fromnumeric.asarray(x), value)
-        mask = nomask
-    mask = mask_or(mask, make_mask(condition, shrink=True))
-    return masked_array(x, mask=mask, copy=copy, fill_value=value)
-
-def masked_values(x, value, rtol=1.e-5, atol=1.e-8, copy=True):
-    """Mask the array x where the data are approximately equal in
-    value, i.e.
-
-    (abs(x - value) <= atol+rtol*abs(value))
-
-    Suitable only for floating points. For integers, please use
-    ``masked_equal``.  The mask is set to nomask if posible.
-
-    Parameters
-    ----------
-    x : array_like
-        Array to fill.
-    value : float
-        Masking value.
-    rtol : float
-        Tolerance parameter.
-    atol : float
-        Tolerance parameter (1e-8).
-    copy : bool
-        Whether to return a copy of x.
-
-    """
-    abs = umath.absolute
-    xnew = filled(x, value)
-    if issubclass(xnew.dtype.type, numeric.floating):
-        condition = umath.less_equal(abs(xnew-value), atol+rtol*abs(value))
-        mask = getattr(x, '_mask', nomask)
-    else:
-        condition = umath.equal(xnew, value)
-        mask = nomask
-    mask = mask_or(mask, make_mask(condition, shrink=True))
-    return masked_array(xnew, mask=mask, copy=copy, fill_value=value)
-
-def masked_invalid(a, copy=True):
-    """Mask the array for invalid values (nans or infs).  Any
-    preexisting mask is conserved.
-
-    """
-    a = narray(a, copy=copy, subok=True)
-    condition = (numpy.isnan(a) | numpy.isinf(a))
-    if hasattr(a, '_mask'):
-        condition = mask_or(condition, a._mask)
-        cls = type(a)
-    else:
-        cls = MaskedArray
-    result = a.view(cls)
-    result._mask = condition
-    return result
-
-
-#####--------------------------------------------------------------------------
-#---- --- Printing options ---
-#####--------------------------------------------------------------------------
-class _MaskedPrintOption:
-    """Handle the string used to represent missing data in a masked
-    array.
-
-    """
-    def __init__ (self, display):
-        "Create the masked_print_option object."
-        self._display = display
-        self._enabled = True
-
-    def display(self):
-        "Display the string to print for masked values."
-        return self._display
-
-    def set_display (self, s):
-        "Set the string to print for masked values."
-        self._display = s
-
-    def enabled(self):
-        "Is the use of the display value enabled?"
-        return self._enabled
-
-    def enable(self, shrink=1):
-        "Set the enabling shrink to `shrink`."
-        self._enabled = shrink
-
-    def __str__ (self):
-        return str(self._display)
-
-    __repr__ = __str__
-
-#if you single index into a masked location you get this object.
-masked_print_option = _MaskedPrintOption('--')
-
-#####--------------------------------------------------------------------------
-#---- --- MaskedArray class ---
-#####--------------------------------------------------------------------------
-
-#...............................................................................
-class _arraymethod(object):
-    """Define a wrapper for basic array methods.
-
-    Upon call, returns a masked array, where the new _data array is
-    the output of the corresponding method called on the original
-    _data.
-
-    If onmask is True, the new mask is the output of the method called
-    on the initial mask. Otherwise, the new mask is just a reference
-    to the initial mask.
-
-    Parameters
-    ----------
-    _name : String
-        Name of the function to apply on data.
-    _onmask : bool
-        Whether the mask must be processed also (True) or left
-        alone (False). Default: True.
-    obj : Object
-        The object calling the arraymethod.
-
-    """
-    def __init__(self, funcname, onmask=True):
-        self._name = funcname
-        self._onmask = onmask
-        self.obj = None
-        self.__doc__ = self.getdoc()
-    #
-    def getdoc(self):
-        "Return the doc of the function (from the doc of the method)."
-        methdoc = getattr(ndarray, self._name, None)
-        methdoc = getattr(numpy, self._name, methdoc)
-        if methdoc is not None:
-            return methdoc.__doc__
-    #
-    def __get__(self, obj, objtype=None):
-        self.obj = obj
-        return self
-    #
-    def __call__(self, *args, **params):
-        methodname = self._name
-        data = self.obj._data
-        mask = self.obj._mask
-        cls = type(self.obj)
-        result = getattr(data, methodname)(*args, **params).view(cls)
-        result._update_from(self.obj)
-        if result.ndim:
-            if not self._onmask:
-                result.__setmask__(mask)
-            elif mask is not nomask:
-                result.__setmask__(getattr(mask, methodname)(*args, **params))
-        else:
-            if mask.ndim and mask.all():
-                return masked
-        return result
-#..........................................................
-
-class FlatIter(object):
-    "Define an interator."
-    def __init__(self, ma):
-        self.ma = ma
-        self.ma_iter = numpy.asarray(ma).flat
-
-        if ma._mask is nomask:
-            self.maskiter = None
-        else:
-            self.maskiter = ma._mask.flat
-
-    def __iter__(self):
-        return self
-
-    ### This won't work is ravel makes a copy
-    def __setitem__(self, index, value):
-        a = self.ma.ravel()
-        a[index] = value
-
-    def next(self):
-        d = self.ma_iter.next()
-        if self.maskiter is not None and self.maskiter.next():
-            d = masked
-        return d
-
-
-class MaskedArray(numeric.ndarray):
-    """Arrays with possibly masked values.  Masked values of True
-    exclude the corresponding element from any computation.
-
-    Construction:
-        x = MaskedArray(data, mask=nomask, dtype=None, copy=True,
-        fill_value=None, keep_mask=True, hard_mask=False, shrink=True)
-
-    Parameters
-    ----------
-    data : {var}
-        Input data.
-    mask : {nomask, sequence}
-        Mask.  Must be convertible to an array of booleans with
-        the same shape as data: True indicates a masked (eg.,
-        invalid) data.
-    dtype : dtype
-        Data type of the output. If None, the type of the data
-        argument is used.  If dtype is not None and different from
-        data.dtype, a copy is performed.
-    copy : bool
-        Whether to copy the input data (True), or to use a
-        reference instead.  Note: data are NOT copied by default.
-    subok : {True, boolean}
-        Whether to return a subclass of MaskedArray (if possible)
-        or a plain MaskedArray.
-    ndmin : {0, int}
-        Minimum number of dimensions
-    fill_value : {var}
-        Value used to fill in the masked values when necessary. If
-        None, a default based on the datatype is used.
-    keep_mask : {True, boolean}
-        Whether to combine mask with the mask of the input data,
-        if any (True), or to use only mask for the output (False).
-    hard_mask : {False, boolean}
-        Whether to use a hard mask or not. With a hard mask,
-        masked values cannot be unmasked.
-    shrink : {True, boolean}
-        Whether to force compression of an empty mask.
-
-    """
-
-    __array_priority__ = 15
-    _defaultmask = nomask
-    _defaulthardmask = False
-    _baseclass =  numeric.ndarray
-
-    def __new__(cls, data=None, mask=nomask, dtype=None, copy=False,
-                subok=True, ndmin=0, fill_value=None,
-                keep_mask=True, hard_mask=False, flag=None,shrink=True,
-                **options):
-        """Create a new masked array from scratch.
-
-        Note: you can also create an array with the .view(MaskedArray)
-        method.
-
-        """
-        if flag is not None:
-            warnings.warn("The flag 'flag' is now called 'shrink'!",
-                          DeprecationWarning)
-            shrink = flag
-        # Process data............
-        _data = narray(data, dtype=dtype, copy=copy, subok=True, ndmin=ndmin)
-        _baseclass = getattr(data, '_baseclass', type(_data))
-        _basedict = getattr(data, '_basedict', getattr(data, '__dict__', None))
-        if not isinstance(data, MaskedArray) or not subok:
-            _data = _data.view(cls)
-        else:
-            _data = _data.view(type(data))
-        # Backwards compatibility w/ numpy.core.ma .......
-        if hasattr(data,'_mask') and not isinstance(data, ndarray):
-            _data._mask = data._mask
-            _sharedmask = True
-        # Process mask ...........
-        if mask is nomask:
-            if not keep_mask:
-                if shrink:
-                    _data._mask = nomask
-                else:
-                    _data._mask = make_mask_none(_data)
-            if copy:
-                _data._mask = _data._mask.copy()
-                _data._sharedmask = False
-            else:
-                _data._sharedmask = True
-        else:
-            mask = narray(mask, dtype=MaskType, copy=copy)
-            if mask.shape != _data.shape:
-                (nd, nm) = (_data.size, mask.size)
-                if nm == 1:
-                    mask = numeric.resize(mask, _data.shape)
-                elif nm == nd:
-                    mask = fromnumeric.reshape(mask, _data.shape)
-                else:
-                    msg = "Mask and data not compatible: data size is %i, "+\
-                          "mask size is %i."
-                    raise MAError, msg % (nd, nm)
-                copy = True
-            if _data._mask is nomask:
-                _data._mask = mask
-                _data._sharedmask = not copy
-            else:
-                if not keep_mask:
-                    _data._mask = mask
-                    _data._sharedmask = not copy
-                else:
-                    _data._mask = umath.logical_or(mask, _data._mask)
-                    _data._sharedmask = False
-
-        # Update fill_value.......
-        _data._fill_value = _check_fill_value(fill_value, _data.dtype)
-        # Process extra options ..
-        _data._hardmask = hard_mask
-        _data._baseclass = _baseclass
-        _data._basedict = _basedict
-        return _data
-    #
-    def _update_from(self, obj):
-        """Copies some attributes of obj to self.
-        """
-        self._hardmask = getattr(obj, '_hardmask', self._defaulthardmask)
-        self._sharedmask = getattr(obj, '_sharedmask', False)
-        if obj is not None:
-            self._baseclass = getattr(obj, '_baseclass', type(obj))
-        else:
-            self._baseclass = ndarray
-        self._fill_value = getattr(obj, '_fill_value', None)
-        return
-    #........................
-    def __array_finalize__(self,obj):
-        """Finalizes the masked array.
-        """
-        # Get main attributes .........
-        self._mask = getattr(obj, '_mask', nomask)
-        self._update_from(obj)
-        # Update special attributes ...
-        self._basedict = getattr(obj, '_basedict', getattr(obj, '__dict__', None))
-        if self._basedict is not None:
-            self.__dict__.update(self._basedict)
-        # Finalize the mask ...........
-        if self._mask is not nomask:
-            self._mask.shape = self.shape
-        return
-    #..................................
-    def __array_wrap__(self, obj, context=None):
-        """Special hook for ufuncs.
-        Wraps the numpy array and sets the mask according to context.
-        """
-        result = obj.view(type(self))
-        result._update_from(self)
-        #..........
-        if context is not None:
-            result._mask = result._mask.copy()
-            (func, args, _) = context
-            m = reduce(mask_or, [getmaskarray(arg) for arg in args])
-            # Get the domain mask................
-            domain = ufunc_domain.get(func, None)
-            if domain is not None:
-                if len(args) > 2:
-                    d = reduce(domain, args)
-                else:
-                    d = domain(*args)
-                # Fill the result where the domain is wrong
-                try:
-                    # Binary domain: take the last value
-                    fill_value = ufunc_fills[func][-1]
-                except TypeError:
-                    # Unary domain: just use this one
-                    fill_value = ufunc_fills[func]
-                except KeyError:
-                    # Domain not recognized, use fill_value instead
-                    fill_value = self.fill_value
-                result = result.copy()
-                numpy.putmask(result, d, fill_value)
-                # Update the mask
-                if m is nomask:
-                    if d is not nomask:
-                        m = d
-                else:
-                    m |= d
-            # Make sure the mask has the proper size
-            if result.shape == () and m:
-                return masked
-            else:
-                result._mask = m
-                result._sharedmask = False
-        #....
-        return result
-    #.............................................
-    def __getitem__(self, indx):
-        """x.__getitem__(y) <==> x[y]
-
-        Return the item described by i, as a masked array.
-
-        """
-        # This test is useful, but we should keep things light...
-#        if getmask(indx) is not nomask:
-#            msg = "Masked arrays must be filled before they can be used as indices!"
-#            raise IndexError, msg
-        dout = ndarray.__getitem__(self.view(ndarray), indx)
-        m = self._mask
-        if not getattr(dout,'ndim', False):
-            # Just a scalar............
-            if m is not nomask and m[indx]:
-                return masked
-        else:
-            # Force dout to MA ........
-            dout = dout.view(type(self))
-            # Inherit attributes from self
-            dout._update_from(self)
-            # Check the fill_value ....
-            if isinstance(indx, basestring):
-                fvindx = list(self.dtype.names).index(indx)
-                dout._fill_value = self.fill_value[fvindx]
-            # Update the mask if needed
-            if m is not nomask:
-                if isinstance(indx, basestring):
-                    dout._mask = m.reshape(dout.shape)
-                else:
-                    dout._mask = ndarray.__getitem__(m, indx).reshape(dout.shape)
-#               Note: Don't try to check for m.any(), that'll take too long...
-#                mask = ndarray.__getitem__(m, indx).reshape(dout.shape)
-#                if self._shrinkmask and not m.any():
-#                    dout._mask = nomask
-#                else:
-#                    dout._mask = mask
-        return dout
-    #........................
-    def __setitem__(self, indx, value):
-        """x.__setitem__(i, y) <==> x[i]=y
-
-        Set item described by index. If value is masked, masks those
-        locations.
-
-        """
-        if self is masked:
-            raise MAError, 'Cannot alter the masked element.'
-        # This test is useful, but we should keep things light...
-#        if getmask(indx) is not nomask:
-#            msg = "Masked arrays must be filled before they can be used as indices!"
-#            raise IndexError, msg
-        if isinstance(indx, basestring):
-            ndarray.__setitem__(self._data,indx, getdata(value))
-            warnings.warn("The mask is NOT affected!")
-            return
-        #....
-        if value is masked:
-            m = self._mask
-            if m is nomask:
-                m = numpy.zeros(self.shape, dtype=MaskType)
-            m[indx] = True
-            self._mask = m
-            self._sharedmask = False
-            return
-        #....
-        dval = getdata(value).astype(self.dtype)
-        valmask = getmask(value)
-        if self._mask is nomask:
-            if valmask is not nomask:
-                self._mask = numpy.zeros(self.shape, dtype=MaskType)
-                self._mask[indx] = valmask
-        elif not self._hardmask:
-            # Unshare the mask if necessary to avoid propagation
-            self.unshare_mask()
-            self._mask[indx] = valmask
-        elif hasattr(indx, 'dtype') and (indx.dtype==bool_):
-            indx = indx * umath.logical_not(self._mask)
-        else:
-            mindx = mask_or(self._mask[indx], valmask, copy=True)
-            dindx = self._data[indx]
-            if dindx.size > 1:
-                dindx[~mindx] = dval
-            elif mindx is nomask:
-                dindx = dval
-            dval = dindx
-            self._mask[indx] = mindx
-        # Set data ..........
-        ndarray.__setitem__(self._data,indx,dval)
-    #............................................
-    def __getslice__(self, i, j):
-        """x.__getslice__(i, j) <==> x[i:j]
-
-        Return the slice described by (i, j).  The use of negative
-        indices is not supported.
-
-        """
-        return self.__getitem__(slice(i,j))
-    #........................
-    def __setslice__(self, i, j, value):
-        """x.__setslice__(i, j, value) <==> x[i:j]=value
-
-        Set the slice (i,j) of a to value. If value is masked, mask
-        those locations.
-
-        """
-        self.__setitem__(slice(i,j), value)
-    #............................................
-    def __setmask__(self, mask, copy=False):
-        """Set the mask.
-
-        """
-        if mask is not nomask:
-            mask = narray(mask, copy=copy, dtype=MaskType)
-            # We could try to check whether shrinking is needed..
-            # ... but we would waste some precious time
-#            if self._shrinkmask and not mask.any():
-#                mask = nomask
-        if self._mask is nomask:
-            self._mask = mask
-        elif self._hardmask:
-            if mask is not nomask:
-                self._mask.__ior__(mask)
-        else:
-            # This one is tricky: if we set the mask that way, we may break the
-            # propagation. But if we don't, we end up with a mask full of False
-            # and a test on nomask fails...
-            if mask is nomask:
-                self._mask = nomask
-            else:
-                self.unshare_mask()
-                self._mask.flat = mask
-        if self._mask.shape:
-            self._mask = numeric.reshape(self._mask, self.shape)
-    _set_mask = __setmask__
-    #....
-    def _get_mask(self):
-        """Return the current mask.
-
-        """
-        # We could try to force a reshape, but that wouldn't work in some cases.
-#        return self._mask.reshape(self.shape)
-        return self._mask
-    mask = property(fget=_get_mask, fset=__setmask__, doc="Mask")
-    #............................................
-    def harden_mask(self):
-        """Force the mask to hard.
-
-        """
-        self._hardmask = True
-
-    def soften_mask(self):
-        """Force the mask to soft.
-
-        """
-        self._hardmask = False
-
-    def unshare_mask(self):
-        """Copy the mask and set the sharedmask flag to False.
-
-        """
-        if self._sharedmask:
-            self._mask = self._mask.copy()
-            self._sharedmask = False
-
-    def shrink_mask(self):
-        """Reduce a mask to nomask when possible.
-
-        """
-        m = self._mask
-        if m.ndim and not m.any():
-            self._mask = nomask
-
-    #............................................
-    def _get_data(self):
-        """Return the current data, as a view of the original
-        underlying data.
-
-        """
-        return self.view(self._baseclass)
-    _data = property(fget=_get_data)
-    data = property(fget=_get_data)
-
-    def raw_data(self):
-        """Return the _data part of the MaskedArray.
-
-        DEPRECATED: You should really use ``.data`` instead...
-
-        """
-        warnings.warn('Use .data instead.', DeprecationWarning)
-        return self._data
-    #............................................
-    def _get_flat(self):
-        """Return a flat iterator.
-
-        """
-        return FlatIter(self)
-    #
-    def _set_flat (self, value):
-        """Set a flattened version of self to value.
-
-        """
-        y = self.ravel()
-        y[:] = value
-    #
-    flat = property(fget=_get_flat, fset=_set_flat,
-                    doc="Flat version of the array.")
-    #............................................
-    def get_fill_value(self):
-        """Return the filling value.
-
-        """
-        if self._fill_value is None:
-            self._fill_value = _check_fill_value(None, self.dtype)
-        return self._fill_value
-
-    def set_fill_value(self, value=None):
-        """Set the filling value to value.
-
-        If value is None, use a default based on the data type.
-
-        """
-        self._fill_value = _check_fill_value(value,self.dtype)
-
-    fill_value = property(fget=get_fill_value, fset=set_fill_value,
-                          doc="Filling value.")
-
-    def filled(self, fill_value=None):
-        """Return a copy of self._data, where masked values are filled
-        with fill_value.
-
-        If fill_value is None, self.fill_value is used instead.
-
-        Notes
-        -----
-        + Subclassing is preserved
-        + The result is NOT a MaskedArray !
-
-        Examples
-        --------
-        >>> x = array([1,2,3,4,5], mask=[0,0,1,0,1], fill_value=-999)
-        >>> x.filled()
-        array([1,2,-999,4,-999])
-        >>> type(x.filled())
-        <type 'numpy.ndarray'>
-
-        """
-        m = self._mask
-        if m is nomask or not m.any():
-            return self._data
-        #
-        if fill_value is None:
-            fill_value = self.fill_value
-        #
-        if self is masked_singleton:
-            result = numeric.asanyarray(fill_value)
-        else:
-            result = self._data.copy()
-            try:
-                numpy.putmask(result, m, fill_value)
-            except (TypeError, AttributeError):
-                fill_value = narray(fill_value, dtype=object)
-                d = result.astype(object)
-                result = fromnumeric.choose(m, (d, fill_value))
-            except IndexError:
-                #ok, if scalar
-                if self._data.shape:
-                    raise
-                elif m:
-                    result = narray(fill_value, dtype=self.dtype)
-                else:
-                    result = self._data
-        return result
-
-    def compressed(self):
-        """Return a 1-D array of all the non-masked data.
-
-        """
-        data = ndarray.ravel(self._data).view(type(self))
-        data._update_from(self)
-        if self._mask is not nomask:
-            data = data[numpy.logical_not(ndarray.ravel(self._mask))]
-        return data
-    
-    
-    def compress(self, condition, axis=None, out=None):
-        """Return a where condition is True.
-        If condition is a MaskedArray, missing values are considered as False.
-        
-        Returns
-        -------
-        A MaskedArray object.
-        
-        Notes
-        -----
-        Please note the difference with compressed() ! 
-        The output of compress has a mask, the output of compressed does not.
-    
-        """
-        # Get the basic components
-        (_data, _mask) = (self._data, self._mask)
-        # Force the condition to a regular ndarray (forget the missing values...)
-        condition = narray(condition, copy=False, subok=False)
-        #
-        _new = _data.compress(condition, axis=axis, out=out).view(type(self))
-        _new._update_from(self)
-        if _mask is not nomask:
-            _new._mask = _mask.compress(condition, axis=axis)
-        return _new
-
-    #............................................
-    def __str__(self):
-        """String representation.
-
-        """
-        if masked_print_option.enabled():
-            f = masked_print_option
-            if self is masked:
-                return str(f)
-            m = self._mask
-            if m is nomask:
-                res = self._data
-            else:
-                if m.shape == ():
-                    if m:
-                        return str(f)
-                    else:
-                        return str(self._data)
-                # convert to object array to make filled work
-#CHECK: the two lines below seem more robust than the self._data.astype
-#                res = numeric.empty(self._data.shape, object_)
-#                numeric.putmask(res,~m,self._data)
-                res = self._data.astype("|O8")
-                res[m] = f
-        else:
-            res = self.filled(self.fill_value)
-        return str(res)
-
-    def __repr__(self):
-        """Literal string representation.
-
-        """
-        with_mask = """\
-masked_%(name)s(data =
- %(data)s,
-      mask =
- %(mask)s,
-      fill_value=%(fill)s)
-"""
-        with_mask1 = """\
-masked_%(name)s(data = %(data)s,
-      mask = %(mask)s,
-      fill_value=%(fill)s)
-"""
-        n = len(self.shape)
-        name = repr(self._data).split('(')[0]
-        if n <= 1:
-            return with_mask1 % {
-                'name': name,
-                'data': str(self),
-                'mask': str(self._mask),
-                'fill': str(self.fill_value),
-                }
-        return with_mask % {
-            'name': name,
-            'data': str(self),
-            'mask': str(self._mask),
-            'fill': str(self.fill_value),
-            }
-    #............................................
-    def __add__(self, other):
-        "Add other to self, and return a new masked array."
-        return add(self, other)
-    #
-    def __sub__(self, other):
-        "Subtract other to self, and return a new masked array."
-        return subtract(self, other)
-    #
-    def __mul__(self, other):
-        "Multiply other by self, and return a new masked array."
-        return multiply(self, other)
-    #
-    def __div__(self, other):
-        "Divides other into self, and return a new masked array."
-        return divide(self, other)
-    #
-    def __truediv__(self, other):
-        "Divide other into self, and return a new masked array."
-        return true_divide(self, other)
-    #
-    def __floordiv__(self, other):
-        "Divide other into self, and return a new masked array."
-        return floor_divide(self, other)
-
-    #............................................
-    def __iadd__(self, other):
-        "Add other to self in-place."
-        ndarray.__iadd__(self._data, getdata(other))
-        m = getmask(other)
-        if self._mask is nomask:
-            self._mask = m
-        elif m is not nomask:
-            self._mask += m
-        return self
-    #....
-    def __isub__(self, other):
-        "Subtract other from self in-place."
-        ndarray.__isub__(self._data, getdata(other))
-        m = getmask(other)
-        if self._mask is nomask:
-            self._mask = m
-        elif m is not nomask:
-            self._mask += m
-        return self
-    #....
-    def __imul__(self, other):
-        "Multiply self by other in-place."
-        ndarray.__imul__(self._data, getdata(other))
-        m = getmask(other)
-        if self._mask is nomask:
-            self._mask = m
-        elif m is not nomask:
-            self._mask += m
-        return self
-    #....
-    def __idiv__(self, other):
-        "Divide self by other in-place."
-        other_data = getdata(other)
-        dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
-        other_mask = getmask(other)
-        new_mask = mask_or(other_mask, dom_mask)
-        # The following 3 lines control the domain filling
-        if dom_mask.any():
-            other_data = other_data.copy()
-            numpy.putmask(other_data, dom_mask, 1)
-        ndarray.__idiv__(self._data, other_data)
-        self._mask = mask_or(self._mask, new_mask)
-        return self
-    #............................................
-    def __float__(self):
-        "Convert to float."
-        if self._mask is not nomask:
-            warnings.warn("Warning: converting a masked element to nan.")
-            return numpy.nan
-        return float(self.item())
-
-    def __int__(self):
-        "Convert to int."
-        if self._mask is not nomask:
-            raise MAError, 'Cannot convert masked element to a Python int.'
-        return int(self.item())
-    #............................................
-    def get_imag(self):
-        result = self._data.imag.view(type(self))
-        result.__setmask__(self._mask)
-        return result
-    imag = property(fget=get_imag,doc="Imaginary part")
-
-    def get_real(self):
-        result = self._data.real.view(type(self))
-        result.__setmask__(self._mask)
-        return result
-    real = property(fget=get_real,doc="Real part")
-
-
-    #............................................
-    def count(self, axis=None):
-        """Count the non-masked elements of the array along the given
-        axis.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to count the non-masked elements. If
-            not given, all the non masked elements are counted.
-
-        Returns
-        -------
-        A masked array where the mask is True where all data are
-        masked.  If axis is None, returns either a scalar ot the
-        masked singleton if all values are masked.
-
-        """
-        m = self._mask
-        s = self.shape
-        ls = len(s)
-        if m is nomask:
-            if ls == 0:
-                return 1
-            if ls == 1:
-                return s[0]
-            if axis is None:
-                return self.size
-            else:
-                n = s[axis]
-                t = list(s)
-                del t[axis]
-                return numeric.ones(t) * n
-        n1 = numpy.size(m, axis)
-        n2 = m.astype(int_).sum(axis)
-        if axis is None:
-            return (n1-n2)
-        else:
-            return masked_array(n1 - n2)
-    #............................................
-    flatten = _arraymethod('flatten')
-    #
-    def ravel(self):
-        """Returns a 1D version of self, as a view."""
-        r = ndarray.ravel(self._data).view(type(self))
-        r._update_from(self)
-        if self._mask is not nomask:
-            r._mask = ndarray.ravel(self._mask).reshape(r.shape)
-        else:
-            r._mask = nomask
-        return r
-    #
-    repeat = _arraymethod('repeat')
-    #
-    def reshape (self, *s):
-        """Reshape the array to shape s.
-
-        Returns
-        -------
-        A new masked array.
-
-        Notes
-        -----
-        If you want to modify the shape in place, please use
-        ``a.shape = s``
-
-        """
-        result = self._data.reshape(*s).view(type(self))
-        result.__dict__.update(self.__dict__)
-        if result._mask is not nomask:
-            result._mask = self._mask.copy()
-            result._mask.shape = result.shape
-        return result
-    #
-    def resize(self, newshape, refcheck=True, order=False):
-        """Attempt to modify the size and the shape of the array in place.
-
-        The array must own its own memory and not be referenced by
-        other arrays.
-
-        Returns
-        -------
-        None.
-
-        """
-        try:
-            self._data.resize(newshape, refcheck, order)
-            if self.mask is not nomask:
-                self._mask.resize(newshape, refcheck, order)
-        except ValueError:
-            raise ValueError("Cannot resize an array that has been referenced "
-                             "or is referencing another array in this way.\n"
-                             "Use the resize function.")
-        return None
-    #
-    def put(self, indices, values, mode='raise'):
-        """Set storage-indexed locations to corresponding values.
-
-        a.put(values, indices, mode) sets a.flat[n] = values[n] for
-        each n in indices.  If ``values`` is shorter than ``indices``
-        then it will repeat.  If ``values`` has some masked values, the
-        initial mask is updated in consequence, else the corresponding
-        values are unmasked.
-
-        """
-        m = self._mask
-        # Hard mask: Get rid of the values/indices that fall on masked data
-        if self._hardmask and self._mask is not nomask:
-            mask = self._mask[indices]
-            indices = narray(indices, copy=False)
-            values = narray(values, copy=False, subok=True)
-            values.resize(indices.shape)
-            indices = indices[~mask]
-            values = values[~mask]
-        #....
-        self._data.put(indices, values, mode=mode)
-        #....
-        if m is nomask:
-            m = getmask(values)
-        else:
-            m = m.copy()
-            if getmask(values) is nomask:
-                m.put(indices, False, mode=mode)
-            else:
-                m.put(indices, values._mask, mode=mode)
-            m = make_mask(m, copy=False, shrink=True)
-        self._mask = m
-    #............................................
-    def ids (self):
-        """Return the addresses of the data and mask areas."""
-        if self._mask is nomask:
-            return (self.ctypes.data, id(nomask))
-        return (self.ctypes.data, self._mask.ctypes.data)
-    #............................................
-    def all(self, axis=None, out=None):
-        """Return True if all entries along the given axis are True,
-        False otherwise.  Masked values are considered as True during
-        computation.
-
-        Parameter
-        ----------
-            axis : int, optional
-                Axis along which the operation is performed.  If None,
-                the operation is performed on a flatten array
-            out : {MaskedArray}, optional
-                Alternate optional output.  If not None, out should be
-                a valid MaskedArray of the same shape as the output of
-                self._data.all(axis).
-
-        Returns            A masked array, where the mask is True if all data along
-        -------
-        the axis are masked.
-
-        Notes
-        -----
-        An exception is raised if ``out`` is not None and not of the
-        same type as self.
-
-        """
-        if out is None:
-            d = self.filled(True).all(axis=axis).view(type(self))
-            if d.ndim > 0:
-                d.__setmask__(self._mask.all(axis))
-            return d
-        elif type(out) is not type(self):
-            raise TypeError("The external array should have " \
-                            "a type %s (got %s instead)" %\
-                            (type(self), type(out)))
-        self.filled(True).all(axis=axis, out=out)
-        if out.ndim:
-            out.__setmask__(self._mask.all(axis))
-        return out
-
-
-    def any(self, axis=None, out=None):
-        """Returns True if at least one entry along the given axis is
-        True.
-
-        Returns False if all entries are False.
-        Masked values are considered as True during computation.
-
-        Parameter
-        ----------
-            axis : int, optional
-                Axis along which the operation is performed.
-                If None, the operation is performed on a flatten array
-            out : {MaskedArray}, optional
-                Alternate optional output.  If not None, out should be
-                a valid MaskedArray of the same shape as the output of
-                self._data.all(axis).
-
-        Returns            A masked array, where the mask is True if all data along
-        -------
-        the axis are masked.
-
-        Notes
-        -----
-        An exception is raised if ``out`` is not None and not of the
-        same type as self.
-
-        """
-        if out is None:
-            d = self.filled(False).any(axis=axis).view(type(self))
-            if d.ndim > 0:
-                d.__setmask__(self._mask.all(axis))
-            return d
-        elif type(out) is not type(self):
-            raise TypeError("The external array should have a type %s "\
-                            "(got %s instead)" %\
-                            (type(self), type(out)))
-        self.filled(False).any(axis=axis, out=out)
-        if out.ndim:
-            out.__setmask__(self._mask.all(axis))
-        return out
-
-
-    def nonzero(self):
-        """Return the indices of the elements of a that are not zero
-        nor masked, as a tuple of arrays.
-
-        There are as many tuples as dimensions of a, each tuple
-        contains the indices of the non-zero elements in that
-        dimension.  The corresponding non-zero values can be obtained
-        with ``a[a.nonzero()]``.
-
-        To group the indices by element, rather than dimension, use
-        instead: ``transpose(a.nonzero())``.
-
-        The result of this is always a 2d array, with a row for each
-        non-zero element.
-
-        """
-        return narray(self.filled(0), copy=False).nonzero()
-    #............................................
-    def trace(self, offset=0, axis1=0, axis2=1, dtype=None, out=None):
-        """a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
-
-        Return the sum along the offset diagonal of the array's
-        indicated `axis1` and `axis2`.
-
-        """
-        # TODO: What are we doing with `out`?
-        m = self._mask
-        if m is nomask:
-            result = super(MaskedArray, self).trace(offset=offset, axis1=axis1,
-                                                    axis2=axis2, out=out)
-            return result.astype(dtype)
-        else:
-            D = self.diagonal(offset=offset, axis1=axis1, axis2=axis2)
-            return D.astype(dtype).filled(0).sum(axis=None)
-    #............................................
-    def sum(self, axis=None, dtype=None):
-        """Sum the array over the given axis.
-
-        Masked elements are set to 0 internally.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : dtype, optional
-            Datatype for the intermediary computation. If not given,
-            the current dtype is used instead.
-
-        """
-        if self._mask is nomask:
-            mask = nomask
-        else:
-            mask = self._mask.all(axis)
-            if (not mask.ndim) and mask:
-                return masked
-        result = self.filled(0).sum(axis, dtype=dtype).view(type(self))
-        if result.ndim > 0:
-            result.__setmask__(mask)
-        return result
-
-    def cumsum(self, axis=None, dtype=None):
-        """Return the cumulative sum of the elements of the array
-        along the given axis.
-
-        Masked values are set to 0 internally.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
-            Datatype for the intermediary computation. If not
-            given, the current dtype is used instead.
-
-        """
-        result = self.filled(0).cumsum(axis=axis, dtype=dtype).view(type(self))
-        result.__setmask__(self.mask)
-        return result
-
-    def prod(self, axis=None, dtype=None):
-        """Return the product of the elements of the array along the
-        given axis.
-
-        Masked elements are set to 1 internally.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
-            Datatype for the intermediary computation. If not
-            given, the current dtype is used instead.
-
-        """
-        if self._mask is nomask:
-            mask = nomask
-        else:
-            mask = self._mask.all(axis)
-            if (not mask.ndim) and mask:
-                return masked
-        result = self.filled(1).prod(axis=axis, dtype=dtype).view(type(self))
-        if result.ndim:
-            result.__setmask__(mask)
-        return result
-
-    product = prod
-
-    def cumprod(self, axis=None, dtype=None):
-        """Return the cumulative product of the elements of the array
-        along the given axis.
-
-        Masked values are set to 1 internally.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
-            Datatype for the intermediary computation. If not
-            given, the current dtype is used instead.
-
-        """
-        result = self.filled(1).cumprod(axis=axis, dtype=dtype).view(type(self))
-        result.__setmask__(self.mask)
-        return result
-
-    def mean(self, axis=None, dtype=None):
-        """Average the array over the given axis.  Equivalent to
-
-        a.sum(axis, dtype) / a.size(axis).
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
-            Datatype for the intermediary computation. If not
-            given, the current dtype is used instead.
-
-        """
-        if self._mask is nomask:
-            return super(MaskedArray, self).mean(axis=axis, dtype=dtype)
-        else:
-            dsum = self.sum(axis=axis, dtype=dtype)
-            cnt = self.count(axis=axis)
-            return dsum*1./cnt
-
-    def anom(self, axis=None, dtype=None):
-        """Return the anomalies (deviations from the average) along
-        the given axis.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
-            Datatype for the intermediary computation. If not
-            given, the current dtype is used instead.
-
-        """
-        m = self.mean(axis, dtype)
-        if not axis:
-            return (self - m)
-        else:
-            return (self - expand_dims(m,axis))
-
-    def var(self, axis=None, dtype=None):
-        """Return the variance, a measure of the spread of a distribution.
-
-        The variance is the average of the squared deviations from the
-        mean, i.e. var = mean((x - x.mean())**2).
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
-            Datatype for the intermediary computation. If not
-            given, the current dtype is used instead.
-
-        Notes
-        -----
-        The value returned is a biased estimate of the true variance.
-        For the (more standard) unbiased estimate, use varu.
-
-        """
-        if self._mask is nomask:
-            # TODO: Do we keep super, or var _data and take a view ?
-            return super(MaskedArray, self).var(axis=axis, dtype=dtype)
-        else:
-            cnt = self.count(axis=axis)
-            danom = self.anom(axis=axis, dtype=dtype)
-            danom *= danom
-            dvar = narray(danom.sum(axis) / cnt).view(type(self))
-            if axis is not None:
-                dvar._mask = mask_or(self._mask.all(axis), (cnt==1))
-            dvar._update_from(self)
-            return dvar
-
-    def std(self, axis=None, dtype=None):
-        """Return the standard deviation, a measure of the spread of a
-        distribution.
-
-        The standard deviation is the square root of the average of
-        the squared deviations from the mean, i.e.
-
-        std = sqrt(mean((x - x.mean())**2)).
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
-            Datatype for the intermediary computation.
-            If not given, the current dtype is used instead.
-
-        Notes
-        -----
-        The value returned is a biased estimate of the true
-        standard deviation.  For the more standard unbiased
-        estimate, use stdu.
-
-        """
-        dvar = self.var(axis,dtype)
-        if axis is not None or dvar is not masked:
-            dvar = sqrt(dvar)
-        return dvar
-
-    #............................................
-    def argsort(self, axis=None, fill_value=None, kind='quicksort',
-                order=None):
-        """Return an ndarray of indices that sort the array along the
-        specified axis.  Masked values are filled beforehand to
-        fill_value.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis to be indirectly sorted.
-            If not given, uses a flatten version of the array.
-        fill_value : {var}
-            Value used to fill in the masked values.
-            If not given, self.fill_value is used instead.
-        kind : {string}
-            Sorting algorithm (default 'quicksort')
-            Possible values: 'quicksort', 'mergesort', or 'heapsort'
-
-        Notes
-        -----
-        This method executes an indirect sort along the given axis
-        using the algorithm specified by the kind keyword. It returns
-        an array of indices of the same shape as 'a' that index data
-        along the given axis in sorted order.
-
-        The various sorts are characterized by average speed, worst
-        case performance need for work space, and whether they are
-        stable.  A stable sort keeps items with the same key in the
-        same relative order. The three available algorithms have the
-        following properties:
-
-        |------------------------------------------------------|
-        |    kind   | speed |  worst case | work space | stable|
-        |------------------------------------------------------|
-        |'quicksort'|   1   | O(n^2)      |     0      |   no  |
-        |'mergesort'|   2   | O(n*log(n)) |    ~n/2    |   yes |
-        |'heapsort' |   3   | O(n*log(n)) |     0      |   no  |
-        |------------------------------------------------------|
-
-        All the sort algorithms make temporary copies of the data when
-        the sort is not along the last axis. Consequently, sorts along
-        the last axis are faster and use less space than sorts along
-        other axis.
-
-        """
-        if fill_value is None:
-            fill_value = default_fill_value(self)
-        d = self.filled(fill_value).view(ndarray)
-        return d.argsort(axis=axis, kind=kind, order=order)
-    #........................
-    def argmin(self, axis=None, fill_value=None):
-        """Return an ndarray of indices for the minimum values of a
-        along the specified axis.
-
-        Masked values are treated as if they had the value fill_value.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        fill_value : {var}, optional
-            Value used to fill in the masked values.  If None, the
-            output of minimum_fill_value(self._data) is used.
-
-        """
-        if fill_value is None:
-            fill_value = minimum_fill_value(self)
-        d = self.filled(fill_value).view(ndarray)
-        return d.argmin(axis)
-    #........................
-    def argmax(self, axis=None, fill_value=None):
-        """Returns the array of indices for the maximum values of `a`
-        along the specified axis.
-
-        Masked values are treated as if they had the value fill_value.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        fill_value : {var}, optional
-            Value used to fill in the masked values.  If None, the
-            output of maximum_fill_value(self._data) is used.
-
-        """
-        if fill_value is None:
-            fill_value = maximum_fill_value(self._data)
-        d = self.filled(fill_value).view(ndarray)
-        return d.argmax(axis)
-
-    def sort(self, axis=-1, kind='quicksort', order=None,
-             endwith=True, fill_value=None):
-        """Sort along the given axis.
-
-        Parameters
-        ----------
-        axis : int
-            Axis to be indirectly sorted.
-        kind : {string}
-            Sorting algorithm (default 'quicksort')
-            Possible values: 'quicksort', 'mergesort', or 'heapsort'.
-        order : {var}
-            If a has fields defined, then the order keyword can be
-            the field name to sort on or a list (or tuple) of
-            field names to indicate the order that fields should
-            be used to define the sort.
-        fill_value : {var}
-            Value used to fill in the masked values.  If None, use
-            the the output of minimum_fill_value().
-        endwith : bool
-            Whether missing values (if any) should be forced in
-            the upper indices (at the end of the array) (True) or
-            lower indices (at the beginning).
-
-        Returns
-        -------
-        When used as method, returns None.
-            When used as a function, returns an array.
-
-        Notes
-        -----
-        This method sorts 'a' in place along the given axis using
-        the algorithm specified by the kind keyword.
-
-        The various sorts may characterized by average speed,
-        worst case performance need for work space, and whether
-        they are stable.  A stable sort keeps items with the same
-        key in the same relative order and is most useful when
-        used w/ argsort where the key might differ from the items
-        being sorted.  The three available algorithms have the
-        following properties:
-
-        |------------------------------------------------------|
-        |    kind   | speed |  worst case | work space | stable|
-        |------------------------------------------------------|
-        |'quicksort'|   1   | O(n^2)      |     0      |   no  |
-        |'mergesort'|   2   | O(n*log(n)) |    ~n/2    |   yes |
-        |'heapsort' |   3   | O(n*log(n)) |     0      |   no  |
-        |------------------------------------------------------|
-
-        """
-        if self._mask is nomask:
-            ndarray.sort(self,axis=axis, kind=kind, order=order)
-        else:
-            if fill_value is None:
-                if endwith:
-                    filler = minimum_fill_value(self)
-                else:
-                    filler = maximum_fill_value(self)
-            else:
-                filler = fill_value
-            idx = numpy.indices(self.shape)
-            idx[axis] = self.filled(filler).argsort(axis=axis,kind=kind,order=order)
-            idx_l = idx.tolist()
-            tmp_mask = self._mask[idx_l].flat
-            tmp_data = self._data[idx_l].flat
-            self.flat = tmp_data
-            self._mask.flat = tmp_mask
-        return
-
-    #............................................
-    def min(self, axis=None, fill_value=None):
-        """Return the minimum of a along the given axis.
-
-        Masked values are filled with fill_value.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        fill_value : {var}, optional
-            Value used to fill in the masked values.
-            If None, use the the output of minimum_fill_value().
-
-    """
-        mask = self._mask
-        # Check all/nothing case ......
-        if mask is nomask:
-            return super(MaskedArray, self).min(axis=axis)
-        elif (not mask.ndim) and mask:
-            return masked
-        # Get the mask ................
-        if axis is None:
-            mask = umath.logical_and.reduce(mask.flat)
-        else:
-            mask = umath.logical_and.reduce(mask, axis=axis)
-        # Skip if all masked ..........
-        if not mask.ndim and mask:
-            return masked
-        # Get the fill value ...........
-        if fill_value is None:
-            fill_value = minimum_fill_value(self)
-        # Get the data ................
-        result = self.filled(fill_value).min(axis=axis).view(type(self))
-        if result.ndim > 0:
-            result._mask = mask
-        return result
-
-    def mini(self, axis=None):
-        if axis is None:
-            return minimum(self)
-        else:
-            return minimum.reduce(self, axis)
-
-    #........................
-    def max(self, axis=None, fill_value=None):
-        """Return the maximum/a along the given axis.
-
-        Masked values are filled with fill_value.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        fill_value : {var}, optional
-            Value used to fill in the masked values.
-            If None, use the the output of maximum_fill_value().
-        """
-        mask = self._mask
-        # Check all/nothing case ......
-        if mask is nomask:
-            return super(MaskedArray, self).max(axis=axis)
-        elif (not mask.ndim) and mask:
-            return masked
-        # Check the mask ..............
-        if axis is None:
-            mask = umath.logical_and.reduce(mask.flat)
-        else:
-            mask = umath.logical_and.reduce(mask, axis=axis)
-        # Skip if all masked ..........
-        if not mask.ndim and mask:
-            return masked
-        # Get the fill value ..........
-        if fill_value is None:
-            fill_value = maximum_fill_value(self)
-        # Get the data ................
-        result = self.filled(fill_value).max(axis=axis).view(type(self))
-        if result.ndim > 0:
-            result._mask = mask
-        return result
-    #........................
-    def ptp(self, axis=None, fill_value=None):
-        """Return the visible data range (max-min) along the given axis.
-
-        Parameters
-        ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        fill_value : {var}, optional
-            Value used to fill in the masked values.  If None, the
-            maximum uses the maximum default, the minimum uses the
-            minimum default.
-
-        """
-        return self.max(axis, fill_value) - self.min(axis, fill_value)
-
-    # Array methods ---------------------------------------
-    copy = _arraymethod('copy')
-    diagonal = _arraymethod('diagonal')
-    take = _arraymethod('take')
-    transpose = _arraymethod('transpose')
-    T = property(fget=lambda self:self.transpose())
-    swapaxes = _arraymethod('swapaxes')
-    clip = _arraymethod('clip', onmask=False)
-    copy = _arraymethod('copy')
-    squeeze = _arraymethod('squeeze')
-    #--------------------------------------------
-    def tolist(self, fill_value=None):
-        """Copy the data portion of the array to a hierarchical python
-        list and returns that list.
-
-        Data items are converted to the nearest compatible Python
-        type.  Masked values are converted to fill_value. If
-        fill_value is None, the corresponding entries in the output
-        list will be ``None``.
-
-        """
-        if fill_value is not None:
-            return self.filled(fill_value).tolist()
-        result = self.filled().tolist()
-        # Set temps to save time when dealing w/ mrecarrays...
-        _mask = self._mask
-        if _mask is nomask:
-            return result
-        nbdims = self.ndim
-        dtypesize = len(self.dtype)
-        if nbdims == 0:
-            return tuple([None]*dtypesize)
-        elif nbdims == 1:
-            maskedidx = _mask.nonzero()[0].tolist()
-            if dtypesize:
-                nodata = tuple([None]*dtypesize)
-            else:
-                nodata = None
-            [operator.setitem(result,i,nodata) for i in maskedidx]
-        else:
-            for idx in zip(*[i.tolist() for i in _mask.nonzero()]):
-                tmp = result
-                for i in idx[:-1]:
-                    tmp = tmp[i]
-                tmp[idx[-1]] = None
-        return result
-    #........................
-    def tostring(self, fill_value=None, order='C'):
-        """Return a copy of array data as a Python string containing the raw
-        bytes in the array.
-
-        Parameters
-        ----------
-        fill_value : {var}, optional
-            Value used to fill in the masked values.
-            If None, uses self.fill_value instead.
-        order : {string}
-            Order of the data item in the copy {"C","F","A"}.
-            "C"       -- C order (row major)
-            "Fortran" -- Fortran order (column major)
-            "Any"     -- Current order of array.
-            None      -- Same as "Any"
-
-        """
-        return self.filled(fill_value).tostring(order=order)
-    #--------------------------------------------
-    # Pickling
-    def __getstate__(self):
-        """Return the internal state of the masked array, for pickling
-        purposes.
-
-        """
-        state = (1,
-                 self.shape,
-                 self.dtype,
-                 self.flags.fnc,
-                 self._data.tostring(),
-                 getmaskarray(self).tostring(),
-                 self._fill_value,
-                 )
-        return state
-    #
-    def __setstate__(self, state):
-        """Restore the internal state of the masked array, for
-        pickling purposes.  ``state`` is typically the output of the
-        ``__getstate__`` output, and is a 5-tuple:
-
-        - class name
-        - a tuple giving the shape of the data
-        - a typecode for the data
-        - a binary string for the data
-        - a binary string for the mask.
-
-        """
-        (ver, shp, typ, isf, raw, msk, flv) = state
-        ndarray.__setstate__(self, (shp, typ, isf, raw))
-        self._mask.__setstate__((shp, dtype(bool), isf, msk))
-        self.fill_value = flv
-    #
-    def __reduce__(self):
-        """Return a 3-tuple for pickling a MaskedArray.
-
-        """
-        return (_mareconstruct,
-                (self.__class__, self._baseclass, (0,), 'b', ),
-                self.__getstate__())
-
-
-def _mareconstruct(subtype, baseclass, baseshape, basetype,):
-    """Internal function that builds a new MaskedArray from the
-    information stored in a pickle.
-
-    """
-    _data = ndarray.__new__(baseclass, baseshape, basetype)
-    _mask = ndarray.__new__(ndarray, baseshape, 'b1')
-    return subtype.__new__(subtype, _data, mask=_mask, dtype=basetype,)
-
-
-#####--------------------------------------------------------------------------
-#---- --- Shortcuts ---
-#####---------------------------------------------------------------------------
-def isMaskedArray(x):
-    "Is x a masked array, that is, an instance of MaskedArray?"
-    return isinstance(x, MaskedArray)
-isarray = isMaskedArray
-isMA = isMaskedArray  #backward compatibility
-# We define the masked singleton as a float for higher precedence...
-# Note that it can be tricky sometimes w/ type comparison
-masked_singleton = MaskedArray(0, dtype=float_, mask=True)
-masked = masked_singleton
-
-masked_array = MaskedArray
-
-def array(data, dtype=None, copy=False, order=False,
-          mask=nomask, fill_value=None,
-          keep_mask=True, hard_mask=False, shrink=True, subok=True, ndmin=0,
-          ):
-    """array(data, dtype=None, copy=False, order=False, mask=nomask,
-             fill_value=None, keep_mask=True, hard_mask=False, shrink=True,
-             subok=True, ndmin=0)
-
-    Acts as shortcut to MaskedArray, with options in a different order
-    for convenience.  And backwards compatibility...
-
-    """
-    #TODO: we should try to put 'order' somwehere
-    return MaskedArray(data, mask=mask, dtype=dtype, copy=copy, subok=subok,
-                       keep_mask=keep_mask, hard_mask=hard_mask,
-                       fill_value=fill_value, ndmin=ndmin, shrink=shrink)
-array.__doc__ = masked_array.__doc__
-
-def is_masked(x):
-    """Does x have masked values?"""
-    m = getmask(x)
-    if m is nomask:
-        return False
-    elif m.any():
-        return True
-    return False
-
-
-#####---------------------------------------------------------------------------
-#---- --- Extrema functions ---
-#####---------------------------------------------------------------------------
-class _extrema_operation(object):
-    "Generic class for maximum/minimum functions."
-    def __call__(self, a, b=None):
-        "Executes the call behavior."
-        if b is None:
-            return self.reduce(a)
-        return where(self.compare(a, b), a, b)
-    #.........
-    def reduce(self, target, axis=None):
-        "Reduce target along the given axis."
-        target = narray(target, copy=False, subok=True)
-        m = getmask(target)
-        if axis is not None:
-            kargs = { 'axis' : axis }
-        else:
-            kargs = {}
-            target = target.ravel()
-            if not (m is nomask):
-                m = m.ravel()
-        if m is nomask:
-            t = self.ufunc.reduce(target, **kargs)
-        else:
-            target = target.filled(self.fill_value_func(target)).view(type(target))
-            t = self.ufunc.reduce(target, **kargs)
-            m = umath.logical_and.reduce(m, **kargs)
-            if hasattr(t, '_mask'):
-                t._mask = m
-            elif m:
-                t = masked
-        return t
-    #.........
-    def outer (self, a, b):
-        "Return the function applied to the outer product of a and b."
-        ma = getmask(a)
-        mb = getmask(b)
-        if ma is nomask and mb is nomask:
-            m = nomask
-        else:
-            ma = getmaskarray(a)
-            mb = getmaskarray(b)
-            m = logical_or.outer(ma, mb)
-        result = self.ufunc.outer(filled(a), filled(b))
-        result._mask = m
-        return result
-
-#............................
-class _minimum_operation(_extrema_operation):
-    "Object to calculate minima"
-    def __init__ (self):
-        """minimum(a, b) or minimum(a)
-In one argument case, returns the scalar minimum.
-        """
-        self.ufunc = umath.minimum
-        self.afunc = amin
-        self.compare = less
-        self.fill_value_func = minimum_fill_value
-
-#............................
-class _maximum_operation(_extrema_operation):
-    "Object to calculate maxima"
-    def __init__ (self):
-        """maximum(a, b) or maximum(a)
-           In one argument case returns the scalar maximum.
-        """
-        self.ufunc = umath.maximum
-        self.afunc = amax
-        self.compare = greater
-        self.fill_value_func = maximum_fill_value
-
-#..........................................................
-def min(array, axis=None, out=None):
-    """Return the minima along the given axis.
-
-    If `axis` is None, applies to the flattened array.
-
-    """
-    if out is not None:
-        raise TypeError("Output arrays Unsupported for masked arrays")
-    if axis is None:
-        return minimum(array)
-    else:
-        return minimum.reduce(array, axis)
-min.__doc__ = MaskedArray.min.__doc__
-#............................
-def max(obj, axis=None, out=None):
-    if out is not None:
-        raise TypeError("Output arrays Unsupported for masked arrays")
-    if axis is None:
-        return maximum(obj)
-    else:
-        return maximum.reduce(obj, axis)
-max.__doc__ = MaskedArray.max.__doc__
-#.............................
-def ptp(obj, axis=None):
-    """a.ptp(axis=None) =  a.max(axis)-a.min(axis)"""
-    try:
-        return obj.max(axis)-obj.min(axis)
-    except AttributeError:
-        return max(obj, axis=axis) - min(obj, axis=axis)
-ptp.__doc__ = MaskedArray.ptp.__doc__
-
-
-#####---------------------------------------------------------------------------
-#---- --- Definition of functions from the corresponding methods ---
-#####---------------------------------------------------------------------------
-class _frommethod:
-    """Define functions from existing MaskedArray methods.
-
-    Parameters
-    ----------
-        _methodname : string
-            Name of the method to transform.
-
-    """
-    def __init__(self, methodname):
-        self._methodname = methodname
-        self.__doc__ = self.getdoc()
-    def getdoc(self):
-        "Return the doc of the function (from the doc of the method)."
-        try:
-            return getattr(MaskedArray, self._methodname).__doc__
-        except:
-            return getattr(numpy, self._methodname).__doc__
-    def __call__(self, a, *args, **params):
-        if isinstance(a, MaskedArray):
-            return getattr(a, self._methodname).__call__(*args, **params)
-        #FIXME ----
-        #As x is not a MaskedArray, we transform it to a ndarray with asarray
-        #... and call the corresponding method.
-        #Except that sometimes it doesn't work (try reshape([1,2,3,4],(2,2)))
-        #we end up with a "SystemError: NULL result without error in PyObject_Call"
-        #A dirty trick is then to call the initial numpy function...
-        method = getattr(narray(a, copy=False), self._methodname)
-        try:
-            return method(*args, **params)
-        except SystemError:
-            return getattr(numpy,self._methodname).__call__(a, *args, **params)
-
-all = _frommethod('all')
-anomalies = anom = _frommethod('anom')
-any = _frommethod('any')
-conjugate = _frommethod('conjugate')
-ids = _frommethod('ids')
-nonzero = _frommethod('nonzero')
-diagonal = _frommethod('diagonal')
-maximum = _maximum_operation()
-mean = _frommethod('mean')
-minimum = _minimum_operation ()
-product = _frommethod('prod')
-ptp = _frommethod('ptp')
-ravel = _frommethod('ravel')
-repeat = _frommethod('repeat')
-std = _frommethod('std')
-sum = _frommethod('sum')
-swapaxes = _frommethod('swapaxes')
-take = _frommethod('take')
-var = _frommethod('var')
-compress = _frommethod('compress')
-
-#..............................................................................
-def power(a, b, third=None):
-    """Computes a**b elementwise.
-
-    Masked values are set to 1.
-
-    """
-    if third is not None:
-        raise MAError, "3-argument power not supported."
-    ma = getmask(a)
-    mb = getmask(b)
-    m = mask_or(ma, mb)
-    fa = getdata(a)
-    fb = getdata(b)
-    if fb.dtype.char in typecodes["Integer"]:
-        return masked_array(umath.power(fa, fb), m)
-    md = make_mask((fa < 0), shrink=True)
-    m = mask_or(m, md)
-    if m is nomask:
-        return masked_array(umath.power(fa, fb))
-    else:
-        fa = fa.copy()
-        fa[(fa < 0)] = 1
-        return masked_array(umath.power(fa, fb), m)
-
-#..............................................................................
-def argsort(a, axis=None, kind='quicksort', order=None, fill_value=None):
-    "Function version of the eponymous method."
-    if fill_value is None:
-        fill_value = default_fill_value(a)
-    d = filled(a, fill_value)
-    if axis is None:
-        return d.argsort(kind=kind, order=order)
-    return d.argsort(axis, kind=kind, order=order)
-argsort.__doc__ = MaskedArray.argsort.__doc__
-
-def argmin(a, axis=None, fill_value=None):
-    "Function version of the eponymous method."
-    if fill_value is None:
-        fill_value = default_fill_value(a)
-    d = filled(a, fill_value)
-    return d.argmin(axis=axis)
-argmin.__doc__ = MaskedArray.argmin.__doc__
-
-def argmax(a, axis=None, fill_value=None):
-    "Function version of the eponymous method."
-    if fill_value is None:
-        fill_value = default_fill_value(a)
-        try:
-            fill_value = - fill_value
-        except:
-            pass
-    d = filled(a, fill_value)
-    return d.argmax(axis=axis)
-argmin.__doc__ = MaskedArray.argmax.__doc__
-
-def sort(a, axis=-1, kind='quicksort', order=None, endwith=True, fill_value=None):
-    "Function version of the eponymous method."
-    a = narray(a, copy=False, subok=True)
-    if fill_value is None:
-        if endwith:
-            filler = minimum_fill_value(a)
-        else:
-            filler = maximum_fill_value(a)
-    else:
-        filler = fill_value
-#    return
-    indx = numpy.indices(a.shape).tolist()
-    indx[axis] = filled(a,filler).argsort(axis=axis,kind=kind,order=order)
-    return a[indx]
-sort.__doc__ = MaskedArray.sort.__doc__
-
-
-def compressed(x):
-    """Return a 1-D array of all the non-masked data."""
-    if getmask(x) is nomask:
-        return x
-    else:
-        return x.compressed()
-
-def concatenate(arrays, axis=0):
-    "Concatenate the arrays along the given axis."
-    d = numpy.concatenate([getdata(a) for a in arrays], axis)
-    rcls = get_masked_subclass(*arrays)
-    data = d.view(rcls)
-    # Check whether one of the arrays has a non-empty mask...
-    for x in arrays:
-        if getmask(x) is not nomask:
-            break
-    else:
-        return data
-    # OK, so we have to concatenate the masks
-    dm = numpy.concatenate([getmaskarray(a) for a in arrays], axis)
-    # If we decide to keep a '_shrinkmask' option, we want to check that ...
-    # ... all of them are True, and then check for dm.any()
-#    shrink = numpy.logical_or.reduce([getattr(a,'_shrinkmask',True) for a in arrays])
-#    if shrink and not dm.any():
-    if not dm.any():
-        data._mask = nomask
-    else:
-        data._mask = dm.reshape(d.shape)
-    return data
-
-def count(a, axis = None):
-    return masked_array(a, copy=False).count(axis)
-count.__doc__ = MaskedArray.count.__doc__
-
-
-def expand_dims(x,axis):
-    """Expand the shape of the array by including a new axis before
-    the given one.
-
-    """
-    result = n_expand_dims(x,axis)
-    if isinstance(x, MaskedArray):
-        new_shape = result.shape
-        result = x.view()
-        result.shape = new_shape
-        if result._mask is not nomask:
-            result._mask.shape = new_shape
-    return result
-
-#......................................
-def left_shift (a, n):
-    "Left shift n bits."
-    m = getmask(a)
-    if m is nomask:
-        d = umath.left_shift(filled(a), n)
-        return masked_array(d)
-    else:
-        d = umath.left_shift(filled(a, 0), n)
-        return masked_array(d, mask=m)
-
-def right_shift (a, n):
-    "Right shift n bits."
-    m = getmask(a)
-    if m is nomask:
-        d = umath.right_shift(filled(a), n)
-        return masked_array(d)
-    else:
-        d = umath.right_shift(filled(a, 0), n)
-        return masked_array(d, mask=m)
-
-#......................................
-def put(a, indices, values, mode='raise'):
-    """Set storage-indexed locations to corresponding values.
-
-    Values and indices are filled if necessary.
-
-    """
-    # We can't use 'frommethod', the order of arguments is different
-    try:
-        return a.put(indices, values, mode=mode)
-    except AttributeError:
-        return narray(a, copy=False).put(indices, values, mode=mode)
-
-def putmask(a, mask, values): #, mode='raise'):
-    """Set a.flat[n] = values[n] for each n where mask.flat[n] is true.
-
-    If values is not the same size of a and mask then it will repeat
-    as necessary.  This gives different behavior than
-    a[mask] = values.
-
-    Note: Using a masked array as values will NOT transform a ndarray in
-          a maskedarray.
-
-    """
-    # We can't use 'frommethod', the order of arguments is different
-    if not isinstance(a, MaskedArray):
-        a = a.view(MaskedArray)
-    (valdata, valmask) = (getdata(values), getmask(values))
-    if getmask(a) is nomask:
-        if valmask is not nomask:
-            a._sharedmask = True
-            a.mask = numpy.zeros(a.shape, dtype=bool_)
-            numpy.putmask(a._mask, mask, valmask)
-    elif a._hardmask:
-        if valmask is not nomask:
-            m = a._mask.copy()
-            numpy.putmask(m, mask, valmask)
-            a.mask |= m
-    else:
-        if valmask is nomask:
-            valmask = getmaskarray(values)
-        numpy.putmask(a._mask, mask, valmask)
-    numpy.putmask(a._data, mask, valdata)
-    return
-
-def transpose(a,axes=None):
-    """Return a view of the array with dimensions permuted according to axes,
-    as a masked array.
-
-    If ``axes`` is None (default), the output view has reversed
-    dimensions compared to the original.
-
-    """
-    #We can't use 'frommethod', as 'transpose' doesn't take keywords
-    try:
-        return a.transpose(axes)
-    except AttributeError:
-        return narray(a, copy=False).transpose(axes).view(MaskedArray)
-
-def reshape(a, new_shape):
-    """Change the shape of the array a to new_shape."""
-    #We can't use 'frommethod', it whine about some parameters. Dmmit.
-    try:
-        return a.reshape(new_shape)
-    except AttributeError:
-        return narray(a, copy=False).reshape(new_shape).view(MaskedArray)
-
-def resize(x, new_shape):
-    """Return a new array with the specified shape.
-
-    The total size of the original array can be any size.  The new
-    array is filled with repeated copies of a. If a was masked, the
-    new array will be masked, and the new mask will be a repetition of
-    the old one.
-
-    """
-    # We can't use _frommethods here, as N.resize is notoriously whiny.
-    m = getmask(x)
-    if m is not nomask:
-        m = numpy.resize(m, new_shape)
-    result = numpy.resize(x, new_shape).view(get_masked_subclass(x))
-    if result.ndim:
-        result._mask = m
-    return result
-
-
-#................................................
-def rank(obj):
-    "maskedarray version of the numpy function."
-    return fromnumeric.rank(getdata(obj))
-rank.__doc__ = numpy.rank.__doc__
-#
-def shape(obj):
-    "maskedarray version of the numpy function."
-    return fromnumeric.shape(getdata(obj))
-shape.__doc__ = numpy.shape.__doc__
-#
-def size(obj, axis=None):
-    "maskedarray version of the numpy function."
-    return fromnumeric.size(getdata(obj), axis)
-size.__doc__ = numpy.size.__doc__
-#................................................
-
-#####--------------------------------------------------------------------------
-#---- --- Extra functions ---
-#####--------------------------------------------------------------------------
-def where (condition, x=None, y=None):
-    """where(condition | x, y)
-
-    Returns a (subclass of) masked array, shaped like condition, where
-    the elements are x when condition is True, and y otherwise.  If
-    neither x nor y are given, returns a tuple of indices where
-    condition is True (a la condition.nonzero()).
-
-    Parameters
-    ----------
-    condition : {var}
-        The condition to meet. Must be convertible to an integer
-        array.
-    x : {var}, optional
-        Values of the output when the condition is met
-    y : {var}, optional
-        Values of the output when the condition is not met.
-
-    """
-    if x is None and y is None:
-        return filled(condition, 0).nonzero()
-    elif x is None or y is None:
-        raise ValueError, "Either both or neither x and y should be given."
-    # Get the condition ...............
-    fc = filled(condition, 0).astype(bool_)
-    notfc = numpy.logical_not(fc)
-    # Get the data ......................................
-    xv = getdata(x)
-    yv = getdata(y)
-    if x is masked:
-        ndtype = yv.dtype
-        xm = numpy.ones(fc.shape, dtype=MaskType)
-    elif y is masked:
-        ndtype = xv.dtype
-        ym = numpy.ones(fc.shape, dtype=MaskType)
-    else:
-        ndtype = numpy.max([xv.dtype, yv.dtype])
-        xm = getmask(x)
-    d = numpy.empty(fc.shape, dtype=ndtype).view(MaskedArray)
-    numpy.putmask(d._data, fc, xv.astype(ndtype))
-    numpy.putmask(d._data, notfc, yv.astype(ndtype))
-    d._mask = numpy.zeros(fc.shape, dtype=MaskType)
-    numpy.putmask(d._mask, fc, getmask(x))
-    numpy.putmask(d._mask, notfc, getmask(y))
-    d._mask |= getmaskarray(condition)
-    if not d._mask.any():
-        d._mask = nomask
-    return d
-
-def choose (indices, t, out=None, mode='raise'):
-    "Return array shaped like indices with elements chosen from t"
-    #TODO: implement options `out` and `mode`, if possible.
-    def fmask (x):
-        "Returns the filled array, or True if masked."
-        if x is masked:
-            return 1
-        return filled(x)
-    def nmask (x):
-        "Returns the mask, True if ``masked``, False if ``nomask``."
-        if x is masked:
-            return 1
-        m = getmask(x)
-        if m is nomask:
-            return 0
-        return m
-    c = filled(indices, 0)
-    masks = [nmask(x) for x in t]
-    a = [fmask(x) for x in t]
-    d = numpy.choose(c, a)
-    m = numpy.choose(c, masks)
-    m = make_mask(mask_or(m, getmask(indices)), copy=0, shrink=True)
-    return masked_array(d, mask=m)
-
-def round_(a, decimals=0, out=None):
-    """Return a copy of a, rounded to 'decimals' places.
-
-    When 'decimals' is negative, it specifies the number of positions
-    to the left of the decimal point.  The real and imaginary parts of
-    complex numbers are rounded separately. Nothing is done if the
-    array is not of float type and 'decimals' is greater than or equal
-    to 0.
-
-    Parameters
-    ----------
-    decimals : int
-        Number of decimals to round to. May be negative.
-    out : array_like
-        Existing array to use for output.
-        If not given, returns a default copy of a.
-
-    Notes
-    -----
-    If out is given and does not have a mask attribute, the mask of a
-    is lost!
-
-    """
-    if out is None:
-        result = fromnumeric.round_(getdata(a), decimals, out)
-        if isinstance(a,MaskedArray):
-            result = result.view(type(a))
-            result._mask = a._mask
-        else:
-            result = result.view(MaskedArray)
-        return result
-    else:
-        fromnumeric.round_(getdata(a), decimals, out)
-        if hasattr(out, '_mask'):
-            out._mask = getmask(a)
-        return out
-
-def arange(stop, start=None, step=1, dtype=None):
-    "maskedarray version of the numpy function."
-    return numpy.arange(stop, start, step, dtype).view(MaskedArray)
-arange.__doc__ = numpy.arange.__doc__
-
-def inner(a, b):
-    "maskedarray version of the numpy function."
-    fa = filled(a, 0)
-    fb = filled(b, 0)
-    if len(fa.shape) == 0:
-        fa.shape = (1,)
-    if len(fb.shape) == 0:
-        fb.shape = (1,)
-    return numpy.inner(fa, fb).view(MaskedArray)
-inner.__doc__ = numpy.inner.__doc__
-inner.__doc__ += doc_note("Masked values are replaced by 0.")
-innerproduct = inner
-
-def outer(a, b):
-    "maskedarray version of the numpy function."
-    fa = filled(a, 0).ravel()
-    fb = filled(b, 0).ravel()
-    d = numeric.outer(fa, fb)
-    ma = getmask(a)
-    mb = getmask(b)
-    if ma is nomask and mb is nomask:
-        return masked_array(d)
-    ma = getmaskarray(a)
-    mb = getmaskarray(b)
-    m = make_mask(1-numeric.outer(1-ma, 1-mb), copy=0)
-    return masked_array(d, mask=m)
-outer.__doc__ = numpy.outer.__doc__
-outer.__doc__ += doc_note("Masked values are replaced by 0.")
-outerproduct = outer
-
-def allequal (a, b, fill_value=True):
-    """Return True if all entries of a and b are equal, using
-    fill_value as a truth value where either or both are masked.
-
-    """
-    m = mask_or(getmask(a), getmask(b))
-    if m is nomask:
-        x = getdata(a)
-        y = getdata(b)
-        d = umath.equal(x, y)
-        return d.all()
-    elif fill_value:
-        x = getdata(a)
-        y = getdata(b)
-        d = umath.equal(x, y)
-        dm = array(d, mask=m, copy=False)
-        return dm.filled(True).all(None)
-    else:
-        return False
-
-def allclose (a, b, fill_value=True, rtol=1.e-5, atol=1.e-8):
-    """ Return True if all elements of a and b are equal subject to
-    given tolerances.
-
-    If fill_value is True, masked values are considered equal.
-    If fill_value is False, masked values considered unequal.
-    The relative error rtol should be positive and << 1.0
-    The absolute error atol comes into play for those elements of b
-    that are very small or zero; it says how small `a` must be also.
-
-    """
-    m = mask_or(getmask(a), getmask(b))
-    d1 = getdata(a)
-    d2 = getdata(b)
-    x = filled(array(d1, copy=0, mask=m), fill_value).astype(float)
-    y = filled(array(d2, copy=0, mask=m), 1).astype(float)
-    d = umath.less_equal(umath.absolute(x-y), atol + rtol * umath.absolute(y))
-    return fromnumeric.alltrue(fromnumeric.ravel(d))
-
-#..............................................................................
-def asarray(a, dtype=None):
-    """asarray(data, dtype) = array(data, dtype, copy=0, subok=0)
-
-    Return a as a MaskedArray object of the given dtype.
-    If dtype is not given or None, is is set to the dtype of a.
-    No copy is performed if a is already an array.
-    Subclasses are converted to the base class MaskedArray.
-
-    """
-    return masked_array(a, dtype=dtype, copy=False, keep_mask=True, subok=False)
-
-def asanyarray(a, dtype=None):
-    """asanyarray(data, dtype) = array(data, dtype, copy=0, subok=1)
-
-    Return a as an masked array.
-    If dtype is not given or None, is is set to the dtype of a.
-    No copy is performed if a is already an array.
-    Subclasses are conserved.
-
-    """
-    return masked_array(a, dtype=dtype, copy=False, keep_mask=True, subok=True)
-
-
-def empty(new_shape, dtype=float):
-    "maskedarray version of the numpy function."
-    return numpy.empty(new_shape, dtype).view(MaskedArray)
-empty.__doc__ = numpy.empty.__doc__
-
-def empty_like(a):
-    "maskedarray version of the numpy function."
-    return numpy.empty_like(a).view(MaskedArray)
-empty_like.__doc__ = numpy.empty_like.__doc__
-
-def ones(new_shape, dtype=float):
-    "maskedarray version of the numpy function."
-    return numpy.ones(new_shape, dtype).view(MaskedArray)
-ones.__doc__ = numpy.ones.__doc__
-
-def zeros(new_shape, dtype=float):
-    "maskedarray version of the numpy function."
-    return numpy.zeros(new_shape, dtype).view(MaskedArray)
-zeros.__doc__ = numpy.zeros.__doc__
-
-#####--------------------------------------------------------------------------
-#---- --- Pickling ---
-#####--------------------------------------------------------------------------
-def dump(a,F):
-    """Pickle the MaskedArray `a` to the file `F`.  `F` can either be
-    the handle of an exiting file, or a string representing a file
-    name.
-
-    """
-    if not hasattr(F,'readline'):
-        F = open(F,'w')
-    return cPickle.dump(a,F)
-
-def dumps(a):
-    """Return a string corresponding to the pickling of the
-    MaskedArray.
-
-    """
-    return cPickle.dumps(a)
-
-def load(F):
-    """Wrapper around ``cPickle.load`` which accepts either a
-    file-like object or a filename.
-
-    """
-    if not hasattr(F, 'readline'):
-        F = open(F,'r')
-    return cPickle.load(F)
-
-def loads(strg):
-    "Load a pickle from the current string."""
-    return cPickle.loads(strg)
-
-################################################################################

Copied: trunk/numpy/ma/core.py (from rev 4777, branches/maskedarray/numpy/ma/core.py)

Deleted: trunk/numpy/ma/extras.py
===================================================================
--- branches/maskedarray/numpy/ma/extras.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/extras.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,802 +0,0 @@
-"""Masked arrays add-ons.
-
-A collection of utilities for maskedarray
-
-:author: Pierre Gerard-Marchant
-:contact: pierregm_at_uga_dot_edu
-:version: $Id: extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $
-"""
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
-__all__ = [
-'apply_along_axis', 'atleast_1d', 'atleast_2d', 'atleast_3d', 'average',
-'vstack', 'hstack', 'dstack', 'row_stack', 'column_stack',
-'compress_rowcols', 'compress_rows', 'compress_cols', 'count_masked',
-'dot', 'hsplit',
-'mask_rowcols','mask_rows','mask_cols','masked_all','masked_all_like',
-'mediff1d', 'mr_',
-'notmasked_edges','notmasked_contiguous',
-'stdu', 'varu',
-           ]
-
-from itertools import groupby
-
-import core
-from core import *
-
-import numpy
-from numpy import float_
-import numpy.core.umath as umath
-import numpy.core.numeric as numeric
-from numpy.core.numeric import ndarray
-from numpy.core.numeric import array as nxarray
-from numpy.core.fromnumeric import asarray as nxasarray
-
-from numpy.lib.index_tricks import AxisConcatenator
-import numpy.lib.function_base as function_base
-
-#...............................................................................
-def issequence(seq):
-    """Is seq a sequence (ndarray, list or tuple)?"""
-    if isinstance(seq, ndarray):
-        return True
-    elif isinstance(seq, tuple):
-        return True
-    elif isinstance(seq, list):
-        return True
-    return False
-
-def count_masked(arr, axis=None):
-    """Count the number of masked elements along the given axis.
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to count.
-            If None (default), a flattened version of the array is used.
-
-    """
-    m = getmaskarray(arr)
-    return m.sum(axis)
-
-def masked_all(shape, dtype=float_):
-    """Return an empty masked array of the given shape and dtype,
-    where all the data are masked.
-
-    Parameters
-    ----------
-        dtype : dtype, optional
-            Data type of the output.
-
-    """
-    a = masked_array(numeric.empty(shape, dtype),
-                     mask=numeric.ones(shape, bool_))
-    return a
-
-def masked_all_like(arr):
-    """Return an empty masked array of the same shape and dtype as
-    the array `a`, where all the data are masked.
-
-    """
-    a = masked_array(numeric.empty_like(arr),
-                     mask=numeric.ones(arr.shape, bool_))
-    return a
-
-#####--------------------------------------------------------------------------
-#---- --- New methods ---
-#####--------------------------------------------------------------------------
-def varu(a, axis=None, dtype=None):
-    """Return an unbiased estimate of the variance.
-    i.e. var = sum((x - x.mean())**2)/(size(x,axis)-1)
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : {dtype}, optional
-            Datatype for the intermediary computation. If not given,
-            the current dtype is used instead.
-
-    Notes
-    -----
-        The value returned is an unbiased estimate of the true variance.
-        For the (less standard) biased estimate, use var.
-
-    """
-    a = asarray(a)
-    cnt = a.count(axis=axis)
-    anom = a.anom(axis=axis, dtype=dtype)
-    anom *= anom
-    dvar = anom.sum(axis) / (cnt-1)
-    if axis is None:
-        return dvar
-    dvar.__setmask__(mask_or(a._mask.all(axis), (cnt==1)))
-    return dvar
-#    return a.__class__(dvar,
-#                          mask=mask_or(a._mask.all(axis), (cnt==1)),
-#                          fill_value=a._fill_value)
-
-def stdu(a, axis=None, dtype=None):
-    """Return an unbiased estimate of the standard deviation.  The
-    standard deviation is the square root of the average of the
-    squared deviations from the mean, i.e. stdu = sqrt(varu(x)).
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        dtype : dtype, optional
-            Datatype for the intermediary computation.
-            If not given, the current dtype is used instead.
-
-    Notes
-    -----
-        The value returned is an unbiased estimate of the true
-        standard deviation.  For the biased estimate,
-        use std.
-
-    """
-    a = asarray(a)
-    dvar = a.varu(axis,dtype)
-    if axis is None:
-        if dvar is masked:
-            return masked
-        else:
-            # Should we use umath.sqrt instead ?
-            return sqrt(dvar)
-    return sqrt(dvar)
-
-
-MaskedArray.stdu = stdu
-MaskedArray.varu = varu
-
-#####--------------------------------------------------------------------------
-#---- --- Standard functions ---
-#####--------------------------------------------------------------------------
-class _fromnxfunction:
-    """Defines a wrapper to adapt numpy functions to masked arrays."""
-    def __init__(self, funcname):
-        self._function = funcname
-        self.__doc__ = self.getdoc()
-    def getdoc(self):
-        "Retrieves the __doc__ string from the function."
-        return getattr(numpy, self._function).__doc__ +\
-            "*Notes*:\n    (The function is applied to both the _data and the _mask, if any.)"
-    def __call__(self, *args, **params):
-        func = getattr(numpy, self._function)
-        if len(args)==1:
-            x = args[0]
-            if isinstance(x,ndarray):
-                _d = func(nxasarray(x), **params)
-                _m = func(getmaskarray(x), **params)
-                return masked_array(_d, mask=_m)
-            elif isinstance(x, tuple) or isinstance(x, list):
-                _d = func(tuple([nxasarray(a) for a in x]), **params)
-                _m = func(tuple([getmaskarray(a) for a in x]), **params)
-                return masked_array(_d, mask=_m)
-        else:
-            arrays = []
-            args = list(args)
-            while len(args)>0 and issequence(args[0]):
-                arrays.append(args.pop(0))
-            res = []
-            for x in arrays:
-                _d = func(nxasarray(x), *args, **params)
-                _m = func(getmaskarray(x), *args, **params)
-                res.append(masked_array(_d, mask=_m))
-            return res
-
-atleast_1d = _fromnxfunction('atleast_1d')
-atleast_2d = _fromnxfunction('atleast_2d')
-atleast_3d = _fromnxfunction('atleast_3d')
-
-vstack = row_stack = _fromnxfunction('vstack')
-hstack = _fromnxfunction('hstack')
-column_stack = _fromnxfunction('column_stack')
-dstack = _fromnxfunction('dstack')
-
-hsplit = _fromnxfunction('hsplit')
-
-#####--------------------------------------------------------------------------
-#----
-#####--------------------------------------------------------------------------
-def flatten_inplace(seq):
-    """Flatten a sequence in place."""
-    k = 0
-    while (k != len(seq)):
-        while hasattr(seq[k],'__iter__'):
-            seq[k:(k+1)] = seq[k]
-        k += 1
-    return seq
-
-
-def apply_along_axis(func1d,axis,arr,*args,**kwargs):
-    """Execute func1d(arr[i],*args) where func1d takes 1-D arrays and
-    arr is an N-d array.  i varies so as to apply the function along
-    the given axis for each 1-d subarray in arr.
-    """
-    arr = core.array(arr, copy=False, subok=True)
-    nd = arr.ndim
-    if axis < 0:
-        axis += nd
-    if (axis >= nd):
-        raise ValueError("axis must be less than arr.ndim; axis=%d, rank=%d."
-            % (axis,nd))
-    ind = [0]*(nd-1)
-    i = numeric.zeros(nd,'O')
-    indlist = range(nd)
-    indlist.remove(axis)
-    i[axis] = slice(None,None)
-    outshape = numeric.asarray(arr.shape).take(indlist)
-    i.put(indlist, ind)
-    j = i.copy()
-    res = func1d(arr[tuple(i.tolist())],*args,**kwargs)
-    #  if res is a number, then we have a smaller output array
-    asscalar = numeric.isscalar(res)
-    if not asscalar:
-        try:
-            len(res)
-        except TypeError:
-            asscalar = True
-    # Note: we shouldn't set the dtype of the output from the first result...
-    #...so we force the type to object, and build a list of dtypes
-    #...we'll just take the largest, to avoid some downcasting
-    dtypes = []
-    if asscalar:
-        dtypes.append(numeric.asarray(res).dtype)
-        outarr = zeros(outshape, object_)
-        outarr[tuple(ind)] = res
-        Ntot = numeric.product(outshape)
-        k = 1
-        while k < Ntot:
-            # increment the index
-            ind[-1] += 1
-            n = -1
-            while (ind[n] >= outshape[n]) and (n > (1-nd)):
-                ind[n-1] += 1
-                ind[n] = 0
-                n -= 1
-            i.put(indlist,ind)
-            res = func1d(arr[tuple(i.tolist())],*args,**kwargs)
-            outarr[tuple(ind)] = res
-            dtypes.append(asarray(res).dtype)
-            k += 1
-    else:
-        res = core.array(res, copy=False, subok=True)
-        j = i.copy()
-        j[axis] = ([slice(None,None)] * res.ndim)
-        j.put(indlist, ind)
-        Ntot = numeric.product(outshape)
-        holdshape = outshape
-        outshape = list(arr.shape)
-        outshape[axis] = res.shape
-        dtypes.append(asarray(res).dtype)
-        outshape = flatten_inplace(outshape)
-        outarr = zeros(outshape, object_)
-        outarr[tuple(flatten_inplace(j.tolist()))] = res
-        k = 1
-        while k < Ntot:
-            # increment the index
-            ind[-1] += 1
-            n = -1
-            while (ind[n] >= holdshape[n]) and (n > (1-nd)):
-                ind[n-1] += 1
-                ind[n] = 0
-                n -= 1
-            i.put(indlist, ind)
-            j.put(indlist, ind)
-            res = func1d(arr[tuple(i.tolist())],*args,**kwargs)
-            outarr[tuple(flatten_inplace(j.tolist()))] = res
-            dtypes.append(asarray(res).dtype)
-            k += 1
-    max_dtypes = numeric.dtype(numeric.asarray(dtypes).max())
-    if not hasattr(arr, '_mask'):
-        result = numeric.asarray(outarr, dtype=max_dtypes)
-    else:
-        result = core.asarray(outarr, dtype=max_dtypes)
-        result.fill_value = core.default_fill_value(result)
-    return result
-
-def average(a, axis=None, weights=None, returned=False):
-    """Average the array over the given axis.
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-        weights : sequence, optional
-            Sequence of weights.
-            The weights must have the shape of a, or be 1D with length
-            the size of a along the given axis.
-            If no weights are given, weights are assumed to be 1.
-        returned : bool
-            Flag indicating whether a tuple (result, sum of weights/counts) 
-            should be returned as output (True), or just the result (False).
-
-    """
-    a = asarray(a)
-    mask = a.mask
-    ash = a.shape
-    if ash == ():
-        ash = (1,)
-    if axis is None:
-        if mask is nomask:
-            if weights is None:
-                n = a.sum(axis=None)
-                d = float(a.size)
-            else:
-                w = filled(weights, 0.0).ravel()
-                n = umath.add.reduce(a._data.ravel() * w)
-                d = umath.add.reduce(w)
-                del w
-        else:
-            if weights is None:
-                n = a.filled(0).sum(axis=None)
-                d = umath.add.reduce((-mask).ravel().astype(int_))
-            else:
-                w = array(filled(weights, 0.0), float, mask=mask).ravel()
-                n = add.reduce(a.ravel() * w)
-                d = add.reduce(w)
-                del w
-    else:
-        if mask is nomask:
-            if weights is None:
-                d = ash[axis] * 1.0
-                n = add.reduce(a._data, axis, dtype=float_)
-            else:
-                w = filled(weights, 0.0)
-                wsh = w.shape
-                if wsh == ():
-                    wsh = (1,)
-                if wsh == ash:
-                    w = numeric.array(w, float_, copy=0)
-                    n = add.reduce(a*w, axis)
-                    d = add.reduce(w, axis)
-                    del w
-                elif wsh == (ash[axis],):
-                    ni = ash[axis]
-                    r = [None]*len(ash)
-                    r[axis] = slice(None, None, 1)
-                    w = eval ("w["+ repr(tuple(r)) + "] * ones(ash, float)")
-                    n = add.reduce(a*w, axis, dtype=float_)
-                    d = add.reduce(w, axis, dtype=float_)
-                    del w, r
-                else:
-                    raise ValueError, 'average: weights wrong shape.'
-        else:
-            if weights is None:
-                n = add.reduce(a, axis, dtype=float_)
-                d = umath.add.reduce((-mask), axis=axis, dtype=float_)
-            else:
-                w = filled(weights, 0.0)
-                wsh = w.shape
-                if wsh == ():
-                    wsh = (1,)
-                if wsh == ash:
-                    w = array(w, dtype=float_, mask=mask, copy=0)
-                    n = add.reduce(a*w, axis, dtype=float_)
-                    d = add.reduce(w, axis, dtype=float_)
-                elif wsh == (ash[axis],):
-                    ni = ash[axis]
-                    r = [None]*len(ash)
-                    r[axis] = slice(None, None, 1)
-                    w = eval ("w["+ repr(tuple(r)) + \
-                              "] * masked_array(ones(ash, float), mask)")
-                    n = add.reduce(a*w, axis, dtype=float_)
-                    d = add.reduce(w, axis, dtype=float_)
-                else:
-                    raise ValueError, 'average: weights wrong shape.'
-                del w
-    if n is masked or d is masked:
-        return masked
-    result = n/d
-    del n
-
-    if isMaskedArray(result):
-        if ((axis is None) or (axis==0 and a.ndim == 1)) and \
-           (result.mask is nomask):
-            result = result._data
-        if returned:
-            if not isMaskedArray(d):
-                d = masked_array(d)
-            if isinstance(d, ndarray) and (not d.shape == result.shape):
-                d = ones(result.shape, dtype=float_) * d
-    if returned:
-        return result, d
-    else:
-        return result
-
-#..............................................................................
-def compress_rowcols(x, axis=None):
-    """Suppress the rows and/or columns of a 2D array that contains
-    masked values.
-
-    The suppression behavior is selected with the `axis`parameter.
-        - If axis is None, rows and columns are suppressed.
-        - If axis is 0, only rows are suppressed.
-        - If axis is 1 or -1, only columns are suppressed.
-        
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-
-    Returns
-    -------
-        compressed_array : an ndarray.
-
-    """
-    x = asarray(x)
-    if x.ndim != 2:
-        raise NotImplementedError, "compress2d works for 2D arrays only."
-    m = getmask(x)
-    # Nothing is masked: return x
-    if m is nomask or not m.any():
-        return x._data
-    # All is masked: return empty
-    if m.all():
-        return nxarray([])
-    # Builds a list of rows/columns indices
-    (idxr, idxc) = (range(len(x)), range(x.shape[1]))
-    masked = m.nonzero()
-    if not axis:
-        for i in function_base.unique(masked[0]):
-            idxr.remove(i)
-    if axis in [None, 1, -1]:
-        for j in function_base.unique(masked[1]):
-            idxc.remove(j)
-    return x._data[idxr][:,idxc]
-
-def compress_rows(a):
-    """Suppress whole rows of a 2D array that contain masked values.
-
-    """
-    return compress_rowcols(a,0)
-
-def compress_cols(a):
-    """Suppress whole columnss of a 2D array that contain masked values.
-
-    """
-    return compress_rowcols(a,1)
-
-def mask_rowcols(a, axis=None):
-    """Mask whole rows and/or columns of a 2D array that contain
-    masked values.  The masking behavior is selected with the
-    `axis`parameter.
-
-        - If axis is None, rows and columns are masked.
-        - If axis is 0, only rows are masked.
-        - If axis is 1 or -1, only columns are masked.
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-            
-    Returns
-    -------
-         a *pure* ndarray.
-
-    """
-    a = asarray(a)
-    if a.ndim != 2:
-        raise NotImplementedError, "compress2d works for 2D arrays only."
-    m = getmask(a)
-    # Nothing is masked: return a
-    if m is nomask or not m.any():
-        return a
-    maskedval = m.nonzero()
-    a._mask = a._mask.copy()
-    if not axis:
-        a[function_base.unique(maskedval[0])] = masked
-    if axis in [None, 1, -1]:
-        a[:,function_base.unique(maskedval[1])] = masked
-    return a
-
-def mask_rows(a, axis=None):
-    """Mask whole rows of a 2D array that contain masked values.
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-    """
-    return mask_rowcols(a, 0)
-
-def mask_cols(a, axis=None):
-    """Mask whole columns of a 2D array that contain masked values.
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-    """
-    return mask_rowcols(a, 1)
-
-
-def dot(a,b, strict=False):
-    """Return the dot product of two 2D masked arrays a and b.
-
-    Like the generic numpy equivalent, the product sum is over the
-    last dimension of a and the second-to-last dimension of b.  If
-    strict is True, masked values are propagated: if a masked value
-    appears in a row or column, the whole row or column is considered
-    masked.
-
-    Parameters
-    ----------
-        strict : {boolean}
-            Whether masked data are propagated (True) or set to 0 for
-            the computation.
-
-    Notes
-    -----
-        The first argument is not conjugated.
-
-    """
-    #TODO: Works only with 2D arrays. There should be a way to get it to run with higher dimension
-    if strict and (a.ndim == 2) and (b.ndim == 2):
-        a = mask_rows(a)
-        b = mask_cols(b)
-    #
-    d = numpy.dot(filled(a, 0), filled(b, 0))
-    #
-    am = (~getmaskarray(a))
-    bm = (~getmaskarray(b))
-    m = ~numpy.dot(am,bm)
-    return masked_array(d, mask=m)
-
-#...............................................................................
-def mediff1d(array, to_end=None, to_begin=None):
-    """Return the differences between consecutive elements of an
-    array, possibly with prefixed and/or appended values.
-
-    Parameters
-    ----------
-        array : {array}
-            Input array,  will be flattened before the difference is taken.
-        to_end : {number}, optional
-            If provided, this number will be tacked onto the end of the returned
-            differences.
-        to_begin : {number}, optional
-            If provided, this number will be taked onto the beginning of the
-            returned differences.
-
-    Returns
-    -------
-          ed : {array}
-            The differences. Loosely, this will be (ary[1:] - ary[:-1]).
-
-    """
-    a = masked_array(array, copy=True)
-    if a.ndim > 1:
-        a.reshape((a.size,))
-    (d, m, n) = (a._data, a._mask, a.size-1)
-    dd = d[1:]-d[:-1]
-    if m is nomask:
-        dm = nomask
-    else:
-        dm = m[1:]-m[:-1]
-    #
-    if to_end is not None:
-        to_end = asarray(to_end)
-        nend = to_end.size
-        if to_begin is not None:
-            to_begin = asarray(to_begin)
-            nbegin = to_begin.size
-            r_data = numeric.empty((n+nend+nbegin,), dtype=a.dtype)
-            r_mask = numeric.zeros((n+nend+nbegin,), dtype=bool_)
-            r_data[:nbegin] = to_begin._data
-            r_mask[:nbegin] = to_begin._mask
-            r_data[nbegin:-nend] = dd
-            r_mask[nbegin:-nend] = dm
-        else:
-            r_data = numeric.empty((n+nend,), dtype=a.dtype)
-            r_mask = numeric.zeros((n+nend,), dtype=bool_)
-            r_data[:-nend] = dd
-            r_mask[:-nend] = dm
-        r_data[-nend:] = to_end._data
-        r_mask[-nend:] = to_end._mask
-    #
-    elif to_begin is not None:
-        to_begin = asarray(to_begin)
-        nbegin = to_begin.size
-        r_data = numeric.empty((n+nbegin,), dtype=a.dtype)
-        r_mask = numeric.zeros((n+nbegin,), dtype=bool_)
-        r_data[:nbegin] = to_begin._data
-        r_mask[:nbegin] = to_begin._mask
-        r_data[nbegin:] = dd
-        r_mask[nbegin:] = dm
-    #
-    else:
-        r_data = dd
-        r_mask = dm
-    return masked_array(r_data, mask=r_mask)
-
-
-
-
-#####--------------------------------------------------------------------------
-#---- --- Concatenation helpers ---
-#####--------------------------------------------------------------------------
-
-class MAxisConcatenator(AxisConcatenator):
-    """Translate slice objects to concatenation along an axis.
-
-    """
-
-    def __init__(self, axis=0):
-        AxisConcatenator.__init__(self, axis, matrix=False)
-
-    def __getitem__(self,key):
-        if isinstance(key, str):
-            raise MAError, "Unavailable for masked array."
-        if type(key) is not tuple:
-            key = (key,)
-        objs = []
-        scalars = []
-        final_dtypedescr = None
-        for k in range(len(key)):
-            scalar = False
-            if type(key[k]) is slice:
-                step = key[k].step
-                start = key[k].start
-                stop = key[k].stop
-                if start is None:
-                    start = 0
-                if step is None:
-                    step = 1
-                if type(step) is type(1j):
-                    size = int(abs(step))
-                    newobj = function_base.linspace(start, stop, num=size)
-                else:
-                    newobj = numeric.arange(start, stop, step)
-            elif type(key[k]) is str:
-                if (key[k] in 'rc'):
-                    self.matrix = True
-                    self.col = (key[k] == 'c')
-                    continue
-                try:
-                    self.axis = int(key[k])
-                    continue
-                except (ValueError, TypeError):
-                    raise ValueError, "Unknown special directive"
-            elif type(key[k]) in numeric.ScalarType:
-                newobj = asarray([key[k]])
-                scalars.append(k)
-                scalar = True
-            else:
-                newobj = key[k]
-            objs.append(newobj)
-            if isinstance(newobj, numeric.ndarray) and not scalar:
-                if final_dtypedescr is None:
-                    final_dtypedescr = newobj.dtype
-                elif newobj.dtype > final_dtypedescr:
-                    final_dtypedescr = newobj.dtype
-        if final_dtypedescr is not None:
-            for k in scalars:
-                objs[k] = objs[k].astype(final_dtypedescr)
-        res = concatenate(tuple(objs),axis=self.axis)
-        return self._retval(res)
-
-class mr_class(MAxisConcatenator):
-    """Translate slice objects to concatenation along the first axis.
-
-    For example:
-        >>> mr_[array([1,2,3]), 0, 0, array([4,5,6])]
-        array([1, 2, 3, 0, 0, 4, 5, 6])
-
-    """
-    def __init__(self):
-        MAxisConcatenator.__init__(self, 0)
-
-mr_ = mr_class()
-
-#####--------------------------------------------------------------------------
-#---- ---
-#####--------------------------------------------------------------------------
-
-def flatnotmasked_edges(a):
-    """Find the indices of the first and last not masked values in a
-    1D masked array.  If all values are masked, returns None.
-
-    """
-    m = getmask(a)
-    if m is nomask or not numpy.any(m):
-        return [0,-1]
-    unmasked = numeric.flatnonzero(~m)
-    if len(unmasked) > 0:
-        return unmasked[[0,-1]]
-    else:
-        return None
-
-def notmasked_edges(a, axis=None):
-    """Find the indices of the first and last not masked values along
-    the given axis in a masked array.
-
-    If all values are masked, return None.  Otherwise, return a list
-    of 2 tuples, corresponding to the indices of the first and last
-    unmasked values respectively.
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-    """
-    a = asarray(a)
-    if axis is None or a.ndim == 1:
-        return flatnotmasked_edges(a)
-    m = getmask(a)
-    idx = array(numpy.indices(a.shape), mask=nxasarray([m]*a.ndim))
-    return [tuple([idx[i].min(axis).compressed() for i in range(a.ndim)]),
-            tuple([idx[i].max(axis).compressed() for i in range(a.ndim)]),]
-
-def flatnotmasked_contiguous(a):
-    """Find contiguous unmasked data in a flattened masked array.
-
-    Return a sorted sequence of slices (start index, end index).
-
-    """
-    m = getmask(a)
-    if m is nomask:
-        return (a.size, [0,-1])
-    unmasked = numeric.flatnonzero(~m)
-    if len(unmasked) == 0:
-        return None
-    result = []
-    for k, group in groupby(enumerate(unmasked), lambda (i,x):i-x):
-        tmp = numpy.fromiter((g[1] for g in group), int_)
-#        result.append((tmp.size, tuple(tmp[[0,-1]])))
-        result.append( slice(tmp[0],tmp[-1]) )
-    result.sort()
-    return result
-
-def notmasked_contiguous(a, axis=None):
-    """Find contiguous unmasked data in a masked array along the given
-    axis.
-
-    Parameters
-    ----------
-        axis : int, optional
-            Axis along which to perform the operation.
-            If None, applies to a flattened version of the array.
-            
-    Returns
-    -------
-        a sorted sequence of slices (start index, end index).
-
-    Notes
-    -----
-        Only accepts 2D arrays at most.
-
-    """
-    a = asarray(a)
-    nd = a.ndim
-    if nd > 2:
-        raise NotImplementedError,"Currently limited to atmost 2D array."
-    if axis is None or nd == 1:
-        return flatnotmasked_contiguous(a)
-    #
-    result = []
-    #
-    other = (axis+1)%2
-    idx = [0,0]
-    idx[axis] = slice(None,None)
-    #
-    for i in range(a.shape[other]):
-        idx[other] = i
-        result.append( flatnotmasked_contiguous(a[idx]) )
-    return result
-
-################################################################################

Copied: trunk/numpy/ma/extras.py (from rev 4777, branches/maskedarray/numpy/ma/extras.py)

Deleted: trunk/numpy/ma/setup.py
===================================================================
--- branches/maskedarray/numpy/ma/setup.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/setup.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,19 +0,0 @@
-#!/usr/bin/env python
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
-import os
-
-def configuration(parent_package='',top_path=None):
-    from numpy.distutils.misc_util import Configuration
-    config = Configuration('ma',parent_package,top_path)
-    config.add_data_dir('tests')
-    return config
-
-if __name__ == "__main__":
-    from numpy.distutils.core import setup
-    #setup.update(nmasetup)
-    config = configuration(top_path='').todict()
-    setup(**config)

Copied: trunk/numpy/ma/setup.py (from rev 4777, branches/maskedarray/numpy/ma/setup.py)
===================================================================
--- branches/maskedarray/numpy/ma/setup.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/setup.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
+__version__ = '1.0'
+__revision__ = "$Revision: 3473 $"
+__date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
+
+import os
+
+def configuration(parent_package='',top_path=None):
+    from numpy.distutils.misc_util import Configuration
+    config = Configuration('ma',parent_package,top_path)
+    config.add_data_dir('tests')
+    return config
+
+if __name__ == "__main__":
+    from numpy.distutils.core import setup
+    config = configuration(top_path='').todict()
+    setup(**config)

Copied: trunk/numpy/ma/tests (from rev 4777, branches/maskedarray/numpy/ma/tests)

Deleted: trunk/numpy/ma/tests/test_core.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_core.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/tests/test_core.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,1449 +0,0 @@
-# pylint: disable-msg=W0611, W0612, W0511,R0201
-"""Tests suite for MaskedArray & subclassing.
-
-:author: Pierre Gerard-Marchant
-:contact: pierregm_at_uga_dot_edu
-"""
-__author__ = "Pierre GF Gerard-Marchant"
-
-import types
-import warnings
-
-import numpy
-import numpy.core.fromnumeric  as fromnumeric
-from numpy.testing import NumpyTest, NumpyTestCase
-from numpy.testing import set_local_path, restore_path
-from numpy.testing.utils import build_err_msg
-from numpy import array as narray
-
-import numpy.ma.testutils
-from numpy.ma.testutils import *
-
-import numpy.ma.core as coremodule
-from numpy.ma.core import *
-
-pi = numpy.pi
-
-set_local_path()
-from test_old_ma import *
-restore_path()
-
-#..............................................................................
-class TestMA(NumpyTestCase):
-    "Base test class for MaskedArrays."
-    def __init__(self, *args, **kwds):
-        NumpyTestCase.__init__(self, *args, **kwds)
-        self.setUp()
-
-    def setUp (self):
-        "Base data definition."
-        x = narray([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
-        y = narray([5.,0.,3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
-        a10 = 10.
-        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 ,0, 1]
-        xm = masked_array(x, mask=m1)
-        ym = masked_array(y, mask=m2)
-        z = narray([-.5, 0., .5, .8])
-        zm = masked_array(z, mask=[0,1,0,0])
-        xf = numpy.where(m1, 1.e+20, x)
-        xm.set_fill_value(1.e+20)
-        self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf)
-    #........................
-    def test_basic1d(self):
-        "Test of basic array creation and properties in 1 dimension."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        assert(not isMaskedArray(x))
-        assert(isMaskedArray(xm))
-        assert((xm-ym).filled(0).any())
-        fail_if_equal(xm.mask.astype(int_), ym.mask.astype(int_))
-        s = x.shape
-        assert_equal(numpy.shape(xm), s)
-        assert_equal(xm.shape, s)
-        assert_equal(xm.dtype, x.dtype)
-        assert_equal(zm.dtype, z.dtype)
-        assert_equal(xm.size , reduce(lambda x,y:x*y, s))
-        assert_equal(count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
-        assert_array_equal(xm, xf)
-        assert_array_equal(filled(xm, 1.e20), xf)
-        assert_array_equal(x, xm)
-    #........................
-    def test_basic2d(self):
-        "Test of basic array creation and properties in 2 dimensions."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        for s in [(4,3), (6,2)]:
-            x.shape = s
-            y.shape = s
-            xm.shape = s
-            ym.shape = s
-            xf.shape = s
-
-            assert(not isMaskedArray(x))
-            assert(isMaskedArray(xm))
-            assert_equal(shape(xm), s)
-            assert_equal(xm.shape, s)
-            assert_equal( xm.size , reduce(lambda x,y:x*y, s))
-            assert_equal( count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
-            assert_equal(xm, xf)
-            assert_equal(filled(xm, 1.e20), xf)
-            assert_equal(x, xm)
-    #........................
-    def test_basic_arithmetic (self):
-        "Test of basic arithmetic."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        a2d = array([[1,2],[0,4]])
-        a2dm = masked_array(a2d, [[0,0],[1,0]])
-        assert_equal(a2d * a2d, a2d * a2dm)
-        assert_equal(a2d + a2d, a2d + a2dm)
-        assert_equal(a2d - a2d, a2d - a2dm)
-        for s in [(12,), (4,3), (2,6)]:
-            x = x.reshape(s)
-            y = y.reshape(s)
-            xm = xm.reshape(s)
-            ym = ym.reshape(s)
-            xf = xf.reshape(s)
-            assert_equal(-x, -xm)
-            assert_equal(x + y, xm + ym)
-            assert_equal(x - y, xm - ym)
-            assert_equal(x * y, xm * ym)
-            assert_equal(x / y, xm / ym)
-            assert_equal(a10 + y, a10 + ym)
-            assert_equal(a10 - y, a10 - ym)
-            assert_equal(a10 * y, a10 * ym)
-            assert_equal(a10 / y, a10 / ym)
-            assert_equal(x + a10, xm + a10)
-            assert_equal(x - a10, xm - a10)
-            assert_equal(x * a10, xm * a10)
-            assert_equal(x / a10, xm / a10)
-            assert_equal(x**2, xm**2)
-            assert_equal(abs(x)**2.5, abs(xm) **2.5)
-            assert_equal(x**y, xm**ym)
-            assert_equal(numpy.add(x,y), add(xm, ym))
-            assert_equal(numpy.subtract(x,y), subtract(xm, ym))
-            assert_equal(numpy.multiply(x,y), multiply(xm, ym))
-            assert_equal(numpy.divide(x,y), divide(xm, ym))
-    #........................
-    def test_mixed_arithmetic(self):
-        "Tests mixed arithmetics."
-        na = narray([1])
-        ma = array([1])
-        self.failUnless(isinstance(na + ma, MaskedArray))
-        self.failUnless(isinstance(ma + na, MaskedArray))
-    #........................
-    def test_inplace_arithmetic(self):
-        """Test of inplace operations and rich comparisons"""
-        # addition
-        x = arange(10)
-        y = arange(10)
-        xm = arange(10)
-        xm[2] = masked
-        x += 1
-        assert_equal(x, y+1)
-        xm += 1
-        assert_equal(xm, y+1)
-        # subtraction
-        x = arange(10)
-        xm = arange(10)
-        xm[2] = masked
-        x -= 1
-        assert_equal(x, y-1)
-        xm -= 1
-        assert_equal(xm, y-1)
-        # multiplication
-        x = arange(10)*1.0
-        xm = arange(10)*1.0
-        xm[2] = masked
-        x *= 2.0
-        assert_equal(x, y*2)
-        xm *= 2.0
-        assert_equal(xm, y*2)
-        # division
-        x = arange(10)*2
-        xm = arange(10)*2
-        xm[2] = masked
-        x /= 2
-        assert_equal(x, y)
-        xm /= 2
-        assert_equal(xm, y)
-        # division, pt 2
-        x = arange(10)*1.0
-        xm = arange(10)*1.0
-        xm[2] = masked
-        x /= 2.0
-        assert_equal(x, y/2.0)
-        xm /= arange(10)
-        assert_equal(xm, ones((10,)))
-
-        warnings.simplefilter('ignore', DeprecationWarning)
-        x = arange(10).astype(float_)
-        xm = arange(10)
-        xm[2] = masked
-        id1 = x.raw_data().ctypes.data
-        x += 1.
-        assert (id1 == x.raw_data().ctypes.data)
-        assert_equal(x, y+1.)
-        warnings.simplefilter('default', DeprecationWarning)
-
-        # addition w/ array
-        x = arange(10, dtype=float_)
-        xm = arange(10, dtype=float_)
-        xm[2] = masked
-        m = xm.mask
-        a = arange(10, dtype=float_)
-        a[-1] = masked
-        x += a
-        xm += a
-        assert_equal(x,y+a)
-        assert_equal(xm,y+a)
-        assert_equal(xm.mask, mask_or(m,a.mask))
-        # subtraction w/ array
-        x = arange(10, dtype=float_)
-        xm = arange(10, dtype=float_)
-        xm[2] = masked
-        m = xm.mask
-        a = arange(10, dtype=float_)
-        a[-1] = masked
-        x -= a
-        xm -= a
-        assert_equal(x,y-a)
-        assert_equal(xm,y-a)
-        assert_equal(xm.mask, mask_or(m,a.mask))
-        # multiplication w/ array
-        x = arange(10, dtype=float_)
-        xm = arange(10, dtype=float_)
-        xm[2] = masked
-        m = xm.mask
-        a = arange(10, dtype=float_)
-        a[-1] = masked
-        x *= a
-        xm *= a
-        assert_equal(x,y*a)
-        assert_equal(xm,y*a)
-        assert_equal(xm.mask, mask_or(m,a.mask))
-        # division w/ array
-        x = arange(10, dtype=float_)
-        xm = arange(10, dtype=float_)
-        xm[2] = masked
-        m = xm.mask
-        a = arange(10, dtype=float_)
-        a[-1] = masked
-        x /= a
-        xm /= a
-        assert_equal(x,y/a)
-        assert_equal(xm,y/a)
-        assert_equal(xm.mask, mask_or(mask_or(m,a.mask), (a==0)))
-        #
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        z = xm/ym
-        assert_equal(z._mask, [1,1,1,0,0,1,1,0,0,0,1,1])
-        assert_equal(z._data, [0.2,1.,1./3.,-1.,-pi/2.,-1.,5.,1.,1.,1.,2.,1.])
-        xm = xm.copy()
-        xm /= ym
-        assert_equal(xm._mask, [1,1,1,0,0,1,1,0,0,0,1,1])
-        assert_equal(xm._data, [1/5.,1.,1./3.,-1.,-pi/2.,-1.,5.,1.,1.,1.,2.,1.])
-
-
-    #..........................
-    def test_scalararithmetic(self):
-        "Tests some scalar arithmetics on MaskedArrays."
-        xm = array(0, mask=1)
-        assert((1/array(0)).mask)
-        assert((1 + xm).mask)
-        assert((-xm).mask)
-        assert((-xm).mask)
-        assert(maximum(xm, xm).mask)
-        assert(minimum(xm, xm).mask)
-        assert(xm.filled().dtype is xm.data.dtype)
-        x = array(0, mask=0)
-        assert_equal(x.filled().ctypes.data, x.ctypes.data)
-        assert_equal(str(xm), str(masked_print_option))
-    #.........................
-    def test_basic_ufuncs (self):
-        "Test various functions such as sin, cos."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        assert_equal(numpy.cos(x), cos(xm))
-        assert_equal(numpy.cosh(x), cosh(xm))
-        assert_equal(numpy.sin(x), sin(xm))
-        assert_equal(numpy.sinh(x), sinh(xm))
-        assert_equal(numpy.tan(x), tan(xm))
-        assert_equal(numpy.tanh(x), tanh(xm))
-        assert_equal(numpy.sqrt(abs(x)), sqrt(xm))
-        assert_equal(numpy.log(abs(x)), log(xm))
-        assert_equal(numpy.log10(abs(x)), log10(xm))
-        assert_equal(numpy.exp(x), exp(xm))
-        assert_equal(numpy.arcsin(z), arcsin(zm))
-        assert_equal(numpy.arccos(z), arccos(zm))
-        assert_equal(numpy.arctan(z), arctan(zm))
-        assert_equal(numpy.arctan2(x, y), arctan2(xm, ym))
-        assert_equal(numpy.absolute(x), absolute(xm))
-        assert_equal(numpy.equal(x,y), equal(xm, ym))
-        assert_equal(numpy.not_equal(x,y), not_equal(xm, ym))
-        assert_equal(numpy.less(x,y), less(xm, ym))
-        assert_equal(numpy.greater(x,y), greater(xm, ym))
-        assert_equal(numpy.less_equal(x,y), less_equal(xm, ym))
-        assert_equal(numpy.greater_equal(x,y), greater_equal(xm, ym))
-        assert_equal(numpy.conjugate(x), conjugate(xm))
-    #........................
-    def test_count_func (self):
-        "Tests count"
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        assert( isinstance(count(ott), int))
-        assert_equal(3, count(ott))
-        assert_equal(1, count(1))
-        assert_equal(0, array(1,mask=[1]))
-        ott = ott.reshape((2,2))
-        assert isMaskedArray(count(ott,0))
-        assert isinstance(count(ott), types.IntType)
-        assert_equal(3, count(ott))
-        assert getmask(count(ott,0)) is nomask
-        assert_equal([1,2],count(ott,0))
-    #........................
-    def test_minmax_func (self):
-        "Tests minimum and maximum."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        xr = numpy.ravel(x) #max doesn't work if shaped
-        xmr = ravel(xm)
-        assert_equal(max(xr), maximum(xmr)) #true because of careful selection of data
-        assert_equal(min(xr), minimum(xmr)) #true because of careful selection of data
-        #
-        assert_equal(minimum([1,2,3],[4,0,9]), [1,0,3])
-        assert_equal(maximum([1,2,3],[4,0,9]), [4,2,9])
-        x = arange(5)
-        y = arange(5) - 2
-        x[3] = masked
-        y[0] = masked
-        assert_equal(minimum(x,y), where(less(x,y), x, y))
-        assert_equal(maximum(x,y), where(greater(x,y), x, y))
-        assert minimum(x) == 0
-        assert maximum(x) == 4
-        #
-        x = arange(4).reshape(2,2)
-        x[-1,-1] = masked
-        assert_equal(maximum(x), 2)
-
-    def test_minmax_methods(self):
-        "Additional tests on max/min"
-        (_, _, _, _, _, xm, _, _, _, _) = self.d
-        xm.shape = (xm.size,)
-        assert_equal(xm.max(), 10)
-        assert(xm[0].max() is masked)
-        assert(xm[0].max(0) is masked)
-        assert(xm[0].max(-1) is masked)
-        assert_equal(xm.min(), -10.)
-        assert(xm[0].min() is masked)
-        assert(xm[0].min(0) is masked)
-        assert(xm[0].min(-1) is masked)
-        assert_equal(xm.ptp(), 20.)
-        assert(xm[0].ptp() is masked)
-        assert(xm[0].ptp(0) is masked)
-        assert(xm[0].ptp(-1) is masked)
-        #
-        x = array([1,2,3], mask=True)
-        assert(x.min() is masked)
-        assert(x.max() is masked)
-        assert(x.ptp() is masked)
-    #........................
-    def test_addsumprod (self):
-        "Tests add, sum, product."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        assert_equal(numpy.add.reduce(x), add.reduce(x))
-        assert_equal(numpy.add.accumulate(x), add.accumulate(x))
-        assert_equal(4, sum(array(4),axis=0))
-        assert_equal(4, sum(array(4), axis=0))
-        assert_equal(numpy.sum(x,axis=0), sum(x,axis=0))
-        assert_equal(numpy.sum(filled(xm,0),axis=0), sum(xm,axis=0))
-        assert_equal(numpy.sum(x,0), sum(x,0))
-        assert_equal(numpy.product(x,axis=0), product(x,axis=0))
-        assert_equal(numpy.product(x,0), product(x,0))
-        assert_equal(numpy.product(filled(xm,1),axis=0), product(xm,axis=0))
-        s = (3,4)
-        x.shape = y.shape = xm.shape = ym.shape = s
-        if len(s) > 1:
-            assert_equal(numpy.concatenate((x,y),1), concatenate((xm,ym),1))
-            assert_equal(numpy.add.reduce(x,1), add.reduce(x,1))
-            assert_equal(numpy.sum(x,1), sum(x,1))
-            assert_equal(numpy.product(x,1), product(x,1))
-    #.........................
-    def test_concat(self):
-        "Tests concatenations."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        # basic concatenation
-        assert_equal(numpy.concatenate((x,y)), concatenate((xm,ym)))
-        assert_equal(numpy.concatenate((x,y)), concatenate((x,y)))
-        assert_equal(numpy.concatenate((x,y)), concatenate((xm,y)))
-        assert_equal(numpy.concatenate((x,y,x)), concatenate((x,ym,x)))
-        # Concatenation along an axis
-        s = (3,4)
-        x.shape = y.shape = xm.shape = ym.shape = s
-        assert_equal(xm.mask, numpy.reshape(m1, s))
-        assert_equal(ym.mask, numpy.reshape(m2, s))
-        xmym = concatenate((xm,ym),1)
-        assert_equal(numpy.concatenate((x,y),1), xmym)
-        assert_equal(numpy.concatenate((xm.mask,ym.mask),1), xmym._mask)
-        #
-        x=zeros(2)
-        y=array(ones(2),mask=[False,True])
-        z = concatenate((x,y))
-        assert_array_equal(z,[0,0,1,1])
-        assert_array_equal(z.mask,[False,False,False,True])
-        z = concatenate((y,x))
-        assert_array_equal(z,[1,1,0,0])
-        assert_array_equal(z.mask,[False,True,False,False])
-
-    #........................
-    def test_indexing(self):
-        "Tests conversions and indexing"
-        x1 = numpy.array([1,2,4,3])
-        x2 = array(x1, mask=[1,0,0,0])
-        x3 = array(x1, mask=[0,1,0,1])
-        x4 = array(x1)
-    # test conversion to strings
-        junk, garbage = str(x2), repr(x2)
-        assert_equal(numpy.sort(x1),sort(x2,endwith=False))
-    # tests of indexing
-        assert type(x2[1]) is type(x1[1])
-        assert x1[1] == x2[1]
-        assert x2[0] is masked
-        assert_equal(x1[2],x2[2])
-        assert_equal(x1[2:5],x2[2:5])
-        assert_equal(x1[:],x2[:])
-        assert_equal(x1[1:], x3[1:])
-        x1[2] = 9
-        x2[2] = 9
-        assert_equal(x1,x2)
-        x1[1:3] = 99
-        x2[1:3] = 99
-        assert_equal(x1,x2)
-        x2[1] = masked
-        assert_equal(x1,x2)
-        x2[1:3] = masked
-        assert_equal(x1,x2)
-        x2[:] = x1
-        x2[1] = masked
-        assert allequal(getmask(x2),array([0,1,0,0]))
-        x3[:] = masked_array([1,2,3,4],[0,1,1,0])
-        assert allequal(getmask(x3), array([0,1,1,0]))
-        x4[:] = masked_array([1,2,3,4],[0,1,1,0])
-        assert allequal(getmask(x4), array([0,1,1,0]))
-        assert allequal(x4, array([1,2,3,4]))
-        x1 = numpy.arange(5)*1.0
-        x2 = masked_values(x1, 3.0)
-        assert_equal(x1,x2)
-        assert allequal(array([0,0,0,1,0],MaskType), x2.mask)
-#FIXME: Well, eh, fill_value is now a property        assert_equal(3.0, x2.fill_value())
-        assert_equal(3.0, x2.fill_value)
-        x1 = array([1,'hello',2,3],object)
-        x2 = numpy.array([1,'hello',2,3],object)
-        s1 = x1[1]
-        s2 = x2[1]
-        assert_equal(type(s2), str)
-        assert_equal(type(s1), str)
-        assert_equal(s1, s2)
-        assert x1[1:1].shape == (0,)
-    #........................
-    def test_copy(self):
-        "Tests of some subtle points of copying and sizing."
-        n = [0,0,1,0,0]
-        m = make_mask(n)
-        m2 = make_mask(m)
-        assert(m is m2)
-        m3 = make_mask(m, copy=1)
-        assert(m is not m3)
-
-        warnings.simplefilter('ignore', DeprecationWarning)
-        x1 = numpy.arange(5)
-        y1 = array(x1, mask=m)
-        #assert( y1._data is x1)
-        assert_equal(y1._data.__array_interface__, x1.__array_interface__)
-        assert( allequal(x1,y1.raw_data()))
-        #assert( y1.mask is m)
-        assert_equal(y1._mask.__array_interface__, m.__array_interface__)
-        warnings.simplefilter('default', DeprecationWarning)
-
-        y1a = array(y1)
-        #assert( y1a.raw_data() is y1.raw_data())
-        assert( y1a._data.__array_interface__ == y1._data.__array_interface__)
-        assert( y1a.mask is y1.mask)
-
-        y2 = array(x1, mask=m)
-        #assert( y2.raw_data() is x1)
-        assert (y2._data.__array_interface__ == x1.__array_interface__)
-        #assert( y2.mask is m)
-        assert (y2._mask.__array_interface__ == m.__array_interface__)
-        assert( y2[2] is masked)
-        y2[2] = 9
-        assert( y2[2] is not masked)
-        #assert( y2.mask is not m)
-        assert (y2._mask.__array_interface__ != m.__array_interface__)
-        assert( allequal(y2.mask, 0))
-
-        y3 = array(x1*1.0, mask=m)
-        assert(filled(y3).dtype is (x1*1.0).dtype)
-
-        x4 = arange(4)
-        x4[2] = masked
-        y4 = resize(x4, (8,))
-        assert_equal(concatenate([x4,x4]), y4)
-        assert_equal(getmask(y4),[0,0,1,0,0,0,1,0])
-        y5 = repeat(x4, (2,2,2,2), axis=0)
-        assert_equal(y5, [0,0,1,1,2,2,3,3])
-        y6 = repeat(x4, 2, axis=0)
-        assert_equal(y5, y6)
-        y7 = x4.repeat((2,2,2,2), axis=0)
-        assert_equal(y5,y7)
-        y8 = x4.repeat(2,0)
-        assert_equal(y5,y8)
-
-        y9 = x4.copy()
-        assert_equal(y9._data, x4._data)
-        assert_equal(y9._mask, x4._mask)
-        #
-        x = masked_array([1,2,3], mask=[0,1,0])
-        # Copy is False by default
-        y = masked_array(x)
-        assert_equal(y._data.ctypes.data, x._data.ctypes.data)
-        assert_equal(y._mask.ctypes.data, x._mask.ctypes.data)
-        y = masked_array(x, copy=True)
-        assert_not_equal(y._data.ctypes.data, x._data.ctypes.data)
-        assert_not_equal(y._mask.ctypes.data, x._mask.ctypes.data)
-    #........................
-    def test_where(self):
-        "Test the where function"
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        d = where(xm>2,xm,-9)
-        assert_equal(d, [-9.,-9.,-9.,-9., -9., 4., -9., -9., 10., -9., -9., 3.])
-        assert_equal(d._mask, xm._mask)
-        d = where(xm>2,-9,ym)
-        assert_equal(d, [5.,0.,3., 2., -1.,-9.,-9., -10., -9., 1., 0., -9.])
-        assert_equal(d._mask, [1,0,1,0,0,0,1,0,0,0,0,0])
-        d = where(xm>2, xm, masked)
-        assert_equal(d, [-9.,-9.,-9.,-9., -9., 4., -9., -9., 10., -9., -9., 3.])
-        tmp = xm._mask.copy()
-        tmp[(xm<=2).filled(True)] = True
-        assert_equal(d._mask, tmp)
-        #
-        ixm = xm.astype(int_)
-        d = where(ixm>2, ixm, masked)
-        assert_equal(d, [-9,-9,-9,-9, -9, 4, -9, -9, 10, -9, -9, 3])
-        assert_equal(d.dtype, ixm.dtype)
-        #
-        x = arange(10)
-        x[3] = masked
-        c = x >= 8
-        z = where(c , x, masked)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is masked
-        assert z[7] is masked
-        assert z[8] is not masked
-        assert z[9] is not masked
-        assert_equal(x,z)
-        #
-        z = where(c , masked, x)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is not masked
-        assert z[7] is not masked
-        assert z[8] is masked
-        assert z[9] is masked
-
-    #........................
-    def test_oddfeatures_1(self):
-        "Test of other odd features"
-        x = arange(20)
-        x = x.reshape(4,5)
-        x.flat[5] = 12
-        assert x[1,0] == 12
-        z = x + 10j * x
-        assert_equal(z.real, x)
-        assert_equal(z.imag, 10*x)
-        assert_equal((z*conjugate(z)).real, 101*x*x)
-        z.imag[...] = 0.0
-
-        x = arange(10)
-        x[3] = masked
-        assert str(x[3]) == str(masked)
-        c = x >= 8
-        assert count(where(c,masked,masked)) == 0
-        assert shape(where(c,masked,masked)) == c.shape
-        #
-        z = masked_where(c, x)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is not masked
-        assert z[7] is not masked
-        assert z[8] is masked
-        assert z[9] is masked
-        assert_equal(x,z)
-        #
-    #........................
-    def test_oddfeatures_2(self):
-        "Tests some more features."
-        x = array([1.,2.,3.,4.,5.])
-        c = array([1,1,1,0,0])
-        x[2] = masked
-        z = where(c, x, -x)
-        assert_equal(z, [1.,2.,0., -4., -5])
-        c[0] = masked
-        z = where(c, x, -x)
-        assert_equal(z, [1.,2.,0., -4., -5])
-        assert z[0] is masked
-        assert z[1] is not masked
-        assert z[2] is masked
-        #
-        x = arange(6)
-        x[5] = masked
-        y = arange(6)*10
-        y[2] = masked
-        c = array([1,1,1,0,0,0], mask=[1,0,0,0,0,0])
-        cm = c.filled(1)
-        z = where(c,x,y)
-        zm = where(cm,x,y)
-        assert_equal(z, zm)
-        assert getmask(zm) is nomask
-        assert_equal(zm, [0,1,2,30,40,50])
-        z = where(c, masked, 1)
-        assert_equal(z, [99,99,99,1,1,1])
-        z = where(c, 1, masked)
-        assert_equal(z, [99, 1, 1, 99, 99, 99])
-    #........................
-    def test_oddfeatures_3(self):
-        """Tests some generic features."""
-        atest = ones((10,10,10), dtype=float_)
-        btest = zeros(atest.shape, MaskType)
-        ctest = masked_where(btest,atest)
-        assert_equal(atest,ctest)
-    #........................
-    def test_maskingfunctions(self):
-        "Tests masking functions."
-        x = array([1.,2.,3.,4.,5.])
-        x[2] = masked
-        assert_equal(masked_where(greater(x, 2), x), masked_greater(x,2))
-        assert_equal(masked_where(greater_equal(x, 2), x), masked_greater_equal(x,2))
-        assert_equal(masked_where(less(x, 2), x), masked_less(x,2))
-        assert_equal(masked_where(less_equal(x, 2), x), masked_less_equal(x,2))
-        assert_equal(masked_where(not_equal(x, 2), x), masked_not_equal(x,2))
-        assert_equal(masked_where(equal(x, 2), x), masked_equal(x,2))
-        assert_equal(masked_where(not_equal(x,2), x), masked_not_equal(x,2))
-        assert_equal(masked_inside(range(5), 1, 3), [0, 199, 199, 199, 4])
-        assert_equal(masked_outside(range(5), 1, 3),[199,1,2,3,199])
-        assert_equal(masked_inside(array(range(5), mask=[1,0,0,0,0]), 1, 3).mask, [1,1,1,1,0])
-        assert_equal(masked_outside(array(range(5), mask=[0,1,0,0,0]), 1, 3).mask, [1,1,0,0,1])
-        assert_equal(masked_equal(array(range(5), mask=[1,0,0,0,0]), 2).mask, [1,0,1,0,0])
-        assert_equal(masked_not_equal(array([2,2,1,2,1], mask=[1,0,0,0,0]), 2).mask, [1,0,1,0,1])
-        assert_equal(masked_where([1,1,0,0,0], [1,2,3,4,5]), [99,99,3,4,5])
-    #........................
-    def test_TakeTransposeInnerOuter(self):
-        "Test of take, transpose, inner, outer products"
-        x = arange(24)
-        y = numpy.arange(24)
-        x[5:6] = masked
-        x = x.reshape(2,3,4)
-        y = y.reshape(2,3,4)
-        assert_equal(numpy.transpose(y,(2,0,1)), transpose(x,(2,0,1)))
-        assert_equal(numpy.take(y, (2,0,1), 1), take(x, (2,0,1), 1))
-        assert_equal(numpy.inner(filled(x,0),filled(y,0)),
-                            inner(x, y))
-        assert_equal(numpy.outer(filled(x,0),filled(y,0)),
-                            outer(x, y))
-        y = array(['abc', 1, 'def', 2, 3], object)
-        y[2] = masked
-        t = take(y,[0,3,4])
-        assert t[0] == 'abc'
-        assert t[1] == 2
-        assert t[2] == 3
-    #.......................
-    def test_maskedelement(self):
-        "Test of masked element"
-        x = arange(6)
-        x[1] = masked
-        assert(str(masked) ==  '--')
-        assert(x[1] is masked)
-        assert_equal(filled(x[1], 0), 0)
-        # don't know why these should raise an exception...
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, masked)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, 2)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, xx)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, xx, masked)
-    #........................
-    def test_scalar(self):
-        "Checks masking a scalar"
-        x = masked_array(0)
-        assert_equal(str(x), '0')
-        x = masked_array(0,mask=True)
-        assert_equal(str(x), str(masked_print_option))
-        x = masked_array(0, mask=False)
-        assert_equal(str(x), '0')
-    #........................
-    def test_usingmasked(self):
-        "Checks that there's no collapsing to masked"
-        x = masked_array([1,2])
-        y = x * masked
-        assert_equal(y.shape, x.shape)
-        assert_equal(y._mask, [True, True])
-        y = x[0] * masked
-        assert y is masked
-        y = x + masked
-        assert_equal(y.shape, x.shape)
-        assert_equal(y._mask, [True, True])
-
-    #........................
-    def test_topython(self):
-        "Tests some communication issues with Python."
-        assert_equal(1, int(array(1)))
-        assert_equal(1.0, float(array(1)))
-        assert_equal(1, int(array([[[1]]])))
-        assert_equal(1.0, float(array([[1]])))
-        self.failUnlessRaises(ValueError, float, array([1,1]))
-
-        warnings.simplefilter('ignore',UserWarning)
-        assert numpy.isnan(float(array([1],mask=[1])))
-        warnings.simplefilter('default',UserWarning)
-#TODO: Check how bool works...
-#TODO:        self.failUnless(bool(array([0,1])))
-#TODO:        self.failUnless(bool(array([0,0],mask=[0,1])))
-#TODO:        self.failIf(bool(array([0,0])))
-#TODO:        self.failIf(bool(array([0,0],mask=[0,0])))
-    #........................
-    def test_arraymethods(self):
-        "Tests some MaskedArray methods."
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        assert_equal(a.any(), a.data.any())
-        assert_equal(a.all(), a.data.all())
-        assert_equal(a.argmax(), a.data.argmax())
-        assert_equal(a.argmin(), a.data.argmin())
-        assert_equal(a.choose(0,1,2,3,4), a.data.choose(0,1,2,3,4))
-        assert_equal(a.compress([1,0,1]), a.data.compress([1,0,1]))
-        assert_equal(a.conj(), a.data.conj())
-        assert_equal(a.conjugate(), a.data.conjugate())
-        #
-        m = array([[1,2],[3,4]])
-        assert_equal(m.diagonal(), m.data.diagonal())
-        assert_equal(a.sum(), a.data.sum())
-        assert_equal(a.take([1,2]), a.data.take([1,2]))
-        assert_equal(m.transpose(), m.data.transpose())
-    #........................
-    def test_basicattributes(self):
-        "Tests some basic array attributes."
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        assert_equal(a.ndim, 1)
-        assert_equal(b.ndim, 1)
-        assert_equal(a.size, 3)
-        assert_equal(b.size, 3)
-        assert_equal(a.shape, (3,))
-        assert_equal(b.shape, (3,))
-    #........................
-    def test_single_element_subscript(self):
-        "Tests single element subscripts of Maskedarrays."
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        assert_equal(a[0].shape, ())
-        assert_equal(b[0].shape, ())
-        assert_equal(b[1].shape, ())
-    #........................
-    def test_maskcreation(self):
-        "Tests how masks are initialized at the creation of Maskedarrays."
-        data = arange(24, dtype=float_)
-        data[[3,6,15]] = masked
-        dma_1 = MaskedArray(data)
-        assert_equal(dma_1.mask, data.mask)
-        dma_2 = MaskedArray(dma_1)
-        assert_equal(dma_2.mask, dma_1.mask)
-        dma_3 = MaskedArray(dma_1, mask=[1,0,0,0]*6)
-        fail_if_equal(dma_3.mask, dma_1.mask)
-
-    def test_pickling(self):
-        "Tests pickling"
-        import cPickle
-        a = arange(10)
-        a[::3] = masked
-        a.fill_value = 999
-        a_pickled = cPickle.loads(a.dumps())
-        assert_equal(a_pickled._mask, a._mask)
-        assert_equal(a_pickled._data, a._data)
-        assert_equal(a_pickled.fill_value, 999)
-        #
-        a = array(numpy.matrix(range(10)), mask=[1,0,1,0,0]*2)
-        a_pickled = cPickle.loads(a.dumps())
-        assert_equal(a_pickled._mask, a._mask)
-        assert_equal(a_pickled, a)
-        assert(isinstance(a_pickled._data,numpy.matrix))
-    #
-    def test_fillvalue(self):
-        "Having fun with the fill_value"
-        data = masked_array([1,2,3],fill_value=-999)
-        series = data[[0,2,1]]
-        assert_equal(series._fill_value, data._fill_value)
-        #
-        mtype = [('f',float_),('s','|S3')]
-        x = array([(1,'a'),(2,'b'),(numpy.pi,'pi')], dtype=mtype)
-        x.fill_value=999
-        assert_equal(x.fill_value,[999.,'999'])
-        assert_equal(x['f'].fill_value, 999)
-        assert_equal(x['s'].fill_value, '999')
-        #
-        x.fill_value=(9,'???')
-        assert_equal(x.fill_value, (9,'???'))
-        assert_equal(x['f'].fill_value, 9)
-        assert_equal(x['s'].fill_value, '???')
-        #
-        x = array([1,2,3.1])
-        x.fill_value = 999
-        assert_equal(numpy.asarray(x.fill_value).dtype, float_)
-        assert_equal(x.fill_value, 999.)
-    #
-    def test_asarray(self):
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
-        xmm = asarray(xm)
-        assert_equal(xmm._data, xm._data)
-        assert_equal(xmm._mask, xm._mask)
-    #
-    def test_fix_invalid(self):
-        "Checks fix_invalid."
-        data = masked_array(numpy.sqrt([-1., 0., 1.]), mask=[0,0,1])
-        data_fixed = fix_invalid(data)
-        assert_equal(data_fixed._data, [data.fill_value, 0., 1.])
-        assert_equal(data_fixed._mask, [1., 0., 1.])
-    #
-    def test_imag_real(self):
-        "Check complex"
-        xx = array([1+10j,20+2j], mask=[1,0])
-        assert_equal(xx.imag,[10,2])
-        assert_equal(xx.imag.filled(), [1e+20,2])
-        assert_equal(xx.imag.dtype, xx._data.imag.dtype)
-        assert_equal(xx.real,[1,20])
-        assert_equal(xx.real.filled(), [1e+20,20])
-        assert_equal(xx.real.dtype, xx._data.real.dtype)
-    #
-    def test_ndmin(self):
-        "Check the use of ndmin"
-        x = array([1,2,3],mask=[1,0,0], ndmin=2)
-        assert_equal(x.shape,(1,3))
-        assert_equal(x._data,[[1,2,3]])
-        assert_equal(x._mask,[[1,0,0]])
-    #
-    def test_record(self):
-        "Check record access"
-        mtype = [('f',float_),('s','|S3')]
-        x = array([(1,'a'),(2,'b'),(numpy.pi,'pi')], dtype=mtype)
-        x[1] = masked
-        #
-        (xf, xs) = (x['f'], x['s'])
-        assert_equal(xf.data, [1,2,numpy.pi])
-        assert_equal(xf.mask, [0,1,0])
-        assert_equal(xf.dtype, float_)
-        assert_equal(xs.data, ['a', 'b', 'pi'])
-        assert_equal(xs.mask, [0,1,0])
-        assert_equal(xs.dtype, '|S3')
-    #
-
-
-#...............................................................................
-
-class TestUfuncs(NumpyTestCase):
-    "Test class for the application of ufuncs on MaskedArrays."
-    def setUp(self):
-        "Base data definition."
-        self.d = (array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
-                  array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
-
-    def test_testUfuncRegression(self):
-        "Tests new ufuncs on MaskedArrays."
-        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
-                  'sin', 'cos', 'tan',
-                  'arcsin', 'arccos', 'arctan',
-                  'sinh', 'cosh', 'tanh',
-                  'arcsinh',
-                  'arccosh',
-                  'arctanh',
-                  'absolute', 'fabs', 'negative',
-                  # 'nonzero', 'around',
-                  'floor', 'ceil',
-                  # 'sometrue', 'alltrue',
-                  'logical_not',
-                  'add', 'subtract', 'multiply',
-                  'divide', 'true_divide', 'floor_divide',
-                  'remainder', 'fmod', 'hypot', 'arctan2',
-                  'equal', 'not_equal', 'less_equal', 'greater_equal',
-                  'less', 'greater',
-                  'logical_and', 'logical_or', 'logical_xor',
-                  ]:
-            #print f
-            try:
-                uf = getattr(umath, f)
-            except AttributeError:
-                uf = getattr(fromnumeric, f)
-            mf = getattr(coremodule, f)
-            args = self.d[:uf.nin]
-            ur = uf(*args)
-            mr = mf(*args)
-            assert_equal(ur.filled(0), mr.filled(0), f)
-            assert_mask_equal(ur.mask, mr.mask)
-    #........................
-    def test_reduce(self):
-        "Tests reduce on MaskedArrays."
-        a = self.d[0]
-        assert(not alltrue(a,axis=0))
-        assert(sometrue(a,axis=0))
-        assert_equal(sum(a[:3],axis=0), 0)
-        assert_equal(product(a,axis=0), 0)
-        assert_equal(add.reduce(a), pi)
-    #........................
-    def test_minmax(self):
-        "Tests extrema on MaskedArrays."
-        a = arange(1,13).reshape(3,4)
-        amask = masked_where(a < 5,a)
-        assert_equal(amask.max(), a.max())
-        assert_equal(amask.min(), 5)
-        assert_equal(amask.max(0), a.max(0))
-        assert_equal(amask.min(0), [5,6,7,8])
-        assert(amask.max(1)[0].mask)
-        assert(amask.min(1)[0].mask)
-
-#...............................................................................
-
-class TestArrayMethods(NumpyTestCase):
-    "Test class for miscellaneous MaskedArrays methods."
-    def setUp(self):
-        "Base data definition."
-        x = numpy.array([ 8.375,  7.545,  8.828,  8.5  ,  1.757,  5.928,
-                      8.43 ,  7.78 ,  9.865,  5.878,  8.979,  4.732,
-                      3.012,  6.022,  5.095,  3.116,  5.238,  3.957,
-                      6.04 ,  9.63 ,  7.712,  3.382,  4.489,  6.479,
-                      7.189,  9.645,  5.395,  4.961,  9.894,  2.893,
-                      7.357,  9.828,  6.272,  3.758,  6.693,  0.993])
-        X = x.reshape(6,6)
-        XX = x.reshape(3,2,2,3)
-
-        m = numpy.array([0, 1, 0, 1, 0, 0,
-                     1, 0, 1, 1, 0, 1,
-                     0, 0, 0, 1, 0, 1,
-                     0, 0, 0, 1, 1, 1,
-                     1, 0, 0, 1, 0, 0,
-                     0, 0, 1, 0, 1, 0])
-        mx = array(data=x,mask=m)
-        mX = array(data=X,mask=m.reshape(X.shape))
-        mXX = array(data=XX,mask=m.reshape(XX.shape))
-
-        m2 = numpy.array([1, 1, 0, 1, 0, 0,
-                      1, 1, 1, 1, 0, 1,
-                      0, 0, 1, 1, 0, 1,
-                      0, 0, 0, 1, 1, 1,
-                      1, 0, 0, 1, 1, 0,
-                      0, 0, 1, 0, 1, 1])
-        m2x = array(data=x,mask=m2)
-        m2X = array(data=X,mask=m2.reshape(X.shape))
-        m2XX = array(data=XX,mask=m2.reshape(XX.shape))
-        self.d =  (x,X,XX,m,mx,mX,mXX,m2x,m2X,m2XX)
-
-    #------------------------------------------------------
-    def test_trace(self):
-        "Tests trace on MaskedArrays."
-        (x,X,XX,m,mx,mX,mXX,m2x,m2X,m2XX) = self.d
-        mXdiag = mX.diagonal()
-        assert_equal(mX.trace(), mX.diagonal().compressed().sum())
-        assert_almost_equal(mX.trace(),
-                            X.trace() - sum(mXdiag.mask*X.diagonal(),axis=0))
-
-    def test_clip(self):
-        "Tests clip on MaskedArrays."
-        (x,X,XX,m,mx,mX,mXX,m2x,m2X,m2XX) = self.d
-        clipped = mx.clip(2,8)
-        assert_equal(clipped.mask,mx.mask)
-        assert_equal(clipped.data,x.clip(2,8))
-        assert_equal(clipped.data,mx.data.clip(2,8))
-
-    def test_ptp(self):
-        "Tests ptp on MaskedArrays."
-        (x,X,XX,m,mx,mX,mXX,m2x,m2X,m2XX) = self.d
-        (n,m) = X.shape
-        assert_equal(mx.ptp(),mx.compressed().ptp())
-        rows = numpy.zeros(n,numpy.float_)
-        cols = numpy.zeros(m,numpy.float_)
-        for k in range(m):
-            cols[k] = mX[:,k].compressed().ptp()
-        for k in range(n):
-            rows[k] = mX[k].compressed().ptp()
-        assert_equal(mX.ptp(0),cols)
-        assert_equal(mX.ptp(1),rows)
-
-    def test_swapaxes(self):
-        "Tests swapaxes on MaskedArrays."
-        (x,X,XX,m,mx,mX,mXX,m2x,m2X,m2XX) = self.d
-        mXswapped = mX.swapaxes(0,1)
-        assert_equal(mXswapped[-1],mX[:,-1])
-        mXXswapped = mXX.swapaxes(0,2)
-        assert_equal(mXXswapped.shape,(2,2,3,3))
-
-    def test_cumsumprod(self):
-        "Tests cumsum & cumprod on MaskedArrays."
-        (x,X,XX,m,mx,mX,mXX,m2x,m2X,m2XX) = self.d
-        mXcp = mX.cumsum(0)
-        assert_equal(mXcp.data,mX.filled(0).cumsum(0))
-        mXcp = mX.cumsum(1)
-        assert_equal(mXcp.data,mX.filled(0).cumsum(1))
-        #
-        mXcp = mX.cumprod(0)
-        assert_equal(mXcp.data,mX.filled(1).cumprod(0))
-        mXcp = mX.cumprod(1)
-        assert_equal(mXcp.data,mX.filled(1).cumprod(1))
-
-    def test_varstd(self):
-        "Tests var & std on MaskedArrays."
-        (x,X,XX,m,mx,mX,mXX,m2x,m2X,m2XX) = self.d
-        assert_almost_equal(mX.var(axis=None),mX.compressed().var())
-        assert_almost_equal(mX.std(axis=None),mX.compressed().std())
-        assert_equal(mXX.var(axis=3).shape,XX.var(axis=3).shape)
-        assert_equal(mX.var().shape,X.var().shape)
-        (mXvar0,mXvar1) = (mX.var(axis=0), mX.var(axis=1))
-        for k in range(6):
-            assert_almost_equal(mXvar1[k],mX[k].compressed().var())
-            assert_almost_equal(mXvar0[k],mX[:,k].compressed().var())
-            assert_almost_equal(numpy.sqrt(mXvar0[k]), mX[:,k].compressed().std())
-
-    def test_argmin(self):
-        "Tests argmin & argmax on MaskedArrays."
-        (x,X,XX,m,mx,mX,mXX,m2x,m2X,m2XX) = self.d
-        #
-        assert_equal(mx.argmin(),35)
-        assert_equal(mX.argmin(),35)
-        assert_equal(m2x.argmin(),4)
-        assert_equal(m2X.argmin(),4)
-        assert_equal(mx.argmax(),28)
-        assert_equal(mX.argmax(),28)
-        assert_equal(m2x.argmax(),31)
-        assert_equal(m2X.argmax(),31)
-        #
-        assert_equal(mX.argmin(0), [2,2,2,5,0,5])
-        assert_equal(m2X.argmin(0), [2,2,4,5,0,4])
-        assert_equal(mX.argmax(0), [0,5,0,5,4,0])
-        assert_equal(m2X.argmax(0), [5,5,0,5,1,0])
-        #
-        assert_equal(mX.argmin(1), [4,1,0,0,5,5,])
-        assert_equal(m2X.argmin(1), [4,4,0,0,5,3])
-        assert_equal(mX.argmax(1), [2,4,1,1,4,1])
-        assert_equal(m2X.argmax(1), [2,4,1,1,1,1])
-
-    def test_put(self):
-        "Tests put."
-        d = arange(5)
-        n = [0,0,0,1,1]
-        m = make_mask(n)
-        x = array(d, mask = m)
-        assert( x[3] is masked)
-        assert( x[4] is masked)
-        x[[1,4]] = [10,40]
-#        assert( x.mask is not m)
-        assert( x[3] is masked)
-        assert( x[4] is not masked)
-        assert_equal(x, [0,10,2,-1,40])
-        #
-        x = masked_array(arange(10), mask=[1,0,0,0,0]*2)
-        i = [0,2,4,6]
-        x.put(i, [6,4,2,0])
-        assert_equal(x, asarray([6,1,4,3,2,5,0,7,8,9,]))
-        assert_equal(x.mask, [0,0,0,0,0,1,0,0,0,0])
-        x.put(i, masked_array([0,2,4,6],[1,0,1,0]))
-        assert_array_equal(x, [0,1,2,3,4,5,6,7,8,9,])
-        assert_equal(x.mask, [1,0,0,0,1,1,0,0,0,0])
-        #
-        x = masked_array(arange(10), mask=[1,0,0,0,0]*2)
-        put(x, i, [6,4,2,0])
-        assert_equal(x, asarray([6,1,4,3,2,5,0,7,8,9,]))
-        assert_equal(x.mask, [0,0,0,0,0,1,0,0,0,0])
-        put(x, i, masked_array([0,2,4,6],[1,0,1,0]))
-        assert_array_equal(x, [0,1,2,3,4,5,6,7,8,9,])
-        assert_equal(x.mask, [1,0,0,0,1,1,0,0,0,0])
-
-    def test_put_hardmask(self):
-        "Tests put on hardmask"
-        d = arange(5)
-        n = [0,0,0,1,1]
-        m = make_mask(n)
-        xh = array(d+1, mask = m, hard_mask=True, copy=True)
-        xh.put([4,2,0,1,3],[1,2,3,4,5])
-        assert_equal(xh._data, [3,4,2,4,5])
-
-    def test_take(self):
-        "Tests take"
-        x = masked_array([10,20,30,40],[0,1,0,1])
-        assert_equal(x.take([0,0,3]), masked_array([10, 10, 40], [0,0,1]) )
-        assert_equal(x.take([0,0,3]), x[[0,0,3]])
-        assert_equal(x.take([[0,1],[0,1]]),
-                     masked_array([[10,20],[10,20]], [[0,1],[0,1]]) )
-        #
-        x = array([[10,20,30],[40,50,60]], mask=[[0,0,1],[1,0,0,]])
-        assert_equal(x.take([0,2], axis=1),
-                     array([[10,30],[40,60]], mask=[[0,1],[1,0]]))
-        assert_equal(take(x, [0,2], axis=1),
-                      array([[10,30],[40,60]], mask=[[0,1],[1,0]]))
-        #........................
-    def test_anyall(self):
-        """Checks the any/all methods/functions."""
-        x = numpy.array([[ 0.13,  0.26,  0.90],
-                     [ 0.28,  0.33,  0.63],
-                     [ 0.31,  0.87,  0.70]])
-        m = numpy.array([[ True, False, False],
-                     [False, False, False],
-                     [True,  True, False]], dtype=numpy.bool_)
-        mx = masked_array(x, mask=m)
-        xbig = numpy.array([[False, False,  True],
-                        [False, False,  True],
-                        [False,  True,  True]], dtype=numpy.bool_)
-        mxbig = (mx > 0.5)
-        mxsmall = (mx < 0.5)
-        #
-        assert (mxbig.all()==False)
-        assert (mxbig.any()==True)
-        assert_equal(mxbig.all(0),[False, False, True])
-        assert_equal(mxbig.all(1), [False, False, True])
-        assert_equal(mxbig.any(0),[False, False, True])
-        assert_equal(mxbig.any(1), [True, True, True])
-        #
-        assert (mxsmall.all()==False)
-        assert (mxsmall.any()==True)
-        assert_equal(mxsmall.all(0), [True,   True, False])
-        assert_equal(mxsmall.all(1), [False, False, False])
-        assert_equal(mxsmall.any(0), [True,   True, False])
-        assert_equal(mxsmall.any(1), [True,   True, False])
-        #
-        X = numpy.matrix(x)
-        mX = masked_array(X, mask=m)
-        mXbig = (mX > 0.5)
-        mXsmall = (mX < 0.5)
-        #
-        assert (mXbig.all()==False)
-        assert (mXbig.any()==True)
-        assert_equal(mXbig.all(0), numpy.matrix([False, False, True]))
-        assert_equal(mXbig.all(1), numpy.matrix([False, False, True]).T)
-        assert_equal(mXbig.any(0), numpy.matrix([False, False, True]))
-        assert_equal(mXbig.any(1), numpy.matrix([ True,  True, True]).T)
-        #
-        assert (mXsmall.all()==False)
-        assert (mXsmall.any()==True)
-        assert_equal(mXsmall.all(0), numpy.matrix([True,   True, False]))
-        assert_equal(mXsmall.all(1), numpy.matrix([False, False, False]).T)
-        assert_equal(mXsmall.any(0), numpy.matrix([True,   True, False]))
-        assert_equal(mXsmall.any(1), numpy.matrix([True,   True, False]).T)
-
-    def test_keepmask(self):
-        "Tests the keep mask flag"
-        x = masked_array([1,2,3], mask=[1,0,0])
-        mx = masked_array(x)
-        assert_equal(mx.mask, x.mask)
-        mx = masked_array(x, mask=[0,1,0], keep_mask=False)
-        assert_equal(mx.mask, [0,1,0])
-        mx = masked_array(x, mask=[0,1,0], keep_mask=True)
-        assert_equal(mx.mask, [1,1,0])
-        # We default to true
-        mx = masked_array(x, mask=[0,1,0])
-        assert_equal(mx.mask, [1,1,0])
-
-    def test_hardmask(self):
-        "Test hard_mask"
-        d = arange(5)
-        n = [0,0,0,1,1]
-        m = make_mask(n)
-        xh = array(d, mask = m, hard_mask=True)
-        # We need to copy, to avoid updating d in xh!
-        xs = array(d, mask = m, hard_mask=False, copy=True)
-        xh[[1,4]] = [10,40]
-        xs[[1,4]] = [10,40]
-        assert_equal(xh._data, [0,10,2,3,4])
-        assert_equal(xs._data, [0,10,2,3,40])
-        #assert_equal(xh.mask.ctypes.data, m.ctypes.data)
-        assert_equal(xs.mask, [0,0,0,1,0])
-        assert(xh._hardmask)
-        assert(not xs._hardmask)
-        xh[1:4] = [10,20,30]
-        xs[1:4] = [10,20,30]
-        assert_equal(xh._data, [0,10,20,3,4])
-        assert_equal(xs._data, [0,10,20,30,40])
-        #assert_equal(xh.mask.ctypes.data, m.ctypes.data)
-        assert_equal(xs.mask, nomask)
-        xh[0] = masked
-        xs[0] = masked
-        assert_equal(xh.mask, [1,0,0,1,1])
-        assert_equal(xs.mask, [1,0,0,0,0])
-        xh[:] = 1
-        xs[:] = 1
-        assert_equal(xh._data, [0,1,1,3,4])
-        assert_equal(xs._data, [1,1,1,1,1])
-        assert_equal(xh.mask, [1,0,0,1,1])
-        assert_equal(xs.mask, nomask)
-        # Switch to soft mask
-        xh.soften_mask()
-        xh[:] = arange(5)
-        assert_equal(xh._data, [0,1,2,3,4])
-        assert_equal(xh.mask, nomask)
-        # Switch back to hard mask
-        xh.harden_mask()
-        xh[xh<3] = masked
-        assert_equal(xh._data, [0,1,2,3,4])
-        assert_equal(xh._mask, [1,1,1,0,0])
-        xh[filled(xh>1,False)] = 5
-        assert_equal(xh._data, [0,1,2,5,5])
-        assert_equal(xh._mask, [1,1,1,0,0])
-        #
-        xh = array([[1,2],[3,4]], mask = [[1,0],[0,0]], hard_mask=True)
-        xh[0] = 0
-        assert_equal(xh._data, [[1,0],[3,4]])
-        assert_equal(xh._mask, [[1,0],[0,0]])
-        xh[-1,-1] = 5
-        assert_equal(xh._data, [[1,0],[3,5]])
-        assert_equal(xh._mask, [[1,0],[0,0]])
-        xh[filled(xh<5,False)] = 2
-        assert_equal(xh._data, [[1,2],[2,5]])
-        assert_equal(xh._mask, [[1,0],[0,0]])
-        #
-        "Another test of hardmask"
-        d = arange(5)
-        n = [0,0,0,1,1]
-        m = make_mask(n)
-        xh = array(d, mask = m, hard_mask=True)
-        xh[4:5] = 999
-        #assert_equal(xh.mask.ctypes.data, m.ctypes.data)
-        xh[0:1] = 999
-        assert_equal(xh._data,[999,1,2,3,4])
-
-    def test_smallmask(self):
-        "Checks the behaviour of _smallmask"
-        a = arange(10)
-        a[1] = masked
-        a[1] = 1
-        assert_equal(a._mask, nomask)
-        a = arange(10)
-        a._smallmask = False
-        a[1] = masked
-        a[1] = 1
-        assert_equal(a._mask, zeros(10))
-
-
-    def test_sort(self):
-        "Test sort"
-        x = array([1,4,2,3],mask=[0,1,0,0],dtype=numpy.uint8)
-        #
-        sortedx = sort(x)
-        assert_equal(sortedx._data,[1,2,3,4])
-        assert_equal(sortedx._mask,[0,0,0,1])
-        #
-        sortedx = sort(x, endwith=False)
-        assert_equal(sortedx._data, [4,1,2,3])
-        assert_equal(sortedx._mask, [1,0,0,0])
-        #
-        x.sort()
-        assert_equal(x._data,[1,2,3,4])
-        assert_equal(x._mask,[0,0,0,1])
-        #
-        x = array([1,4,2,3],mask=[0,1,0,0],dtype=numpy.uint8)
-        x.sort(endwith=False)
-        assert_equal(x._data, [4,1,2,3])
-        assert_equal(x._mask, [1,0,0,0])
-        #
-        x = [1,4,2,3]
-        sortedx = sort(x)
-        assert(not isinstance(sorted, MaskedArray))
-        #
-        x = array([0,1,-1,-2,2], mask=nomask, dtype=numpy.int8)
-        sortedx = sort(x, endwith=False)
-        assert_equal(sortedx._data, [-2,-1,0,1,2])
-        x = array([0,1,-1,-2,2], mask=[0,1,0,0,1], dtype=numpy.int8)
-        sortedx = sort(x, endwith=False)
-        assert_equal(sortedx._data, [1,2,-2,-1,0])
-        assert_equal(sortedx._mask, [1,1,0,0,0])
-
-    def test_sort_2d(self):
-        "Check sort of 2D array."
-        # 2D array w/o mask
-        a = masked_array([[8,4,1],[2,0,9]])
-        a.sort(0)
-        assert_equal(a, [[2,0,1],[8,4,9]])
-        a = masked_array([[8,4,1],[2,0,9]])
-        a.sort(1)
-        assert_equal(a, [[1,4,8],[0,2,9]])
-        # 2D array w/mask
-        a = masked_array([[8,4,1],[2,0,9]], mask=[[1,0,0],[0,0,1]])
-        a.sort(0)
-        assert_equal(a, [[2,0,1],[8,4,9]])
-        assert_equal(a._mask, [[0,0,0],[1,0,1]])
-        a = masked_array([[8,4,1],[2,0,9]], mask=[[1,0,0],[0,0,1]])
-        a.sort(1)
-        assert_equal(a, [[1,4,8],[0,2,9]])
-        assert_equal(a._mask, [[0,0,1],[0,0,1]])
-        # 3D
-        a = masked_array([[[7, 8, 9],[4, 5, 6],[1, 2, 3]],
-                          [[1, 2, 3],[7, 8, 9],[4, 5, 6]],
-                          [[7, 8, 9],[1, 2, 3],[4, 5, 6]],
-                          [[4, 5, 6],[1, 2, 3],[7, 8, 9]]])
-        a[a%4==0] = masked
-        am = a.copy()
-        an = a.filled(99)
-        am.sort(0)
-        an.sort(0)
-        assert_equal(am, an)
-        am = a.copy()
-        an = a.filled(99)
-        am.sort(1)
-        an.sort(1)
-        assert_equal(am, an)
-        am = a.copy()
-        an = a.filled(99)
-        am.sort(2)
-        an.sort(2)
-        assert_equal(am, an)
-
-
-    def test_ravel(self):
-        "Tests ravel"
-        a = array([[1,2,3,4,5]], mask=[[0,1,0,0,0]])
-        aravel = a.ravel()
-        assert_equal(a._mask.shape, a.shape)
-        a = array([0,0], mask=[1,1])
-        aravel = a.ravel()
-        assert_equal(a._mask.shape, a.shape)
-        a = array(numpy.matrix([1,2,3,4,5]), mask=[[0,1,0,0,0]])
-        aravel = a.ravel()
-        assert_equal(a.shape,(1,5))
-        assert_equal(a._mask.shape, a.shape)
-        # Checs that small_mask is preserved
-        a = array([1,2,3,4],mask=[0,0,0,0],shrink=False)
-        assert_equal(a.ravel()._mask, [0,0,0,0])
-
-    def test_reshape(self):
-        "Tests reshape"
-        x = arange(4)
-        x[0] = masked
-        y = x.reshape(2,2)
-        assert_equal(y.shape, (2,2,))
-        assert_equal(y._mask.shape, (2,2,))
-        assert_equal(x.shape, (4,))
-        assert_equal(x._mask.shape, (4,))
-
-    def test_compressed(self):
-        "Tests compressed"
-        a = array([1,2,3,4],mask=[0,0,0,0])
-        b = a.compressed()
-        assert_equal(b, a)
-        assert_equal(b._mask, nomask)
-        a[0] = masked
-        b = a.compressed()
-        assert_equal(b._data, [2,3,4])
-        assert_equal(b._mask, nomask)
-
-    def test_tolist(self):
-        "Tests to list"
-        x = array(numpy.arange(12))
-        x[[1,-2]] = masked
-        xlist = x.tolist()
-        assert(xlist[1] is None)
-        assert(xlist[-2] is None)
-        #
-        x.shape = (3,4)
-        xlist = x.tolist()
-        #
-        assert_equal(xlist[0],[0,None,2,3])
-        assert_equal(xlist[1],[4,5,6,7])
-        assert_equal(xlist[2],[8,9,None,11])
-        # Make sure a masked record is output as a tuple of None
-        x = array(zip([1,2,3],
-                      [1.1,2.2,3.3],
-                      ['one','two','thr']),
-                  dtype=[('a',int_),('b',float_),('c','|S8')])
-        x[-1] = masked
-        assert_equal(x.tolist(), [(1,1.1,'one'),(2,2.2,'two'),(None,None,None)])
-
-
-    def test_squeeze(self):
-        "Check squeeze"
-        data = masked_array([[1,2,3]])
-        assert_equal(data.squeeze(), [1,2,3])
-        data = masked_array([[1,2,3]], mask=[[1,1,1]])
-        assert_equal(data.squeeze(), [1,2,3])
-        assert_equal(data.squeeze()._mask, [1,1,1])
-        data = masked_array([[1]], mask=True)
-        assert(data.squeeze() is masked)
-
-    def test_putmask(self):
-        x = arange(6)+1
-        mx = array(x, mask=[0,0,0,1,1,1])
-        mask = [0,0,1,0,0,1]
-        # w/o mask, w/o masked values
-        xx = x.copy()
-        putmask(xx, mask, 99)
-        assert_equal(xx, [1,2,99,4,5,99])
-        # w/ mask, w/o masked values
-        mxx = mx.copy()
-        putmask(mxx, mask, 99)
-        assert_equal(mxx._data, [1,2,99,4,5,99])
-        assert_equal(mxx._mask, [0,0,0,1,1,0])
-        # w/o mask, w/ masked values
-        values = array([10,20,30,40,50,60],mask=[1,1,1,0,0,0])
-        xx = x.copy()
-        putmask(xx, mask, values)
-        assert_equal(xx._data, [1,2,30,4,5,60])
-        assert_equal(xx._mask, [0,0,1,0,0,0])
-        # w/ mask, w/ masked values
-        mxx = mx.copy()
-        putmask(mxx, mask, values)
-        assert_equal(mxx._data, [1,2,30,4,5,60])
-        assert_equal(mxx._mask, [0,0,1,1,1,0])
-        # w/ mask, w/ masked values + hardmask
-        mxx = mx.copy()
-        mxx.harden_mask()
-        putmask(mxx, mask, values)
-        assert_equal(mxx, [1,2,30,4,5,60])
-
-    def test_compress(self):
-        "test compress"
-        a = masked_array([1., 2., 3., 4., 5.], fill_value=9999)
-        condition = (a > 1.5) & (a < 3.5)
-        assert_equal(a.compress(condition),[2.,3.])
-        #
-        a[[2,3]] = masked
-        b = a.compress(condition)
-        assert_equal(b._data,[2.,3.])
-        assert_equal(b._mask,[0,1])
-        assert_equal(b.fill_value,9999)
-        assert_equal(b,a[condition])
-        #
-        condition = (a<4.)
-        b = a.compress(condition)
-        assert_equal(b._data,[1.,2.,3.])
-        assert_equal(b._mask,[0,0,1])
-        assert_equal(b.fill_value,9999)
-        assert_equal(b,a[condition])
-        #
-        a = masked_array([[10,20,30],[40,50,60]], mask=[[0,0,1],[1,0,0]])
-        b = a.compress(a.ravel() >= 22)
-        assert_equal(b._data, [30, 40, 50, 60])
-        assert_equal(b._mask, [1,1,0,0])
-        #
-        x = numpy.array([3,1,2])
-        b = a.compress(x >= 2, axis=1)
-        assert_equal(b._data, [[10,30],[40,60]])
-        assert_equal(b._mask, [[0,1],[1,0]])
-    #
-    def test_empty(self):
-        "Tests empty/like"
-        datatype = [('a',int_),('b',float_),('c','|S8')]
-        a = masked_array([(1,1.1,'1.1'),(2,2.2,'2.2'),(3,3.3,'3.3')],
-                         dtype=datatype)
-        assert_equal(len(a.fill_value), len(datatype))
-        #
-        b = empty_like(a)
-        assert_equal(b.shape, a.shape)
-        assert_equal(b.fill_value, a.fill_value)
-        #
-        b = empty(len(a), dtype=datatype)
-        assert_equal(b.shape, a.shape)
-        assert_equal(b.fill_value, a.fill_value)
-
-
-#..............................................................................
-
-###############################################################################
-#------------------------------------------------------------------------------
-if __name__ == "__main__":
-    NumpyTest().run()

Copied: trunk/numpy/ma/tests/test_core.py (from rev 4777, branches/maskedarray/numpy/ma/tests/test_core.py)

Deleted: trunk/numpy/ma/tests/test_extras.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_extras.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/tests/test_extras.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,331 +0,0 @@
-# pylint: disable-msg=W0611, W0612, W0511
-"""Tests suite for MaskedArray.
-Adapted from the original test_ma by Pierre Gerard-Marchant
-
-:author: Pierre Gerard-Marchant
-:contact: pierregm_at_uga_dot_edu
-:version: $Id: test_extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $
-"""
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
-import numpy as N
-from numpy.testing import NumpyTest, NumpyTestCase
-from numpy.testing.utils import build_err_msg
-
-import numpy.ma.testutils
-from numpy.ma.testutils import *
-
-import numpy.ma.core
-from numpy.ma.core import *
-import numpy.ma.extras
-from numpy.ma.extras import *
-
-class TestAverage(NumpyTestCase):
-    "Several tests of average. Why so many ? Good point..."
-    def check_testAverage1(self):
-        "Test of average."
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        assert_equal(2.0, average(ott,axis=0))
-        assert_equal(2.0, average(ott, weights=[1., 1., 2., 1.]))
-        result, wts = average(ott, weights=[1.,1.,2.,1.], returned=1)
-        assert_equal(2.0, result)
-        assert(wts == 4.0)
-        ott[:] = masked
-        assert_equal(average(ott,axis=0).mask, [True])
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        ott = ott.reshape(2,2)
-        ott[:,1] = masked
-        assert_equal(average(ott,axis=0), [2.0, 0.0])
-        assert_equal(average(ott,axis=1).mask[0], [True])
-        assert_equal([2.,0.], average(ott, axis=0))
-        result, wts = average(ott, axis=0, returned=1)
-        assert_equal(wts, [1., 0.])
-
-    def check_testAverage2(self):
-        "More tests of average."
-        w1 = [0,1,1,1,1,0]
-        w2 = [[0,1,1,1,1,0],[1,0,0,0,0,1]]
-        x = arange(6, dtype=float_)
-        assert_equal(average(x, axis=0), 2.5)
-        assert_equal(average(x, axis=0, weights=w1), 2.5)
-        y = array([arange(6, dtype=float_), 2.0*arange(6)])
-        assert_equal(average(y, None), N.add.reduce(N.arange(6))*3./12.)
-        assert_equal(average(y, axis=0), N.arange(6) * 3./2.)
-        assert_equal(average(y, axis=1), [average(x,axis=0), average(x,axis=0) * 2.0])
-        assert_equal(average(y, None, weights=w2), 20./6.)
-        assert_equal(average(y, axis=0, weights=w2), [0.,1.,2.,3.,4.,10.])
-        assert_equal(average(y, axis=1), [average(x,axis=0), average(x,axis=0) * 2.0])
-        m1 = zeros(6)
-        m2 = [0,0,1,1,0,0]
-        m3 = [[0,0,1,1,0,0],[0,1,1,1,1,0]]
-        m4 = ones(6)
-        m5 = [0, 1, 1, 1, 1, 1]
-        assert_equal(average(masked_array(x, m1),axis=0), 2.5)
-        assert_equal(average(masked_array(x, m2),axis=0), 2.5)
-        assert_equal(average(masked_array(x, m4),axis=0).mask, [True])
-        assert_equal(average(masked_array(x, m5),axis=0), 0.0)
-        assert_equal(count(average(masked_array(x, m4),axis=0)), 0)
-        z = masked_array(y, m3)
-        assert_equal(average(z, None), 20./6.)
-        assert_equal(average(z, axis=0), [0.,1.,99.,99.,4.0, 7.5])
-        assert_equal(average(z, axis=1), [2.5, 5.0])
-        assert_equal(average(z,axis=0, weights=w2), [0.,1., 99., 99., 4.0, 10.0])
-
-    def check_testAverage3(self):
-        "Yet more tests of average!"
-        a = arange(6)
-        b = arange(6) * 3
-        r1, w1 = average([[a,b],[b,a]], axis=1, returned=1)
-        assert_equal(shape(r1) , shape(w1))
-        assert_equal(r1.shape , w1.shape)
-        r2, w2 = average(ones((2,2,3)), axis=0, weights=[3,1], returned=1)
-        assert_equal(shape(w2) , shape(r2))
-        r2, w2 = average(ones((2,2,3)), returned=1)
-        assert_equal(shape(w2) , shape(r2))
-        r2, w2 = average(ones((2,2,3)), weights=ones((2,2,3)), returned=1)
-        assert_equal(shape(w2), shape(r2))
-        a2d = array([[1,2],[0,4]], float)
-        a2dm = masked_array(a2d, [[0,0],[1,0]])
-        a2da = average(a2d, axis=0)
-        assert_equal(a2da, [0.5, 3.0])
-        a2dma = average(a2dm, axis=0)
-        assert_equal(a2dma, [1.0, 3.0])
-        a2dma = average(a2dm, axis=None)
-        assert_equal(a2dma, 7./3.)
-        a2dma = average(a2dm, axis=1)
-        assert_equal(a2dma, [1.5, 4.0])
-
-class TestConcatenator(NumpyTestCase):
-    "Tests for mr_, the equivalent of r_ for masked arrays."
-    def check_1d(self):
-        "Tests mr_ on 1D arrays."
-        assert_array_equal(mr_[1,2,3,4,5,6],array([1,2,3,4,5,6]))
-        b = ones(5)
-        m = [1,0,0,0,0]
-        d = masked_array(b,mask=m)
-        c = mr_[d,0,0,d]
-        assert(isinstance(c,MaskedArray) or isinstance(c,core.MaskedArray))
-        assert_array_equal(c,[1,1,1,1,1,0,0,1,1,1,1,1])
-        assert_array_equal(c.mask, mr_[m,0,0,m])
-
-    def check_2d(self):
-        "Tests mr_ on 2D arrays."
-        a_1 = rand(5,5)
-        a_2 = rand(5,5)
-        m_1 = N.round_(rand(5,5),0)
-        m_2 = N.round_(rand(5,5),0)
-        b_1 = masked_array(a_1,mask=m_1)
-        b_2 = masked_array(a_2,mask=m_2)
-        d = mr_['1',b_1,b_2]  # append columns
-        assert(d.shape == (5,10))
-        assert_array_equal(d[:,:5],b_1)
-        assert_array_equal(d[:,5:],b_2)
-        assert_array_equal(d.mask, N.r_['1',m_1,m_2])
-        d = mr_[b_1,b_2]
-        assert(d.shape == (10,5))
-        assert_array_equal(d[:5,:],b_1)
-        assert_array_equal(d[5:,:],b_2)
-        assert_array_equal(d.mask, N.r_[m_1,m_2])
-
-class TestNotMasked(NumpyTestCase):
-    "Tests notmasked_edges and notmasked_contiguous."
-    def check_edges(self):
-        "Tests unmasked_edges"
-        a = masked_array(N.arange(24).reshape(3,8),
-                         mask=[[0,0,0,0,1,1,1,0],
-                               [1,1,1,1,1,1,1,1],
-                               [0,0,0,0,0,0,1,0],])
-        #
-        assert_equal(notmasked_edges(a, None), [0,23])
-        #
-        tmp = notmasked_edges(a, 0)
-        assert_equal(tmp[0], (array([0,0,0,0,2,2,0]), array([0,1,2,3,4,5,7])))
-        assert_equal(tmp[1], (array([2,2,2,2,2,2,2]), array([0,1,2,3,4,5,7])))
-        #
-        tmp = notmasked_edges(a, 1)
-        assert_equal(tmp[0], (array([0,2,]), array([0,0])))
-        assert_equal(tmp[1], (array([0,2,]), array([7,7])))
-
-    def check_contiguous(self):
-        "Tests notmasked_contiguous"
-        a = masked_array(N.arange(24).reshape(3,8),
-                         mask=[[0,0,0,0,1,1,1,1],
-                               [1,1,1,1,1,1,1,1],
-                               [0,0,0,0,0,0,1,0],])
-        tmp = notmasked_contiguous(a, None)
-        assert_equal(tmp[-1], slice(23,23,None))
-        assert_equal(tmp[-2], slice(16,21,None))
-        assert_equal(tmp[-3], slice(0,3,None))
-        #
-        tmp = notmasked_contiguous(a, 0)
-        assert(len(tmp[-1]) == 1)
-        assert(tmp[-2] is None)
-        assert_equal(tmp[-3],tmp[-1])
-        assert(len(tmp[0]) == 2)
-        #
-        tmp = notmasked_contiguous(a, 1)
-        assert_equal(tmp[0][-1], slice(0,3,None))
-        assert(tmp[1] is None)
-        assert_equal(tmp[2][-1], slice(7,7,None))
-        assert_equal(tmp[2][-2], slice(0,5,None))
-
-class Test2DFunctions(NumpyTestCase):
-    "Tests 2D functions"
-    def check_compress2d(self):
-        "Tests compress2d"
-        x = array(N.arange(9).reshape(3,3), mask=[[1,0,0],[0,0,0],[0,0,0]])
-        assert_equal(compress_rowcols(x), [[4,5],[7,8]] )
-        assert_equal(compress_rowcols(x,0), [[3,4,5],[6,7,8]] )
-        assert_equal(compress_rowcols(x,1), [[1,2],[4,5],[7,8]] )
-        x = array(x._data, mask=[[0,0,0],[0,1,0],[0,0,0]])
-        assert_equal(compress_rowcols(x), [[0,2],[6,8]] )
-        assert_equal(compress_rowcols(x,0), [[0,1,2],[6,7,8]] )
-        assert_equal(compress_rowcols(x,1), [[0,2],[3,5],[6,8]] )
-        x = array(x._data, mask=[[1,0,0],[0,1,0],[0,0,0]])
-        assert_equal(compress_rowcols(x), [[8]] )
-        assert_equal(compress_rowcols(x,0), [[6,7,8]] )
-        assert_equal(compress_rowcols(x,1,), [[2],[5],[8]] )
-        x = array(x._data, mask=[[1,0,0],[0,1,0],[0,0,1]])
-        assert_equal(compress_rowcols(x).size, 0 )
-        assert_equal(compress_rowcols(x,0).size, 0 )
-        assert_equal(compress_rowcols(x,1).size, 0 )
-    #
-    def check_mask_rowcols(self):
-        "Tests mask_rowcols."
-        x = array(N.arange(9).reshape(3,3), mask=[[1,0,0],[0,0,0],[0,0,0]])
-        assert_equal(mask_rowcols(x).mask, [[1,1,1],[1,0,0],[1,0,0]] )
-        assert_equal(mask_rowcols(x,0).mask, [[1,1,1],[0,0,0],[0,0,0]] )
-        assert_equal(mask_rowcols(x,1).mask, [[1,0,0],[1,0,0],[1,0,0]] )
-        x = array(x._data, mask=[[0,0,0],[0,1,0],[0,0,0]])
-        assert_equal(mask_rowcols(x).mask, [[0,1,0],[1,1,1],[0,1,0]] )
-        assert_equal(mask_rowcols(x,0).mask, [[0,0,0],[1,1,1],[0,0,0]] )
-        assert_equal(mask_rowcols(x,1).mask, [[0,1,0],[0,1,0],[0,1,0]] )
-        x = array(x._data, mask=[[1,0,0],[0,1,0],[0,0,0]])
-        assert_equal(mask_rowcols(x).mask, [[1,1,1],[1,1,1],[1,1,0]] )
-        assert_equal(mask_rowcols(x,0).mask, [[1,1,1],[1,1,1],[0,0,0]] )
-        assert_equal(mask_rowcols(x,1,).mask, [[1,1,0],[1,1,0],[1,1,0]] )
-        x = array(x._data, mask=[[1,0,0],[0,1,0],[0,0,1]])
-        assert(mask_rowcols(x).all())
-        assert(mask_rowcols(x,0).all())
-        assert(mask_rowcols(x,1).all())
-    #
-    def test_dot(self):
-        "Tests dot product"
-        n = N.arange(1,7)
-        #
-        m = [1,0,0,0,0,0]
-        a = masked_array(n, mask=m).reshape(2,3)
-        b = masked_array(n, mask=m).reshape(3,2)
-        c = dot(a,b,True)
-        assert_equal(c.mask, [[1,1],[1,0]])
-        c = dot(b,a,True)
-        assert_equal(c.mask, [[1,1,1],[1,0,0],[1,0,0]])
-        c = dot(a,b,False)
-        assert_equal(c, N.dot(a.filled(0), b.filled(0)))
-        c = dot(b,a,False)
-        assert_equal(c, N.dot(b.filled(0), a.filled(0)))
-        #
-        m = [0,0,0,0,0,1]
-        a = masked_array(n, mask=m).reshape(2,3)
-        b = masked_array(n, mask=m).reshape(3,2)
-        c = dot(a,b,True)
-        assert_equal(c.mask,[[0,1],[1,1]])
-        c = dot(b,a,True)
-        assert_equal(c.mask, [[0,0,1],[0,0,1],[1,1,1]])
-        c = dot(a,b,False)
-        assert_equal(c, N.dot(a.filled(0), b.filled(0)))
-        assert_equal(c, dot(a,b))
-        c = dot(b,a,False)
-        assert_equal(c, N.dot(b.filled(0), a.filled(0)))
-        #
-        m = [0,0,0,0,0,0]
-        a = masked_array(n, mask=m).reshape(2,3)
-        b = masked_array(n, mask=m).reshape(3,2)
-        c = dot(a,b)
-        assert_equal(c.mask,nomask)
-        c = dot(b,a)
-        assert_equal(c.mask,nomask)
-        #
-        a = masked_array(n, mask=[1,0,0,0,0,0]).reshape(2,3)
-        b = masked_array(n, mask=[0,0,0,0,0,0]).reshape(3,2)
-        c = dot(a,b,True)
-        assert_equal(c.mask,[[1,1],[0,0]])
-        c = dot(a,b,False)
-        assert_equal(c, N.dot(a.filled(0),b.filled(0)))
-        c = dot(b,a,True)
-        assert_equal(c.mask,[[1,0,0],[1,0,0],[1,0,0]])
-        c = dot(b,a,False)
-        assert_equal(c, N.dot(b.filled(0),a.filled(0)))
-        #
-        a = masked_array(n, mask=[0,0,0,0,0,1]).reshape(2,3)
-        b = masked_array(n, mask=[0,0,0,0,0,0]).reshape(3,2)
-        c = dot(a,b,True)
-        assert_equal(c.mask,[[0,0],[1,1]])
-        c = dot(a,b)
-        assert_equal(c, N.dot(a.filled(0),b.filled(0)))
-        c = dot(b,a,True)
-        assert_equal(c.mask,[[0,0,1],[0,0,1],[0,0,1]])
-        c = dot(b,a,False)
-        assert_equal(c, N.dot(b.filled(0), a.filled(0)))
-        #
-        a = masked_array(n, mask=[0,0,0,0,0,1]).reshape(2,3)
-        b = masked_array(n, mask=[0,0,1,0,0,0]).reshape(3,2)
-        c = dot(a,b,True)
-        assert_equal(c.mask,[[1,0],[1,1]])
-        c = dot(a,b,False)
-        assert_equal(c, N.dot(a.filled(0),b.filled(0)))
-        c = dot(b,a,True)
-        assert_equal(c.mask,[[0,0,1],[1,1,1],[0,0,1]])
-        c = dot(b,a,False)
-        assert_equal(c, N.dot(b.filled(0),a.filled(0)))
-
-    def test_mediff1d(self):
-        "Tests mediff1d"
-        x = masked_array(N.arange(5), mask=[1,0,0,0,1])
-        difx_d = (x._data[1:]-x._data[:-1])
-        difx_m = (x._mask[1:]-x._mask[:-1])
-        dx = mediff1d(x)
-        assert_equal(dx._data, difx_d)
-        assert_equal(dx._mask, difx_m)
-        #
-        dx = mediff1d(x, to_begin=masked)
-        assert_equal(dx._data, N.r_[0,difx_d])
-        assert_equal(dx._mask, N.r_[1,difx_m])
-        dx = mediff1d(x, to_begin=[1,2,3])
-        assert_equal(dx._data, N.r_[[1,2,3],difx_d])
-        assert_equal(dx._mask, N.r_[[0,0,0],difx_m])
-        #
-        dx = mediff1d(x, to_end=masked)
-        assert_equal(dx._data, N.r_[difx_d,0])
-        assert_equal(dx._mask, N.r_[difx_m,1])
-        dx = mediff1d(x, to_end=[1,2,3])
-        assert_equal(dx._data, N.r_[difx_d,[1,2,3]])
-        assert_equal(dx._mask, N.r_[difx_m,[0,0,0]])
-        #
-        dx = mediff1d(x, to_end=masked, to_begin=masked)
-        assert_equal(dx._data, N.r_[0,difx_d,0])
-        assert_equal(dx._mask, N.r_[1,difx_m,1])
-        dx = mediff1d(x, to_end=[1,2,3], to_begin=masked)
-        assert_equal(dx._data, N.r_[0,difx_d,[1,2,3]])
-        assert_equal(dx._mask, N.r_[1,difx_m,[0,0,0]])
-        #
-        dx = mediff1d(x._data, to_end=masked, to_begin=masked)
-        assert_equal(dx._data, N.r_[0,difx_d,0])
-        assert_equal(dx._mask, N.r_[1,0,0,0,0,1])
-
-class TestApplyAlongAxis(NumpyTestCase):
-    "Tests 2D functions"
-    def check_3d(self):
-        a = arange(12.).reshape(2,2,3)
-        def myfunc(b):
-            return b[1]
-        xa = apply_along_axis(myfunc,2,a)
-        assert_equal(xa,[[1,4],[7,10]])
-
-###############################################################################
-#------------------------------------------------------------------------------
-if __name__ == "__main__":
-    NumpyTest().run()

Copied: trunk/numpy/ma/tests/test_extras.py (from rev 4777, branches/maskedarray/numpy/ma/tests/test_extras.py)

Deleted: trunk/numpy/ma/tests/test_old_ma.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_old_ma.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/tests/test_old_ma.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,855 +0,0 @@
-import numpy
-import types, time
-from numpy.ma import *
-from numpy.core.numerictypes import float32
-from numpy.testing import NumpyTestCase, NumpyTest
-pi = numpy.pi
-def eq(v,w, msg=''):
-    result = allclose(v,w)
-    if not result:
-        print """Not eq:%s
-%s
-----
-%s"""% (msg, str(v), str(w))
-    return result
-
-class TestMa(NumpyTestCase):
-    def __init__(self, *args, **kwds):
-        NumpyTestCase.__init__(self, *args, **kwds)
-        self.setUp()
-
-    def setUp (self):
-        x=numpy.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
-        y=numpy.array([5.,0.,3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
-        a10 = 10.
-        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 ,0, 1]
-        xm = array(x, mask=m1)
-        ym = array(y, mask=m2)
-        z = numpy.array([-.5, 0., .5, .8])
-        zm = array(z, mask=[0,1,0,0])
-        xf = numpy.where(m1, 1.e+20, x)
-        s = x.shape
-        xm.set_fill_value(1.e+20)
-        self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf, s)
-
-    def check_testBasic1d(self):
-        "Test of basic array creation and properties in 1 dimension."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        self.failIf(isMaskedArray(x))
-        self.failUnless(isMaskedArray(xm))
-        self.assertEqual(shape(xm), s)
-        self.assertEqual(xm.shape, s)
-        self.assertEqual(xm.dtype, x.dtype)
-        self.assertEqual( xm.size , reduce(lambda x,y:x*y, s))
-        self.assertEqual(count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
-        self.failUnless(eq(xm, xf))
-        self.failUnless(eq(filled(xm, 1.e20), xf))
-        self.failUnless(eq(x, xm))
-
-    def check_testBasic2d(self):
-        "Test of basic array creation and properties in 2 dimensions."
-        for s in [(4,3), (6,2)]:
-            (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-            x.shape = s
-            y.shape = s
-            xm.shape = s
-            ym.shape = s
-            xf.shape = s
-
-            self.failIf(isMaskedArray(x))
-            self.failUnless(isMaskedArray(xm))
-            self.assertEqual(shape(xm), s)
-            self.assertEqual(xm.shape, s)
-            self.assertEqual( xm.size , reduce(lambda x,y:x*y, s))
-            self.assertEqual( count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
-            self.failUnless(eq(xm, xf))
-            self.failUnless(eq(filled(xm, 1.e20), xf))
-            self.failUnless(eq(x, xm))
-            self.setUp()
-
-    def check_testArithmetic (self):
-        "Test of basic arithmetic."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        a2d = array([[1,2],[0,4]])
-        a2dm = masked_array(a2d, [[0,0],[1,0]])
-        self.failUnless(eq (a2d * a2d, a2d * a2dm))
-        self.failUnless(eq (a2d + a2d, a2d + a2dm))
-        self.failUnless(eq (a2d - a2d, a2d - a2dm))
-        for s in [(12,), (4,3), (2,6)]:
-            x = x.reshape(s)
-            y = y.reshape(s)
-            xm = xm.reshape(s)
-            ym = ym.reshape(s)
-            xf = xf.reshape(s)
-            self.failUnless(eq(-x, -xm))
-            self.failUnless(eq(x + y, xm + ym))
-            self.failUnless(eq(x - y, xm - ym))
-            self.failUnless(eq(x * y, xm * ym))
-            olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.failUnless(eq(x / y, xm / ym))
-            numpy.seterr(**olderr)
-            self.failUnless(eq(a10 + y, a10 + ym))
-            self.failUnless(eq(a10 - y, a10 - ym))
-            self.failUnless(eq(a10 * y, a10 * ym))
-            olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.failUnless(eq(a10 / y, a10 / ym))
-            numpy.seterr(**olderr)
-            self.failUnless(eq(x + a10, xm + a10))
-            self.failUnless(eq(x - a10, xm - a10))
-            self.failUnless(eq(x * a10, xm * a10))
-            self.failUnless(eq(x / a10, xm / a10))
-            self.failUnless(eq(x**2, xm**2))
-            self.failUnless(eq(abs(x)**2.5, abs(xm) **2.5))
-            self.failUnless(eq(x**y, xm**ym))
-            self.failUnless(eq(numpy.add(x,y), add(xm, ym)))
-            self.failUnless(eq(numpy.subtract(x,y), subtract(xm, ym)))
-            self.failUnless(eq(numpy.multiply(x,y), multiply(xm, ym)))
-            olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.failUnless(eq(numpy.divide(x,y), divide(xm, ym)))
-            numpy.seterr(**olderr)
-
-
-    def check_testMixedArithmetic(self):
-        na = numpy.array([1])
-        ma = array([1])
-        self.failUnless(isinstance(na + ma, MaskedArray))
-        self.failUnless(isinstance(ma + na, MaskedArray))
-
-    def check_testUfuncs1 (self):
-        "Test various functions such as sin, cos."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        self.failUnless (eq(numpy.cos(x), cos(xm)))
-        self.failUnless (eq(numpy.cosh(x), cosh(xm)))
-        self.failUnless (eq(numpy.sin(x), sin(xm)))
-        self.failUnless (eq(numpy.sinh(x), sinh(xm)))
-        self.failUnless (eq(numpy.tan(x), tan(xm)))
-        self.failUnless (eq(numpy.tanh(x), tanh(xm)))
-        olderr = numpy.seterr(divide='ignore', invalid='ignore')
-        self.failUnless (eq(numpy.sqrt(abs(x)), sqrt(xm)))
-        self.failUnless (eq(numpy.log(abs(x)), log(xm)))
-        self.failUnless (eq(numpy.log10(abs(x)), log10(xm)))
-        numpy.seterr(**olderr)
-        self.failUnless (eq(numpy.exp(x), exp(xm)))
-        self.failUnless (eq(numpy.arcsin(z), arcsin(zm)))
-        self.failUnless (eq(numpy.arccos(z), arccos(zm)))
-        self.failUnless (eq(numpy.arctan(z), arctan(zm)))
-        self.failUnless (eq(numpy.arctan2(x, y), arctan2(xm, ym)))
-        self.failUnless (eq(numpy.absolute(x), absolute(xm)))
-        self.failUnless (eq(numpy.equal(x,y), equal(xm, ym)))
-        self.failUnless (eq(numpy.not_equal(x,y), not_equal(xm, ym)))
-        self.failUnless (eq(numpy.less(x,y), less(xm, ym)))
-        self.failUnless (eq(numpy.greater(x,y), greater(xm, ym)))
-        self.failUnless (eq(numpy.less_equal(x,y), less_equal(xm, ym)))
-        self.failUnless (eq(numpy.greater_equal(x,y), greater_equal(xm, ym)))
-        self.failUnless (eq(numpy.conjugate(x), conjugate(xm)))
-        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((xm,ym))))
-        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((x,y))))
-        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((xm,y))))
-        self.failUnless (eq(numpy.concatenate((x,y,x)), concatenate((x,ym,x))))
-
-    def check_xtestCount (self):
-        "Test count"
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        self.failUnless( isinstance(count(ott), types.IntType))
-        self.assertEqual(3, count(ott))
-        self.assertEqual(1, count(1))
-        self.failUnless (eq(0, array(1,mask=[1])))
-        ott=ott.reshape((2,2))
-        assert isMaskedArray(count(ott,0))
-        assert isinstance(count(ott), types.IntType)
-        self.failUnless (eq(3, count(ott)))
-        assert getmask(count(ott,0)) is nomask
-        self.failUnless (eq([1,2],count(ott,0)))
-
-    def check_testMinMax (self):
-        "Test minimum and maximum."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        xr = numpy.ravel(x) #max doesn't work if shaped
-        xmr = ravel(xm)
-        self.failUnless (eq(max(xr), maximum(xmr))) #true because of careful selection of data
-        self.failUnless (eq(min(xr), minimum(xmr))) #true because of careful selection of data
-
-    def check_testAddSumProd (self):
-        "Test add, sum, product."
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        self.failUnless (eq(numpy.add.reduce(x), add.reduce(x)))
-        self.failUnless (eq(numpy.add.accumulate(x), add.accumulate(x)))
-        self.failUnless (eq(4, sum(array(4),axis=0)))
-        self.failUnless (eq(4, sum(array(4), axis=0)))
-        self.failUnless (eq(numpy.sum(x,axis=0), sum(x,axis=0)))
-        self.failUnless (eq(numpy.sum(filled(xm,0),axis=0), sum(xm,axis=0)))
-        self.failUnless (eq(numpy.sum(x,0), sum(x,0)))
-        self.failUnless (eq(numpy.product(x,axis=0), product(x,axis=0)))
-        self.failUnless (eq(numpy.product(x,0), product(x,0)))
-        self.failUnless (eq(numpy.product(filled(xm,1),axis=0), product(xm,axis=0)))
-        if len(s) > 1:
-            self.failUnless (eq(numpy.concatenate((x,y),1), concatenate((xm,ym),1)))
-            self.failUnless (eq(numpy.add.reduce(x,1), add.reduce(x,1)))
-            self.failUnless (eq(numpy.sum(x,1), sum(x,1)))
-            self.failUnless (eq(numpy.product(x,1), product(x,1)))
-
-
-    def check_testCI(self):
-        "Test of conversions and indexing"
-        x1 = numpy.array([1,2,4,3])
-        x2 = array(x1, mask = [1,0,0,0])
-        x3 = array(x1, mask = [0,1,0,1])
-        x4 = array(x1)
-    # test conversion to strings
-        junk, garbage = str(x2), repr(x2)
-        assert eq(numpy.sort(x1),sort(x2, fill_value=0))
-    # tests of indexing
-        assert type(x2[1]) is type(x1[1])
-        assert x1[1] == x2[1]
-        assert x2[0] is masked
-        assert eq(x1[2],x2[2])
-        assert eq(x1[2:5],x2[2:5])
-        assert eq(x1[:],x2[:])
-        assert eq(x1[1:], x3[1:])
-        x1[2]=9
-        x2[2]=9
-        assert eq(x1,x2)
-        x1[1:3] = 99
-        x2[1:3] = 99
-        assert eq(x1,x2)
-        x2[1] = masked
-        assert eq(x1,x2)
-        x2[1:3]=masked
-        assert eq(x1,x2)
-        x2[:] = x1
-        x2[1] = masked
-        assert allequal(getmask(x2),array([0,1,0,0]))
-        x3[:] = masked_array([1,2,3,4],[0,1,1,0])
-        assert allequal(getmask(x3), array([0,1,1,0]))
-        x4[:] = masked_array([1,2,3,4],[0,1,1,0])
-        assert allequal(getmask(x4), array([0,1,1,0]))
-        assert allequal(x4, array([1,2,3,4]))
-        x1 = numpy.arange(5)*1.0
-        x2 = masked_values(x1, 3.0)
-        assert eq(x1,x2)
-        assert allequal(array([0,0,0,1,0],MaskType), x2.mask)
-        assert eq(3.0, x2.fill_value)
-        x1 = array([1,'hello',2,3],object)
-        x2 = numpy.array([1,'hello',2,3],object)
-        s1 = x1[1]
-        s2 = x2[1]
-        self.assertEqual(type(s2), str)
-        self.assertEqual(type(s1), str)
-        self.assertEqual(s1, s2)
-        assert x1[1:1].shape == (0,)
-
-    def check_testCopySize(self):
-        "Tests of some subtle points of copying and sizing."
-        n = [0,0,1,0,0]
-        m = make_mask(n)
-        m2 = make_mask(m)
-        self.failUnless(m is m2)
-        m3 = make_mask(m, copy=1)
-        self.failUnless(m is not m3)
-
-        x1 = numpy.arange(5)
-        y1 = array(x1, mask=m)
-        self.failUnless( y1.data is not x1)
-        self.failUnless( allequal(x1,y1.data))
-        self.failUnless( y1.mask is m)
-
-        y1a = array(y1, copy=0)
-        self.failUnless( y1a.mask is y1.mask)
-
-        y2 = array(x1, mask=m, copy=0)
-        self.failUnless( y2.mask is m)
-        self.failUnless( y2[2] is masked)
-        y2[2]=9
-        self.failUnless( y2[2] is not masked)
-        self.failUnless( y2.mask is not m)
-        self.failUnless( allequal(y2.mask, 0))
-
-        y3 = array(x1*1.0, mask=m)
-        self.failUnless(filled(y3).dtype is (x1*1.0).dtype)
-
-        x4 = arange(4)
-        x4[2] = masked
-        y4 = resize(x4, (8,))
-        self.failUnless( eq(concatenate([x4,x4]), y4))
-        self.failUnless( eq(getmask(y4),[0,0,1,0,0,0,1,0]))
-        y5 = repeat(x4, (2,2,2,2), axis=0)
-        self.failUnless( eq(y5, [0,0,1,1,2,2,3,3]))
-        y6 = repeat(x4, 2, axis=0)
-        self.failUnless( eq(y5, y6))
-
-    def check_testPut(self):
-        "Test of put"
-        d = arange(5)
-        n = [0,0,0,1,1]
-        m = make_mask(n)
-        x = array(d, mask = m)
-        self.failUnless( x[3] is masked)
-        self.failUnless( x[4] is masked)
-        x[[1,4]] = [10,40]
-        self.failUnless( x.mask is not m)
-        self.failUnless( x[3] is masked)
-        self.failUnless( x[4] is not masked)
-        self.failUnless( eq(x, [0,10,2,-1,40]))
-
-        x = array(d, mask = m)
-        x.put([0,1,2],[-1,100,200])
-        self.failUnless( eq(x, [-1,100,200,0,0]))
-        self.failUnless( x[3] is masked)
-        self.failUnless( x[4] is masked)
-
-    def check_testMaPut(self):
-        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
-        m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]
-        i = numpy.nonzero(m)[0]
-        put(ym, i, zm)
-        assert all(take(ym, i, axis=0) == zm)
-
-    def check_testOddFeatures(self):
-        "Test of other odd features"
-        x = arange(20); x=x.reshape(4,5)
-        x.flat[5] = 12
-        assert x[1,0] == 12
-        z = x + 10j * x
-        assert eq(z.real, x)
-        assert eq(z.imag, 10*x)
-        assert eq((z*conjugate(z)).real, 101*x*x)
-        z.imag[...] = 0.0
-
-        x = arange(10)
-        x[3] = masked
-        assert str(x[3]) == str(masked)
-        c = x >= 8
-        assert count(where(c,masked,masked)) == 0
-        assert shape(where(c,masked,masked)) == c.shape
-        z = where(c , x, masked)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is masked
-        assert z[7] is masked
-        assert z[8] is not masked
-        assert z[9] is not masked
-        assert eq(x,z)
-        z = where(c , masked, x)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is not masked
-        assert z[7] is not masked
-        assert z[8] is masked
-        assert z[9] is masked
-        z = masked_where(c, x)
-        assert z.dtype is x.dtype
-        assert z[3] is masked
-        assert z[4] is not masked
-        assert z[7] is not masked
-        assert z[8] is masked
-        assert z[9] is masked
-        assert eq(x,z)
-        x = array([1.,2.,3.,4.,5.])
-        c = array([1,1,1,0,0])
-        x[2] = masked
-        z = where(c, x, -x)
-        assert eq(z, [1.,2.,0., -4., -5])
-        c[0] = masked
-        z = where(c, x, -x)
-        assert eq(z, [1.,2.,0., -4., -5])
-        assert z[0] is masked
-        assert z[1] is not masked
-        assert z[2] is masked
-        assert eq(masked_where(greater(x, 2), x), masked_greater(x,2))
-        assert eq(masked_where(greater_equal(x, 2), x), masked_greater_equal(x,2))
-        assert eq(masked_where(less(x, 2), x), masked_less(x,2))
-        assert eq(masked_where(less_equal(x, 2), x), masked_less_equal(x,2))
-        assert eq(masked_where(not_equal(x, 2), x), masked_not_equal(x,2))
-        assert eq(masked_where(equal(x, 2), x), masked_equal(x,2))
-        assert eq(masked_where(not_equal(x,2), x), masked_not_equal(x,2))
-        assert eq(masked_inside(range(5), 1, 3), [0, 199, 199, 199, 4])
-        assert eq(masked_outside(range(5), 1, 3),[199,1,2,3,199])
-        assert eq(masked_inside(array(range(5), mask=[1,0,0,0,0]), 1, 3).mask, [1,1,1,1,0])
-        assert eq(masked_outside(array(range(5), mask=[0,1,0,0,0]), 1, 3).mask, [1,1,0,0,1])
-        assert eq(masked_equal(array(range(5), mask=[1,0,0,0,0]), 2).mask, [1,0,1,0,0])
-        assert eq(masked_not_equal(array([2,2,1,2,1], mask=[1,0,0,0,0]), 2).mask, [1,0,1,0,1])
-        assert eq(masked_where([1,1,0,0,0], [1,2,3,4,5]), [99,99,3,4,5])
-        atest = ones((10,10,10), dtype=float32)
-        btest = zeros(atest.shape, MaskType)
-        ctest = masked_where(btest,atest)
-        assert eq(atest,ctest)
-        z = choose(c, (-x, x))
-        assert eq(z, [1.,2.,0., -4., -5])
-        assert z[0] is masked
-        assert z[1] is not masked
-        assert z[2] is masked
-        x = arange(6)
-        x[5] = masked
-        y = arange(6)*10
-        y[2]= masked
-        c = array([1,1,1,0,0,0], mask=[1,0,0,0,0,0])
-        cm = c.filled(1)
-        z = where(c,x,y)
-        zm = where(cm,x,y)
-        assert eq(z, zm)
-        assert getmask(zm) is nomask
-        assert eq(zm, [0,1,2,30,40,50])
-        z = where(c, masked, 1)
-        assert eq(z, [99,99,99,1,1,1])
-        z = where(c, 1, masked)
-        assert eq(z, [99, 1, 1, 99, 99, 99])
-
-    def check_testMinMax(self):
-        "Test of minumum, maximum."
-        assert eq(minimum([1,2,3],[4,0,9]), [1,0,3])
-        assert eq(maximum([1,2,3],[4,0,9]), [4,2,9])
-        x = arange(5)
-        y = arange(5) - 2
-        x[3] = masked
-        y[0] = masked
-        assert eq(minimum(x,y), where(less(x,y), x, y))
-        assert eq(maximum(x,y), where(greater(x,y), x, y))
-        assert minimum(x) == 0
-        assert maximum(x) == 4
-
-    def check_testTakeTransposeInnerOuter(self):
-        "Test of take, transpose, inner, outer products"
-        x = arange(24)
-        y = numpy.arange(24)
-        x[5:6] = masked
-        x=x.reshape(2,3,4)
-        y=y.reshape(2,3,4)
-        assert eq(numpy.transpose(y,(2,0,1)), transpose(x,(2,0,1)))
-        assert eq(numpy.take(y, (2,0,1), 1), take(x, (2,0,1), 1))
-        assert eq(numpy.inner(filled(x,0),filled(y,0)),
-                                inner(x, y))
-        assert eq(numpy.outer(filled(x,0),filled(y,0)),
-                                outer(x, y))
-        y = array(['abc', 1, 'def', 2, 3], object)
-        y[2] = masked
-        t = take(y,[0,3,4])
-        assert t[0] == 'abc'
-        assert t[1] == 2
-        assert t[2] == 3
-
-    def check_testInplace(self):
-        """Test of inplace operations and rich comparisons"""
-        y = arange(10)
-
-        x = arange(10)
-        xm = arange(10)
-        xm[2] = masked
-        x += 1
-        assert eq(x, y+1)
-        xm += 1
-        assert eq(x, y+1)
-
-        x = arange(10)
-        xm = arange(10)
-        xm[2] = masked
-        x -= 1
-        assert eq(x, y-1)
-        xm -= 1
-        assert eq(xm, y-1)
-
-        x = arange(10)*1.0
-        xm = arange(10)*1.0
-        xm[2] = masked
-        x *= 2.0
-        assert eq(x, y*2)
-        xm *= 2.0
-        assert eq(xm, y*2)
-
-        x = arange(10)*2
-        xm = arange(10)
-        xm[2] = masked
-        x /= 2
-        assert eq(x, y)
-        xm /= 2
-        assert eq(x, y)
-
-        x = arange(10)*1.0
-        xm = arange(10)*1.0
-        xm[2] = masked
-        x /= 2.0
-        assert eq(x, y/2.0)
-        xm /= arange(10)
-        assert eq(xm, ones((10,)))
-
-        x = arange(10).astype(float32)
-        xm = arange(10)
-        xm[2] = masked
-        id1 = id(x.data)
-        x += 1.
-        assert id1 == id(x.data)
-        assert eq(x, y+1.)
-
-    def check_testPickle(self):
-        "Test of pickling"
-        import pickle
-        x = arange(12)
-        x[4:10:2] = masked
-        x = x.reshape(4,3)
-        s = pickle.dumps(x)
-        y = pickle.loads(s)
-        assert eq(x,y)
-
-    def check_testMasked(self):
-        "Test of masked element"
-        xx=arange(6)
-        xx[1] = masked
-        self.failUnless(str(masked) ==  '--')
-        self.failUnless(xx[1] is masked)
-        self.failUnlessEqual(filled(xx[1], 0), 0)
-        # don't know why these should raise an exception...
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, masked)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, 2)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, xx)
-        #self.failUnlessRaises(Exception, lambda x,y: x+y, xx, masked)
-
-    def check_testAverage1(self):
-        "Test of average."
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        self.failUnless(eq(2.0, average(ott,axis=0)))
-        self.failUnless(eq(2.0, average(ott, weights=[1., 1., 2., 1.])))
-        result, wts = average(ott, weights=[1.,1.,2.,1.], returned=1)
-        self.failUnless(eq(2.0, result))
-        self.failUnless(wts == 4.0)
-        ott[:] = masked
-        self.failUnless(average(ott,axis=0) is masked)
-        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
-        ott=ott.reshape(2,2)
-        ott[:,1] = masked
-        self.failUnless(eq(average(ott,axis=0), [2.0, 0.0]))
-        self.failUnless(average(ott,axis=1)[0] is masked)
-        self.failUnless(eq([2.,0.], average(ott, axis=0)))
-        result, wts = average(ott, axis=0, returned=1)
-        self.failUnless(eq(wts, [1., 0.]))
-
-    def check_testAverage2(self):
-        "More tests of average."
-        w1 = [0,1,1,1,1,0]
-        w2 = [[0,1,1,1,1,0],[1,0,0,0,0,1]]
-        x=arange(6)
-        self.failUnless(allclose(average(x, axis=0), 2.5))
-        self.failUnless(allclose(average(x, axis=0, weights=w1), 2.5))
-        y=array([arange(6), 2.0*arange(6)])
-        self.failUnless(allclose(average(y, None), numpy.add.reduce(numpy.arange(6))*3./12.))
-        self.failUnless(allclose(average(y, axis=0), numpy.arange(6) * 3./2.))
-        self.failUnless(allclose(average(y, axis=1), [average(x,axis=0), average(x,axis=0) * 2.0]))
-        self.failUnless(allclose(average(y, None, weights=w2), 20./6.))
-        self.failUnless(allclose(average(y, axis=0, weights=w2), [0.,1.,2.,3.,4.,10.]))
-        self.failUnless(allclose(average(y, axis=1), [average(x,axis=0), average(x,axis=0) * 2.0]))
-        m1 = zeros(6)
-        m2 = [0,0,1,1,0,0]
-        m3 = [[0,0,1,1,0,0],[0,1,1,1,1,0]]
-        m4 = ones(6)
-        m5 = [0, 1, 1, 1, 1, 1]
-        self.failUnless(allclose(average(masked_array(x, m1),axis=0), 2.5))
-        self.failUnless(allclose(average(masked_array(x, m2),axis=0), 2.5))
-        self.failUnless(average(masked_array(x, m4),axis=0) is masked)
-        self.assertEqual(average(masked_array(x, m5),axis=0), 0.0)
-        self.assertEqual(count(average(masked_array(x, m4),axis=0)), 0)
-        z = masked_array(y, m3)
-        self.failUnless(allclose(average(z, None), 20./6.))
-        self.failUnless(allclose(average(z, axis=0), [0.,1.,99.,99.,4.0, 7.5]))
-        self.failUnless(allclose(average(z, axis=1), [2.5, 5.0]))
-        self.failUnless(allclose( average(z,axis=0, weights=w2), [0.,1., 99., 99., 4.0, 10.0]))
-
-        a = arange(6)
-        b = arange(6) * 3
-        r1, w1 = average([[a,b],[b,a]], axis=1, returned=1)
-        self.assertEqual(shape(r1) , shape(w1))
-        self.assertEqual(r1.shape , w1.shape)
-        r2, w2 = average(ones((2,2,3)), axis=0, weights=[3,1], returned=1)
-        self.assertEqual(shape(w2) , shape(r2))
-        r2, w2 = average(ones((2,2,3)), returned=1)
-        self.assertEqual(shape(w2) , shape(r2))
-        r2, w2 = average(ones((2,2,3)), weights=ones((2,2,3)), returned=1)
-        self.failUnless(shape(w2) == shape(r2))
-        a2d = array([[1,2],[0,4]], float)
-        a2dm = masked_array(a2d, [[0,0],[1,0]])
-        a2da = average(a2d, axis=0)
-        self.failUnless(eq (a2da, [0.5, 3.0]))
-        a2dma = average(a2dm, axis=0)
-        self.failUnless(eq( a2dma, [1.0, 3.0]))
-        a2dma = average(a2dm, axis=None)
-        self.failUnless(eq(a2dma, 7./3.))
-        a2dma = average(a2dm, axis=1)
-        self.failUnless(eq(a2dma, [1.5, 4.0]))
-
-    def check_testToPython(self):
-        self.assertEqual(1, int(array(1)))
-        self.assertEqual(1.0, float(array(1)))
-        self.assertEqual(1, int(array([[[1]]])))
-        self.assertEqual(1.0, float(array([[1]])))
-        self.failUnlessRaises(ValueError, float, array([1,1]))
-        self.failUnlessRaises(ValueError, bool, array([0,1]))
-        self.failUnlessRaises(ValueError, bool, array([0,0],mask=[0,1]))
-
-    def check_testScalarArithmetic(self):
-        xm = array(0, mask=1)
-        self.failUnless((1/array(0)).mask)
-        self.failUnless((1 + xm).mask)
-        self.failUnless((-xm).mask)
-        self.failUnless((-xm).mask)
-        self.failUnless(maximum(xm, xm).mask)
-        self.failUnless(minimum(xm, xm).mask)
-        self.failUnless(xm.filled().dtype is xm.data.dtype)
-        x = array(0, mask=0)
-        self.failUnless(x.filled() == x.data)
-        self.failUnlessEqual(str(xm), str(masked_print_option))
-
-    def check_testArrayMethods(self):
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        self.failUnless(eq(a.any(), a.data.any()))
-        self.failUnless(eq(a.all(), a.data.all()))
-        self.failUnless(eq(a.argmax(), a.data.argmax()))
-        self.failUnless(eq(a.argmin(), a.data.argmin()))
-        self.failUnless(eq(a.choose(0,1,2,3,4), a.data.choose(0,1,2,3,4)))
-        self.failUnless(eq(a.compress([1,0,1]), a.data.compress([1,0,1])))
-        self.failUnless(eq(a.conj(), a.data.conj()))
-        self.failUnless(eq(a.conjugate(), a.data.conjugate()))
-        m = array([[1,2],[3,4]])
-        self.failUnless(eq(m.diagonal(), m.data.diagonal()))
-        self.failUnless(eq(a.sum(), a.data.sum()))
-        self.failUnless(eq(a.take([1,2]), a.data.take([1,2])))
-        self.failUnless(eq(m.transpose(), m.data.transpose()))
-
-    def check_testArrayAttributes(self):
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        self.failUnlessEqual(a.ndim, 1)
-
-    def check_testAPI(self):
-        self.failIf([m for m in dir(numpy.ndarray)
-                     if m not in dir(MaskedArray) and not m.startswith('_')])
-
-    def check_testSingleElementSubscript(self):
-        a = array([1,3,2])
-        b = array([1,3,2], mask=[1,0,1])
-        self.failUnlessEqual(a[0].shape, ())
-        self.failUnlessEqual(b[0].shape, ())
-        self.failUnlessEqual(b[1].shape, ())
-
-class TestUfuncs(NumpyTestCase):
-    def setUp(self):
-        self.d = (array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
-                  array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
-
-
-    def check_testUfuncRegression(self):
-        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
-                  'sin', 'cos', 'tan',
-                  'arcsin', 'arccos', 'arctan',
-                  'sinh', 'cosh', 'tanh',
-                  'arcsinh',
-                  'arccosh',
-                  'arctanh',
-                  'absolute', 'fabs', 'negative',
-                  # 'nonzero', 'around',
-                  'floor', 'ceil',
-                  # 'sometrue', 'alltrue',
-                  'logical_not',
-                  'add', 'subtract', 'multiply',
-                  'divide', 'true_divide', 'floor_divide',
-                  'remainder', 'fmod', 'hypot', 'arctan2',
-                  'equal', 'not_equal', 'less_equal', 'greater_equal',
-                  'less', 'greater',
-                  'logical_and', 'logical_or', 'logical_xor',
-                  ]:
-            try:
-                uf = getattr(umath, f)
-            except AttributeError:
-                uf = getattr(fromnumeric, f)
-            mf = getattr(numpy.ma, f)
-            args = self.d[:uf.nin]
-            olderr = numpy.geterr()
-            if f in ['sqrt', 'arctanh', 'arcsin', 'arccos', 'arccosh', 'arctanh', 'log',
-                     'log10','divide','true_divide', 'floor_divide', 'remainder', 'fmod']:
-                numpy.seterr(invalid='ignore')
-            if f in ['arctanh', 'log', 'log10']:
-                numpy.seterr(divide='ignore')
-            ur = uf(*args)
-            mr = mf(*args)
-            numpy.seterr(**olderr)
-            self.failUnless(eq(ur.filled(0), mr.filled(0), f))
-            self.failUnless(eqmask(ur.mask, mr.mask))
-
-    def test_reduce(self):
-        a = self.d[0]
-        self.failIf(alltrue(a,axis=0))
-        self.failUnless(sometrue(a,axis=0))
-        self.failUnlessEqual(sum(a[:3],axis=0), 0)
-        self.failUnlessEqual(product(a,axis=0), 0)
-
-    def test_minmax(self):
-        a = arange(1,13).reshape(3,4)
-        amask = masked_where(a < 5,a)
-        self.failUnlessEqual(amask.max(), a.max())
-        self.failUnlessEqual(amask.min(), 5)
-        self.failUnless((amask.max(0) == a.max(0)).all())
-        self.failUnless((amask.min(0) == [5,6,7,8]).all())
-        self.failUnless(amask.max(1)[0].mask)
-        self.failUnless(amask.min(1)[0].mask)
-
-    def test_nonzero(self):
-        for t in "?bhilqpBHILQPfdgFDGO":
-            x = array([1,0,2,0], mask=[0,0,1,1])
-            self.failUnless(eq(nonzero(x), [0]))
-
-
-class TestArrayMethods(NumpyTestCase):
-
-    def setUp(self):
-        x = numpy.array([ 8.375,  7.545,  8.828,  8.5  ,  1.757,  5.928,
-                          8.43 ,  7.78 ,  9.865,  5.878,  8.979,  4.732,
-                          3.012,  6.022,  5.095,  3.116,  5.238,  3.957,
-                          6.04 ,  9.63 ,  7.712,  3.382,  4.489,  6.479,
-                          7.189,  9.645,  5.395,  4.961,  9.894,  2.893,
-                          7.357,  9.828,  6.272,  3.758,  6.693,  0.993])
-        X = x.reshape(6,6)
-        XX = x.reshape(3,2,2,3)
-
-        m = numpy.array([0, 1, 0, 1, 0, 0,
-                         1, 0, 1, 1, 0, 1,
-                         0, 0, 0, 1, 0, 1,
-                         0, 0, 0, 1, 1, 1,
-                         1, 0, 0, 1, 0, 0,
-                         0, 0, 1, 0, 1, 0])
-        mx = array(data=x,mask=m)
-        mX = array(data=X,mask=m.reshape(X.shape))
-        mXX = array(data=XX,mask=m.reshape(XX.shape))
-
-        m2 = numpy.array([1, 1, 0, 1, 0, 0,
-                          1, 1, 1, 1, 0, 1,
-                          0, 0, 1, 1, 0, 1,
-                          0, 0, 0, 1, 1, 1,
-                          1, 0, 0, 1, 1, 0,
-                          0, 0, 1, 0, 1, 1])
-        m2x = array(data=x,mask=m2)
-        m2X = array(data=X,mask=m2.reshape(X.shape))
-        m2XX = array(data=XX,mask=m2.reshape(XX.shape))
-        self.d =  (x,X,XX,m,mx,mX,mXX)
-
-    #------------------------------------------------------
-    def test_trace(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        mXdiag = mX.diagonal()
-        self.assertEqual(mX.trace(), mX.diagonal().compressed().sum())
-        self.failUnless(eq(mX.trace(),
-                           X.trace() - sum(mXdiag.mask*X.diagonal(),axis=0)))
-
-    def test_clip(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        clipped = mx.clip(2,8)
-        self.failUnless(eq(clipped.mask,mx.mask))
-        self.failUnless(eq(clipped.data,x.clip(2,8)))
-        self.failUnless(eq(clipped.data,mx.data.clip(2,8)))
-
-    def test_ptp(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        (n,m) = X.shape
-        self.assertEqual(mx.ptp(),mx.compressed().ptp())
-        rows = numpy.zeros(n,numpy.float_)
-        cols = numpy.zeros(m,numpy.float_)
-        for k in range(m):
-            cols[k] = mX[:,k].compressed().ptp()
-        for k in range(n):
-            rows[k] = mX[k].compressed().ptp()
-        self.failUnless(eq(mX.ptp(0),cols))
-        self.failUnless(eq(mX.ptp(1),rows))
-
-    def test_swapaxes(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        mXswapped = mX.swapaxes(0,1)
-        self.failUnless(eq(mXswapped[-1],mX[:,-1]))
-        mXXswapped = mXX.swapaxes(0,2)
-        self.assertEqual(mXXswapped.shape,(2,2,3,3))
-
-
-    def test_cumprod(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        mXcp = mX.cumprod(0)
-        self.failUnless(eq(mXcp.data,mX.filled(1).cumprod(0)))
-        mXcp = mX.cumprod(1)
-        self.failUnless(eq(mXcp.data,mX.filled(1).cumprod(1)))
-
-    def test_cumsum(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        mXcp = mX.cumsum(0)
-        self.failUnless(eq(mXcp.data,mX.filled(0).cumsum(0)))
-        mXcp = mX.cumsum(1)
-        self.failUnless(eq(mXcp.data,mX.filled(0).cumsum(1)))
-
-    def test_varstd(self):
-        (x,X,XX,m,mx,mX,mXX,) = self.d
-        self.failUnless(eq(mX.var(axis=None),mX.compressed().var()))
-        self.failUnless(eq(mX.std(axis=None),mX.compressed().std()))
-        self.failUnless(eq(mXX.var(axis=3).shape,XX.var(axis=3).shape))
-        self.failUnless(eq(mX.var().shape,X.var().shape))
-        (mXvar0,mXvar1) = (mX.var(axis=0), mX.var(axis=1))
-        for k in range(6):
-            self.failUnless(eq(mXvar1[k],mX[k].compressed().var()))
-            self.failUnless(eq(mXvar0[k],mX[:,k].compressed().var()))
-            self.failUnless(eq(numpy.sqrt(mXvar0[k]),
-                               mX[:,k].compressed().std()))
-
-
-def eqmask(m1, m2):
-    if m1 is nomask:
-        return m2 is nomask
-    if m2 is nomask:
-        return m1 is nomask
-    return (m1 == m2).all()
-
-def timingTest():
-    for f in [testf, testinplace]:
-        for n in [1000,10000,50000]:
-            t = testta(n, f)
-            t1 = testtb(n, f)
-            t2 = testtc(n, f)
-            print f.test_name
-            print """\
-n = %7d
-numpy time (ms) %6.1f
-MA maskless ratio %6.1f
-MA masked ratio %6.1f
-""" % (n, t*1000.0, t1/t, t2/t)
-
-def testta(n, f):
-    x=numpy.arange(n) + 1.0
-    tn0 = time.time()
-    z = f(x)
-    return time.time() - tn0
-
-def testtb(n, f):
-    x=arange(n) + 1.0
-    tn0 = time.time()
-    z = f(x)
-    return time.time() - tn0
-
-def testtc(n, f):
-    x=arange(n) + 1.0
-    x[0] = masked
-    tn0 = time.time()
-    z = f(x)
-    return time.time() - tn0
-
-def testf(x):
-    for i in range(25):
-        y = x **2 +  2.0 * x - 1.0
-        w = x **2 +  1.0
-        z = (y / w) ** 2
-    return z
-testf.test_name = 'Simple arithmetic'
-
-def testinplace(x):
-    for i in range(25):
-        y = x**2
-        y += 2.0*x
-        y -= 1.0
-        y /= x
-    return y
-testinplace.test_name = 'Inplace operations'
-
-if __name__ == "__main__":
-    NumpyTest('numpy.ma').run()
-    #timingTest()

Copied: trunk/numpy/ma/tests/test_old_ma.py (from rev 4777, branches/maskedarray/numpy/ma/tests/test_old_ma.py)

Deleted: trunk/numpy/ma/tests/test_subclassing.py
===================================================================
--- branches/maskedarray/numpy/ma/tests/test_subclassing.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/tests/test_subclassing.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,183 +0,0 @@
-# pylint: disable-msg=W0611, W0612, W0511,R0201
-"""Tests suite for MaskedArray & subclassing.
-
-:author: Pierre Gerard-Marchant
-:contact: pierregm_at_uga_dot_edu
-:version: $Id: test_subclassing.py 3473 2007-10-29 15:18:13Z jarrod.millman $
-"""
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
-import numpy as N
-import numpy.core.numeric as numeric
-
-from numpy.testing import NumpyTest, NumpyTestCase
-
-import numpy.ma.testutils
-from numpy.ma.testutils import *
-
-import numpy.ma.core as coremodule
-from numpy.ma.core import *
-
-
-class SubArray(N.ndarray):
-    """Defines a generic N.ndarray subclass, that stores some metadata
-    in the  dictionary `info`."""
-    def __new__(cls,arr,info={}):
-        x = N.asanyarray(arr).view(cls)
-        x.info = info
-        return x
-    def __array_finalize__(self, obj):
-        self.info = getattr(obj,'info',{})
-        return
-    def __add__(self, other):
-        result = N.ndarray.__add__(self, other)
-        result.info.update({'added':result.info.pop('added',0)+1})
-        return result
-subarray = SubArray
-
-class MSubArray(SubArray,MaskedArray):
-    def __new__(cls, data, info=None, mask=nomask):
-        subarr = SubArray(data, info)
-        _data = MaskedArray.__new__(cls, data=subarr, mask=mask)
-        _data.info = subarr.info
-        return _data
-    def __array_finalize__(self,obj):
-        MaskedArray.__array_finalize__(self,obj)
-        SubArray.__array_finalize__(self, obj)
-        return
-    def _get_series(self):
-        _view = self.view(MaskedArray)
-        _view._sharedmask = False
-        return _view
-    _series = property(fget=_get_series)
-msubarray = MSubArray
-
-class MMatrix(MaskedArray, N.matrix,):
-    def __new__(cls, data, mask=nomask):
-        mat = N.matrix(data)
-        _data = MaskedArray.__new__(cls, data=mat, mask=mask)
-        return _data
-    def __array_finalize__(self,obj):
-        N.matrix.__array_finalize__(self, obj)
-        MaskedArray.__array_finalize__(self,obj)
-        return
-    def _get_series(self):
-        _view = self.view(MaskedArray)
-        _view._sharedmask = False
-        return _view
-    _series = property(fget=_get_series)
-mmatrix = MMatrix
-
-
-
-class TestSubclassing(NumpyTestCase):
-    """Test suite for masked subclasses of ndarray."""
-
-    def check_data_subclassing(self):
-        "Tests whether the subclass is kept."
-        x = N.arange(5)
-        m = [0,0,1,0,0]
-        xsub = SubArray(x)
-        xmsub = masked_array(xsub, mask=m)
-        assert isinstance(xmsub, MaskedArray)
-        assert_equal(xmsub._data, xsub)
-        assert isinstance(xmsub._data, SubArray)
-
-    def check_maskedarray_subclassing(self):
-        "Tests subclassing MaskedArray"
-        x = N.arange(5)
-        mx = mmatrix(x,mask=[0,1,0,0,0])
-        assert isinstance(mx._data, N.matrix)
-        "Tests masked_unary_operation"
-        assert isinstance(add(mx,mx), mmatrix)
-        assert isinstance(add(mx,x), mmatrix)
-        assert_equal(add(mx,x), mx+x)
-        assert isinstance(add(mx,mx)._data, N.matrix)
-        assert isinstance(add.outer(mx,mx), mmatrix)
-        "Tests masked_binary_operation"
-        assert isinstance(hypot(mx,mx), mmatrix)
-        assert isinstance(hypot(mx,x), mmatrix)
-
-    def check_attributepropagation(self):
-        x = array(arange(5), mask=[0]+[1]*4)
-        my = masked_array(subarray(x))
-        ym = msubarray(x)
-        #
-        z = (my+1)
-        assert isinstance(z,MaskedArray)
-        assert not isinstance(z, MSubArray)
-        assert isinstance(z._data, SubArray)
-        assert_equal(z._data.info, {})
-        #
-        z = (ym+1)
-        assert isinstance(z, MaskedArray)
-        assert isinstance(z, MSubArray)
-        assert isinstance(z._data, SubArray)
-        assert z._data.info['added'] > 0
-        #
-        ym._set_mask([1,0,0,0,1])
-        assert_equal(ym._mask, [1,0,0,0,1])
-        ym._series._set_mask([0,0,0,0,1])
-        assert_equal(ym._mask, [0,0,0,0,1])
-        #
-        xsub = subarray(x, info={'name':'x'})
-        mxsub = masked_array(xsub)
-        assert hasattr(mxsub, 'info')
-        assert_equal(mxsub.info, xsub.info)
-
-    def check_subclasspreservation(self):
-        "Checks that masked_array(...,subok=True) preserves the class."
-        x = N.arange(5)
-        m = [0,0,1,0,0]
-        xinfo = [(i,j) for (i,j) in zip(x,m)]
-        xsub = MSubArray(x, mask=m, info={'xsub':xinfo})
-        #
-        mxsub = masked_array(xsub, subok=False)
-        assert not isinstance(mxsub, MSubArray)
-        assert isinstance(mxsub, MaskedArray)
-        assert_equal(mxsub._mask, m)
-        #
-        mxsub = asarray(xsub)
-        assert not isinstance(mxsub, MSubArray)
-        assert isinstance(mxsub, MaskedArray)
-        assert_equal(mxsub._mask, m)
-        #
-        mxsub = masked_array(xsub, subok=True)
-        assert isinstance(mxsub, MSubArray)
-        assert_equal(mxsub.info, xsub.info)
-        assert_equal(mxsub._mask, xsub._mask)
-        #
-        mxsub = asanyarray(xsub)
-        assert isinstance(mxsub, MSubArray)
-        assert_equal(mxsub.info, xsub.info)
-        assert_equal(mxsub._mask, m)
-
-
-################################################################################
-if __name__ == '__main__':
-    NumpyTest().run()
-    #
-    if 0:
-        x = array(arange(5), mask=[0]+[1]*4)
-        my = masked_array(subarray(x))
-        ym = msubarray(x)
-        #
-        z = (my+1)
-        assert isinstance(z,MaskedArray)
-        assert not isinstance(z, MSubArray)
-        assert isinstance(z._data, SubArray)
-        assert_equal(z._data.info, {})
-        #
-        z = (ym+1)
-        assert isinstance(z, MaskedArray)
-        assert isinstance(z, MSubArray)
-        assert isinstance(z._data, SubArray)
-        assert z._data.info['added'] > 0
-        #
-        ym._set_mask([1,0,0,0,1])
-        assert_equal(ym._mask, [1,0,0,0,1])
-        ym._series._set_mask([0,0,0,0,1])
-        assert_equal(ym._mask, [0,0,0,0,1])

Copied: trunk/numpy/ma/tests/test_subclassing.py (from rev 4777, branches/maskedarray/numpy/ma/tests/test_subclassing.py)

Deleted: trunk/numpy/ma/testutils.py
===================================================================
--- branches/maskedarray/numpy/ma/testutils.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/ma/testutils.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -1,219 +0,0 @@
-"""Miscellaneous functions for testing masked arrays and subclasses
-
-:author: Pierre Gerard-Marchant
-:contact: pierregm_at_uga_dot_edu
-:version: $Id: testutils.py 3529 2007-11-13 08:01:14Z jarrod.millman $
-"""
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = "1.0"
-__revision__ = "$Revision: 3529 $"
-__date__ = "$Date: 2007-11-13 10:01:14 +0200 (Tue, 13 Nov 2007) $"
-
-
-import numpy as N
-from numpy.core import ndarray
-from numpy.core.numerictypes import float_
-import numpy.core.umath as umath
-from numpy.testing import NumpyTest, NumpyTestCase
-from numpy.testing.utils import build_err_msg, rand
-
-import core
-from core import mask_or, getmask, getmaskarray, masked_array, nomask, masked
-from core import filled, equal, less
-
-#------------------------------------------------------------------------------
-def approx (a, b, fill_value=True, rtol=1.e-5, atol=1.e-8):
-    """Returns true if all components of a and b are equal subject to given tolerances.
-
-If fill_value is True, masked values considered equal. Otherwise, masked values
-are considered unequal.
-The relative error rtol should be positive and << 1.0
-The absolute error atol comes into play for those elements of b that are very
-small or zero; it says how small a must be also.
-    """
-    m = mask_or(getmask(a), getmask(b))
-    d1 = filled(a)
-    d2 = filled(b)
-    if d1.dtype.char == "O" or d2.dtype.char == "O":
-        return N.equal(d1,d2).ravel()
-    x = filled(masked_array(d1, copy=False, mask=m), fill_value).astype(float_)
-    y = filled(masked_array(d2, copy=False, mask=m), 1).astype(float_)
-    d = N.less_equal(umath.absolute(x-y), atol + rtol * umath.absolute(y))
-    return d.ravel()
-#................................................
-def _assert_equal_on_sequences(actual, desired, err_msg=''):
-    "Asserts the equality of two non-array sequences."
-    assert_equal(len(actual),len(desired),err_msg)
-    for k in range(len(desired)):
-        assert_equal(actual[k], desired[k], 'item=%r\n%s' % (k,err_msg))
-    return
-
-def assert_equal_records(a,b):
-    """Asserts that two records are equal. Pretty crude for now."""
-    assert_equal(a.dtype, b.dtype)
-    for f in a.dtype.names:
-        (af, bf) = (getattr(a,f), getattr(b,f))
-        if not (af is masked) and not (bf is masked):
-            assert_equal(getattr(a,f), getattr(b,f))
-    return
-
-def assert_equal(actual,desired,err_msg=''):
-    """Asserts that two items are equal.
-    """
-    # Case #1: dictionary .....
-    if isinstance(desired, dict):
-        assert isinstance(actual, dict), repr(type(actual))
-        assert_equal(len(actual),len(desired),err_msg)
-        for k,i in desired.items():
-            assert k in actual, repr(k)
-            assert_equal(actual[k], desired[k], 'key=%r\n%s' % (k,err_msg))
-        return
-    # Case #2: lists .....
-    if isinstance(desired, (list,tuple)) and isinstance(actual, (list,tuple)):
-        return _assert_equal_on_sequences(actual, desired, err_msg='')
-    if not (isinstance(actual, ndarray) or isinstance(desired, ndarray)):
-        msg = build_err_msg([actual, desired], err_msg,)
-        assert desired == actual, msg
-        return
-    # Case #4. arrays or equivalent
-    if ((actual is masked) and not (desired is masked)) or \
-        ((desired is masked) and not (actual is masked)):
-        msg = build_err_msg([actual, desired], err_msg, header='', names=('x', 'y'))
-        raise ValueError(msg)
-    actual = N.array(actual, copy=False, subok=True)
-    desired = N.array(desired, copy=False, subok=True)
-    if actual.dtype.char in "OS" and desired.dtype.char in "OS":
-        return _assert_equal_on_sequences(actual.tolist(),
-                                          desired.tolist(),
-                                          err_msg='')
-    return assert_array_equal(actual, desired, err_msg)
-#.............................
-def fail_if_equal(actual,desired,err_msg='',):
-    """Raises an assertion error if two items are equal.
-    """
-    if isinstance(desired, dict):
-        assert isinstance(actual, dict), repr(type(actual))
-        fail_if_equal(len(actual),len(desired),err_msg)
-        for k,i in desired.items():
-            assert k in actual, repr(k)
-            fail_if_equal(actual[k], desired[k], 'key=%r\n%s' % (k,err_msg))
-        return
-    if isinstance(desired, (list,tuple)) and isinstance(actual, (list,tuple)):
-        fail_if_equal(len(actual),len(desired),err_msg)
-        for k in range(len(desired)):
-            fail_if_equal(actual[k], desired[k], 'item=%r\n%s' % (k,err_msg))
-        return
-    if isinstance(actual, N.ndarray) or isinstance(desired, N.ndarray):
-        return fail_if_array_equal(actual, desired, err_msg)
-    msg = build_err_msg([actual, desired], err_msg)
-    assert desired != actual, msg
-assert_not_equal = fail_if_equal
-#............................
-def assert_almost_equal(actual,desired,decimal=7,err_msg=''):
-    """Asserts that two items are almost equal.
-    The test is equivalent to abs(desired-actual) < 0.5 * 10**(-decimal)
-    """
-    if isinstance(actual, N.ndarray) or isinstance(desired, N.ndarray):
-        return assert_array_almost_equal(actual, desired, decimal, err_msg)
-    msg = build_err_msg([actual, desired], err_msg)
-    assert round(abs(desired - actual),decimal) == 0, msg
-#............................
-def assert_array_compare(comparison, x, y, err_msg='', header='',
-                         fill_value=True):
-    """Asserts that a comparison relation between two masked arrays is satisfied
-    elementwise."""
-    xf = filled(x)
-    yf = filled(y)
-    m = mask_or(getmask(x), getmask(y))
-
-    x = masked_array(xf, copy=False, subok=False, mask=m).filled(fill_value)
-    y = masked_array(yf, copy=False, subok=False, mask=m).filled(fill_value)
-
-    if ((x is masked) and not (y is masked)) or \
-        ((y is masked) and not (x is masked)):
-        msg = build_err_msg([x, y], err_msg, header=header, names=('x', 'y'))
-        raise ValueError(msg)
-
-    if (x.dtype.char != "O") and (x.dtype.char != "S"):
-        x = x.astype(float_)
-        if isinstance(x, N.ndarray) and x.size > 1:
-            x[N.isnan(x)] = 0
-        elif N.isnan(x):
-            x = 0
-    if (y.dtype.char != "O") and (y.dtype.char != "S"):
-        y = y.astype(float_)
-        if isinstance(y, N.ndarray) and y.size > 1:
-            y[N.isnan(y)] = 0
-        elif N.isnan(y):
-            y = 0
-    try:
-        cond = (x.shape==() or y.shape==()) or x.shape == y.shape
-        if not cond:
-            msg = build_err_msg([x, y],
-                                err_msg
-                                + '\n(shapes %s, %s mismatch)' % (x.shape,
-                                                                  y.shape),
-                                header=header,
-                                names=('x', 'y'))
-            assert cond, msg
-        val = comparison(x,y)
-        if m is not nomask and fill_value:
-            val = masked_array(val, mask=m, copy=False)
-        if isinstance(val, bool):
-            cond = val
-            reduced = [0]
-        else:
-            reduced = val.ravel()
-            cond = reduced.all()
-            reduced = reduced.tolist()
-        if not cond:
-            match = 100-100.0*reduced.count(1)/len(reduced)
-            msg = build_err_msg([x, y],
-                                err_msg
-                                + '\n(mismatch %s%%)' % (match,),
-                                header=header,
-                                names=('x', 'y'))
-            assert cond, msg
-    except ValueError:
-        msg = build_err_msg([x, y], err_msg, header=header, names=('x', 'y'))
-        raise ValueError(msg)
-#............................
-def assert_array_equal(x, y, err_msg=''):
-    """Checks the elementwise equality of two masked arrays."""
-    assert_array_compare(equal, x, y, err_msg=err_msg,
-                         header='Arrays are not equal')
-##............................
-def fail_if_array_equal(x, y, err_msg=''):
-    "Raises an assertion error if two masked arrays are not equal (elementwise)."
-    def compare(x,y):
-
-        return (not N.alltrue(approx(x, y)))
-    assert_array_compare(compare, x, y, err_msg=err_msg,
-                         header='Arrays are not equal')
-#............................
-def assert_array_almost_equal(x, y, decimal=6, err_msg=''):
-    """Checks the elementwise equality of two masked arrays, up to a given
-    number of decimals."""
-    def compare(x, y):
-        "Returns the result of the loose comparison between x and y)."
-        return approx(x,y, rtol=10.**-decimal)
-    assert_array_compare(compare, x, y, err_msg=err_msg,
-                         header='Arrays are not almost equal')
-#............................
-def assert_array_less(x, y, err_msg=''):
-    "Checks that x is smaller than y elementwise."
-    assert_array_compare(less, x, y, err_msg=err_msg,
-                         header='Arrays are not less-ordered')
-#............................
-assert_close = assert_almost_equal
-#............................
-def assert_mask_equal(m1, m2):
-    """Asserts the equality of two masks."""
-    if m1 is nomask:
-        assert(m2 is nomask)
-    if m2 is nomask:
-        assert(m1 is nomask)
-    assert_array_equal(m1, m2)
-
-if __name__ == '__main__':
-    pass
\ No newline at end of file

Copied: trunk/numpy/ma/testutils.py (from rev 4777, branches/maskedarray/numpy/ma/testutils.py)

Modified: trunk/numpy/setup.py
===================================================================
--- trunk/numpy/setup.py	2008-02-09 00:45:11 UTC (rev 4777)
+++ trunk/numpy/setup.py	2008-02-09 01:35:25 UTC (rev 4778)
@@ -13,6 +13,7 @@
     config.add_subpackage('fft')
     config.add_subpackage('linalg')
     config.add_subpackage('random')
+    config.add_subpackage('ma')
     config.add_data_dir('doc')
     config.add_data_dir('tests')
     config.make_config_py() # installs __config__.py



From numpy-svn at scipy.org  Sat Feb  9 08:01:50 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat,  9 Feb 2008 07:01:50 -0600 (CST)
Subject: [Numpy-svn] r4779 - trunk/numpy/core
Message-ID: <20080209130150.181F439C0CE@new.scipy.org>

Author: cdavid
Date: 2008-02-09 07:01:45 -0600 (Sat, 09 Feb 2008)
New Revision: 4779

Modified:
   trunk/numpy/core/setup.py
Log:
Do not install config.h, since it not needed anymore for numpy API

Modified: trunk/numpy/core/setup.py
===================================================================
--- trunk/numpy/core/setup.py	2008-02-09 01:35:25 UTC (rev 4778)
+++ trunk/numpy/core/setup.py	2008-02-09 13:01:45 UTC (rev 4779)
@@ -155,7 +155,6 @@
         if incl_dir not in config.numpy_include_dirs:
             config.numpy_include_dirs.append(incl_dir)
 
-        config.add_data_files((header_dir,target))
         return target
 
     def generate_numpyconfig_h(ext, build_dir):



From numpy-svn at scipy.org  Sat Feb  9 13:08:46 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat,  9 Feb 2008 12:08:46 -0600 (CST)
Subject: [Numpy-svn] r4780 - in trunk/numpy: . ma
Message-ID: <20080209180846.B090A39C21C@new.scipy.org>

Author: cdavid
Date: 2008-02-09 12:08:40 -0600 (Sat, 09 Feb 2008)
New Revision: 4780

Added:
   trunk/numpy/ma/setupscons.py
Modified:
   trunk/numpy/setupscons.py
Log:
Add ma for scons build

Copied: trunk/numpy/ma/setupscons.py (from rev 4779, trunk/numpy/ma/setup.py)

Modified: trunk/numpy/setupscons.py
===================================================================
--- trunk/numpy/setupscons.py	2008-02-09 13:01:45 UTC (rev 4779)
+++ trunk/numpy/setupscons.py	2008-02-09 18:08:40 UTC (rev 4780)
@@ -13,6 +13,7 @@
     config.add_subpackage('fft')
     config.add_subpackage('linalg')
     config.add_subpackage('random')
+    config.add_subpackage('ma')
     config.add_data_dir('doc')
     config.add_data_dir('tests')
     config.scons_make_config_py() # installs __config__.py



From numpy-svn at scipy.org  Sat Feb  9 23:54:00 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat,  9 Feb 2008 22:54:00 -0600 (CST)
Subject: [Numpy-svn] r4781 - trunk/numpy/core/src
Message-ID: <20080210045400.0883939C0DF@new.scipy.org>

Author: charris
Date: 2008-02-09 22:53:58 -0600 (Sat, 09 Feb 2008)
New Revision: 4781

Modified:
   trunk/numpy/core/src/arrayobject.c
Log:
Add PyArray_CompareString function, but don't add it to the OBJECT_API yet. A
function not used warning will be issued during compile, but it is harmless.


Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2008-02-09 18:08:40 UTC (rev 4780)
+++ trunk/numpy/core/src/arrayobject.c	2008-02-10 04:53:58 UTC (rev 4781)
@@ -4280,6 +4280,24 @@
     return 0;
 }
 
+/*
+ */
+static int
+PyArray_CompareString(char *s1, char *s2, size_t len)
+{
+    const unsigned char *c1 = (unsigned char *)s1;
+    const unsigned char *c2 = (unsigned char *)s2;
+    size_t i;
+
+    for(i = 0; i < len; ++i) {
+        if (c1[i] != c2[i]) {
+            return (c1[i] > c2[i]) ? 1 : -1;
+        }
+    }
+    return 0;
+}
+
+
 /* This also handles possibly mis-aligned data */
 /* Compare s1 and s2 which are not necessarily NULL-terminated.
    s1 is of length len1



From numpy-svn at scipy.org  Sat Feb  9 23:57:47 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat,  9 Feb 2008 22:57:47 -0600 (CST)
Subject: [Numpy-svn] r4782 - trunk/numpy/core/src
Message-ID: <20080210045747.279D339C0DF@new.scipy.org>

Author: charris
Date: 2008-02-09 22:57:45 -0600 (Sat, 09 Feb 2008)
New Revision: 4782

Modified:
   trunk/numpy/core/src/_sortmodule.c.src
Log:
Add inline string compare functions for strings and UCS4. The indirect merge
sort now works correctly for strings. The new functions use the const keyword,
which may be a problem with very old C compilers.


Modified: trunk/numpy/core/src/_sortmodule.c.src
===================================================================
--- trunk/numpy/core/src/_sortmodule.c.src	2008-02-10 04:53:58 UTC (rev 4781)
+++ trunk/numpy/core/src/_sortmodule.c.src	2008-02-10 04:57:45 UTC (rev 4782)
@@ -38,14 +38,46 @@
 #define NUMC_LT(p,q) ((((p).real==(q).real) ? ((p).imag < (q).imag): ((p).real < (q).real)))
 #define NUMC_LE(p,q) ((((p).real==(q).real) ? ((p).imag <= (q).imag): ((p).real <= (q).real)))
 #define NUMC_EQ(p,q) (((p).real==(q).real) && ((p).imag == (q).imag))
-#define STRING_LT(pa, pb, len) (strncmp(pa, pb, len) < 0)
-#define STRING_LE(pa, pb, len) (strncmp(pa, pb, len) <= 0)
-#define STRING_EQ(pa, pb, len) (strncmp(pa, pb, len) == 0)
-#define UNICODE_LT(pa, pb, len) (PyArray_CompareUCS4(pa, pb, len) < 0)
-#define UNICODE_LE(pa, pb, len) (PyArray_CompareUCS4(pa, pb, len) <= 0)
-#define UNICODE_EQ(pa, pb, len) (PyArray_CompareUCS4(pa, pb, len) == 0)
+#define STRING_LT(pa, pb, len) (compare_string(pa, pb, len) < 0)
+#define STRING_LE(pa, pb, len) (compare_string(pa, pb, len) <= 0)
+#define STRING_EQ(pa, pb, len) (compare_string(pa, pb, len) == 0)
+#define STRING_SWAP(pa, pb, n) {int i; for(i = 0; i < n; ++i) SWAP(pa[i], pb[i]);}
+#define STRING_COPY(pa, pb, n) {int i; for(i = 0; i < n; ++i) pa[i] = pb[i];}
+#define UNICODE_LT(pa, pb, len) (compare_ucs4(pa, pb, len) < 0)
+#define UNICODE_LE(pa, pb, len) (compare_ucs4(pa, pb, len) <= 0)
+#define UNICODE_EQ(pa, pb, len) (compare_ucs4(pa, pb, len) == 0)
 
+#include <stdio.h>
 
+static int inline
+compare_string(char *s1, char *s2, size_t len)
+{
+    const unsigned char *c1 = (unsigned char *)s1;
+    const unsigned char *c2 = (unsigned char *)s2;
+    size_t i;
+
+    for(i = 0; i < len; ++i) {
+        if (c1[i] != c2[i]) {
+            return (c1[i] > c2[i]) ? 1 : -1;
+        }
+    }
+    return 0;
+}
+
+
+static int inline
+compare_ucs4(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)
+{
+    size_t i;
+
+    for(i = 0; i < len; ++i) {
+        if (s1[i] != s2[i]) {
+            return (s1[i] > s2[i]) ? 1 : -1;
+        }
+    }
+    return 0;
+}
+
 /**begin repeat
    #TYPE=BOOL,BYTE,UBYTE,SHORT,USHORT,INT,UINT,LONG,ULONG,LONGLONG,ULONGLONG,FLOAT,DOUBLE,LONGDOUBLE,CFLOAT,CDOUBLE,CLONGDOUBLE#
    #type=Bool,byte,ubyte,short,ushort,int,uint,long,ulong,longlong,ulonglong,float,double,longdouble,cfloat,cdouble,clongdouble#



From numpy-svn at scipy.org  Sun Feb 10 00:12:00 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat,  9 Feb 2008 23:12:00 -0600 (CST)
Subject: [Numpy-svn] r4783 - trunk/numpy/core/src
Message-ID: <20080210051200.4333639C0A0@new.scipy.org>

Author: charris
Date: 2008-02-09 23:11:58 -0600 (Sat, 09 Feb 2008)
New Revision: 4783

Modified:
   trunk/numpy/core/src/arraytypes.inc.src
Log:
Fix STRING_compare function to work correctly with strings containing zeros.


Modified: trunk/numpy/core/src/arraytypes.inc.src
===================================================================
--- trunk/numpy/core/src/arraytypes.inc.src	2008-02-10 04:57:45 UTC (rev 4782)
+++ trunk/numpy/core/src/arraytypes.inc.src	2008-02-10 05:11:58 UTC (rev 4783)
@@ -1679,7 +1679,17 @@
 static int
 STRING_compare(char *ip1, char *ip2, PyArrayObject *ap)
 {
-        return strncmp(ip1, ip2, ap->descr->elsize);
+    const unsigned char *c1 = (unsigned char *)ip1;
+    const unsigned char *c2 = (unsigned char *)ip2;
+    const size_t len = ap->descr->elsize;
+    size_t i;
+
+    for(i = 0; i < len; ++i) {
+        if (c1[i] != c2[i]) {
+            return (c1[i] > c2[i]) ? 1 : -1;
+        }
+    }
+    return 0;
 }
 
 /* taken from Python */



From numpy-svn at scipy.org  Sun Feb 10 01:19:44 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sun, 10 Feb 2008 00:19:44 -0600 (CST)
Subject: [Numpy-svn] r4784 - trunk/numpy/core/tests
Message-ID: <20080210061944.B810139C243@new.scipy.org>

Author: charris
Date: 2008-02-10 00:19:42 -0600 (Sun, 10 Feb 2008)
New Revision: 4784

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Add tests for sorting strings containing zeros.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2008-02-10 05:11:58 UTC (rev 4783)
+++ trunk/numpy/core/tests/test_regression.py	2008-02-10 06:19:42 UTC (rev 4784)
@@ -780,5 +780,17 @@
         y = np.array(['d','e'])
         assert_equal(x.searchsorted(y), [3,3])
 
+    def check_string_argsort_with_zeros(self, level=rlevel):
+        """Check argsort for strings containing zeros."""
+        x = np.fromstring("\x00\x02\x00\x01", dtype="|S2")
+        assert_array_equal(x.argsort(kind='m'), np.array([1,0]))
+        assert_array_equal(x.argsort(kind='q'), np.array([1,0]))
+
+    def check_string_sort_with_zeros(self, level=rlevel):
+        """Check sort for strings containing zeros."""
+        x = np.fromstring("\x00\x02\x00\x01", dtype="|S2")
+        y = np.fromstring("\x00\x01\x00\x02", dtype="|S2")
+        assert_array_equal(np.sort(x, kind="q"), y)
+
 if __name__ == "__main__":
     NumpyTest().run()



From numpy-svn at scipy.org  Sun Feb 10 01:38:39 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sun, 10 Feb 2008 00:38:39 -0600 (CST)
Subject: [Numpy-svn] r4785 - trunk/numpy/lib/src
Message-ID: <20080210063839.CCE1139C243@new.scipy.org>

Author: charris
Date: 2008-02-10 00:38:37 -0600 (Sun, 10 Feb 2008)
New Revision: 4785

Modified:
   trunk/numpy/lib/src/_compiled_base.c
Log:
Fix whitespace and compiler warning. _compiled_base.c is full of ugly code and
is in terrific need of reformating.


Modified: trunk/numpy/lib/src/_compiled_base.c
===================================================================
--- trunk/numpy/lib/src/_compiled_base.c	2008-02-10 06:19:42 UTC (rev 4784)
+++ trunk/numpy/lib/src/_compiled_base.c	2008-02-10 06:38:37 UTC (rev 4785)
@@ -344,12 +344,14 @@
 static npy_intp
 binary_search(double dval, double dlist [], npy_intp len)
 {
-    /* binary_search accepts three arguments: a numeric value and
+    /*
+     * binary_search accepts three arguments: a numeric value and
      * a numeric array and its length. It assumes that the array is sorted in
      * increasing order. It returns the index of the array's
      * largest element which is <= the value. It will return -1 if
-     * the value is less than the least element of the array. */
-    /* self is not used */
+     * the value is less than the least element of the array.
+     * self is not used
+     */
     npy_intp bottom , top , middle, result;
 
     if (dval < dlist [0])
@@ -530,12 +532,12 @@
 }
 
 
-static char packbits_doc[] = 
+static char packbits_doc[] =
   "out = numpy.packbits(myarray, axis=None)\n\n"
   "  myarray : an integer type array whose elements should be packed to bits\n\n"
   "   This routine packs the elements of a binary-valued dataset into a\n"
   "   NumPy array of type uint8 ('B') whose bits correspond to\n"
-  "   the logical (0 or nonzero) value of the input elements.\n" 
+  "   the logical (0 or nonzero) value of the input elements.\n"
   "   The dimension over-which bit-packing is done is given by axis.\n"
   "   The shape of the output has the same number of dimensions as the input\n"
   "   (unless axis is None, in which case the output is 1-d).\n"
@@ -551,7 +553,7 @@
   "     Note that 160 = 128 + 32\n"
   "               192 = 128 + 64\n";
 
-static char unpackbits_doc[] = 
+static char unpackbits_doc[] =
   "out = numpy.unpackbits(myarray, axis=None)\n\n"
   "     myarray - array of uint8 type where each element represents a bit-field\n"
   "        that should be unpacked into a boolean output array\n\n"
@@ -566,7 +568,7 @@
 
 */
 
-static void 
+static void
 _packbits(
 	      void 	*In,
               int       element_size,  /* in bytes */
@@ -586,11 +588,13 @@
   outptr = Out;                          /* pointer to output buffer */
   inptr  = In;                           /* pointer to input buffer */
 
-  /* Loop through the elements of In */
-  /* Determine whether or not it is nonzero.
-     Yes: set correspdoning bit (and adjust build value)
-     No:  move on     
-  /* Every 8th value, set the value of build and increment the outptr */
+  /*
+   * Loop through the elements of In
+   * Determine whether or not it is nonzero.
+   *  Yes: set correspdoning bit (and adjust build value)
+   *  No:  move on
+   * Every 8th value, set the value of build and increment the outptr
+   */
 
   remain = in_N % 8;                      /* uneven bits */
   if (remain == 0) remain = 8;
@@ -607,7 +611,7 @@
       build += (nonzero != 0);             /* add to this bit if the input value is non-zero */
     }
     if (index == out_Nm1) build <<= (8-remain);
-    /*      printf("Here: %d %d %d %d\n",build,slice,index,maxi); 
+    /*      printf("Here: %d %d %d %d\n",build,slice,index,maxi);
      */
     *outptr = build;
     outptr += out_stride;
@@ -616,7 +620,7 @@
 }
 
 
-static void 
+static void
 _unpackbits(
 		void      *In,
 		int       el_size,  /* unused */
@@ -670,7 +674,7 @@
     if (!PyArray_ISINTEGER(inp))
       PYSETERROR("Expecting an input array of integer data type");
   }
- 
+
   new = PyArray_CheckAxis(inp, &axis, 0);
   Py_DECREF(inp);
   if (new == NULL) return NULL;
@@ -680,7 +684,7 @@
     return PyArray_Copy((PyArrayObject *)new);
   }
 
-  if (PyArray_NDIM(new) == 0) {    
+  if (PyArray_NDIM(new) == 0) {
     if (unpack) {
       /* Handle 0-d array by converting it to a 1-d array */
       PyObject *temp;
@@ -733,7 +737,7 @@
   out = PyArray_New(new->ob_type, PyArray_NDIM(new), outdims, PyArray_UBYTE,
 		    NULL, NULL, 0, PyArray_ISFORTRAN(new), NULL);
   if (out == NULL) goto fail;
-  
+
   /* Setup iterators to iterate over all but given axis */
   it = (PyArrayIterObject *)PyArray_IterAllButAxis((PyObject *)new, &axis);
   ot = (PyArrayIterObject *)PyArray_IterAllButAxis((PyObject *)out, &axis);
@@ -744,12 +748,12 @@
   }
 
   while(PyArray_ITER_NOTDONE(it)) {
-    thefunc(PyArray_ITER_DATA(it), PyArray_ITEMSIZE(new), 
+    thefunc(PyArray_ITER_DATA(it), PyArray_ITEMSIZE(new),
 	    PyArray_DIM(new, axis), PyArray_STRIDE(new, axis),
-	    PyArray_ITER_DATA(ot), PyArray_DIM(out, axis), 
+	    PyArray_ITER_DATA(ot), PyArray_DIM(out, axis),
 	    PyArray_STRIDE(out, axis));
     PyArray_ITER_NEXT(it);
-    PyArray_ITER_NEXT(ot);	      
+    PyArray_ITER_NEXT(ot);
   }
   Py_DECREF(it);
   Py_DECREF(ot);
@@ -761,26 +765,26 @@
  fail:
   Py_XDECREF(new);
   Py_XDECREF(out);
-  return NULL;  
+  return NULL;
 }
 
 
 
 static PyObject *
-io_pack(PyObject *self, PyObject *args, PyObject *kwds)  
+io_pack(PyObject *self, PyObject *args, PyObject *kwds)
 {
   PyObject *obj;
   int axis=NPY_MAXDIMS;
   static char *kwlist[] = {"in", "axis", NULL};
 
-  if (!PyArg_ParseTupleAndKeywords( args, kwds, "O|O&" , kwlist, 
+  if (!PyArg_ParseTupleAndKeywords( args, kwds, "O|O&" , kwlist,
 				    &obj, PyArray_AxisConverter, &axis))
     return NULL;
-  return pack_or_unpack_bits(obj, axis, 0);  
+  return pack_or_unpack_bits(obj, axis, 0);
 }
 
 static PyObject *
-io_unpack(PyObject *self, PyObject *args, PyObject *kwds)  
+io_unpack(PyObject *self, PyObject *args, PyObject *kwds)
 {
   PyObject *obj;
   int axis=NPY_MAXDIMS;
@@ -789,7 +793,7 @@
   if (!PyArg_ParseTupleAndKeywords( args, kwds, "O|O&" , kwlist,
 				    &obj, PyArray_AxisConverter, &axis))
     return NULL;
-  return pack_or_unpack_bits(obj, axis, 1);  
+  return pack_or_unpack_bits(obj, axis, 1);
 }
 
 static struct PyMethodDef methods[] = {
@@ -803,9 +807,9 @@
      NULL},
     {"add_docstring", (PyCFunction)arr_add_docstring, METH_VARARGS,
      NULL},
-    {"packbits",  (PyCFunction)io_pack,       METH_VARARGS | METH_KEYWORDS, 
+    {"packbits",  (PyCFunction)io_pack,       METH_VARARGS | METH_KEYWORDS,
      packbits_doc},
-    {"unpackbits", (PyCFunction)io_unpack,     METH_VARARGS | METH_KEYWORDS, 
+    {"unpackbits", (PyCFunction)io_unpack,     METH_VARARGS | METH_KEYWORDS,
      unpackbits_doc},
     {NULL, NULL}    /* sentinel */
 };



From numpy-svn at scipy.org  Sun Feb 10 10:22:03 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sun, 10 Feb 2008 09:22:03 -0600 (CST)
Subject: [Numpy-svn] r4786 - trunk/numpy/ma
Message-ID: <20080210152203.E451839C03B@new.scipy.org>

Author: jarrod.millman
Date: 2008-02-10 09:22:01 -0600 (Sun, 10 Feb 2008)
New Revision: 4786

Added:
   trunk/numpy/ma/README.txt
Log:
initial port from Moin Moin site


Added: trunk/numpy/ma/README.txt
===================================================================
--- trunk/numpy/ma/README.txt	2008-02-10 06:38:37 UTC (rev 4785)
+++ trunk/numpy/ma/README.txt	2008-02-10 15:22:01 UTC (rev 4786)
@@ -0,0 +1,241 @@
+==================================
+A Guide to Masked Arrays in NumPy
+==================================
+
+.. Contents::
+
+See http://www.scipy.org/scipy/numpy/wiki/MaskedArray
+for updates of this document.
+
+
+History
+-------
+
+As a regular user of MaskedArray, I (Pierre G.F. Gerard-Marchant) became
+increasingly frustrated with the subclassing of masked arrays (even if
+I can only blame my inexperience). I needed to develop a class of arrays
+that could store some additional information along with numerical values,
+while keeping the possibility for missing data (picture storing a series
+of dates along with measurements, what would later become the `TimeSeries
+Scikit <http://projects.scipy.org/scipy/scikits/wiki/TimeSeries>`__
+.
+
+I started to implement such a class, but then quickly realized that
+any additional information disappeared when processing these subarrays
+(for example, adding a constant value to a subarray would erase its
+dates). I ended up writing the equivalent of *numpy.core.ma* for my
+particular class, ufuncs included. Everything went fine until I needed to
+subclass my new class, when more problems showed up: some attributes of
+the new subclass were lost during processing. I identified the culprit as
+MaskedArray, which returns masked ndarrays when I expected masked
+arrays of my class. I was preparing myself to rewrite *numpy.core.ma*
+when I forced myself to learn how to subclass ndarrays. As I became more
+familiar with the *__new__* and *__array_finalize__* methods,
+I started to wonder why masked arrays were objects, and not ndarrays,
+and whether it wouldn't be more convenient for subclassing if they did
+behave like regular ndarrays.
+
+The new *maskedarray* is what I eventually come up with. The
+main differences with the initial *numpy.core.ma* package are
+that MaskedArray is now a subclass of *ndarray* and that the
+*_data* section can now be any subclass of *ndarray*. Apart from a
+couple of issues listed below, the behavior of the new MaskedArray
+class reproduces the old one. Initially the *maskedarray*
+implementation was marginally slower than *numpy.ma* in some areas,
+but work is underway to speed it up; the expectation is that it can be
+made substantially faster than the present *numpy.ma*.
+
+
+Note that if the subclass has some special methods and
+attributes, they are not propagated to the masked version:
+this would require a modification of the *__getattribute__*
+method (first trying *ndarray.__getattribute__*, then trying
+*self._data.__getattribute__* if an exception is raised in the first
+place), which really slows things down.
+
+Main differences
+----------------
+
+ * The *_data* part of the masked array can be any subclass of ndarray (but not recarray, cf below).
+ * *fill_value* is now a property, not a function.
+ * in the majority of cases, the mask is forced to *nomask* when no value is actually masked. A notable exception is when a masked array (with no masked values) has just been unpickled.
+ * I got rid of the *share_mask* flag, I never understood its purpose.
+ * *put*, *putmask* and *take* now mimic the ndarray methods, to avoid unpleasant surprises. Moreover, *put* and *putmask* both update the mask when needed.  * if *a* is a masked array, *bool(a)* raises a *ValueError*, as it does with ndarrays.
+ * in the same way, the comparison of two masked arrays is a masked array, not a boolean
+ * *filled(a)* returns an array of the same subclass as *a._data*, and no test is performed on whether it is contiguous or not.
+ * the mask is always printed, even if it's *nomask*, which makes things easie (for me at least) to remember that a masked array is used.
+ * *cumsum* works as if the *_data* array was filled with 0. The mask is preserved, but not updated.
+ * *cumprod* works as if the *_data* array was filled with 1. The mask is preserved, but not updated.
+
+New features
+------------
+
+This list is non-exhaustive...
+
+ * the *mr_* function mimics *r_* for masked arrays.
+ * the *anom* method returns the anomalies (deviations from the average)
+ * the *stdu* and *varu* return unbiased estimates of the standard deviation and variance, respectively.
+
+Using the new package with numpy.core.ma
+----------------------------------------
+
+I tried to make sure that the new package can understand old masked
+arrays. Unfortunately, there's no upward compatibility.
+
+For example:
+
+>>> import numpy.core.ma as old_ma
+>>> import maskedarray as new_ma
+>>> x = old_ma.array([1,2,3,4,5], mask=[0,0,1,0,0])
+>>> x
+array(data =
+ [     1      2 999999      4      5],
+      mask =
+ [False False True False False],
+      fill_value=999999)
+>>> y = new_ma.array([1,2,3,4,5], mask=[0,0,1,0,0])
+>>> y
+array(data = [1 2 -- 4 5],
+      mask = [False False True False False],
+      fill_value=999999)
+>>> x==y
+array(data =
+ [True True True True True],
+      mask =
+ [False False True False False],
+      fill_value=?)
+>>> old_ma.getmask(x) == new_ma.getmask(x)
+array([True, True, True, True, True], dtype=bool)
+>>> old_ma.getmask(y) == new_ma.getmask(y)
+array([True, True, False, True, True], dtype=bool)
+>>> old_ma.getmask(y)
+False
+
+
+Using maskedarray with matplotlib
+---------------------------------
+
+Starting with matplotlib 0.91.2, the masked array importing will work with
+the the maskedarray branch) as well as with earlier versions.
+
+By default matplotlib still uses numpy.ma, but there is an rcParams setting
+that you can use to select maskedarray instead.  In the matplotlibrc file
+you will find::
+
+  #maskedarray : False       # True to use external maskedarray module
+                             # instead of numpy.ma; this is a temporary #
+                             setting for testing maskedarray.
+
+
+Uncomment and set to True to select maskedarray everywhere.
+Alternatively, you can test a script with maskedarray by using a
+command-line option, e.g.::
+
+  python simple_plot.py --maskedarray
+
+
+Masked records
+--------------
+
+Like *numpy.core.ma*, the *ndarray*-based implementation
+of MaskedArray is limited when working with records: you can
+mask any record of the array, but not a field in a record. If you
+need this feature, you may want to give the *mrecords* package
+a try (available in the *maskedarray* directory in the scipy
+sandbox). This module defines a new class, *MaskedRecord*. An
+instance of this class accepts a *recarray* as data, and uses two
+masks: the *fieldmask* has as many entries as records in the array,
+each entry with the same fields as a record, but of boolean types:
+they indicate whether the field is masked or not; a record entry
+is flagged as masked in the *mask* array if all the fields are
+masked. A few examples in the file should give you an idea of what
+can be done. Note that *mrecords* is still experimental...
+
+Optimizing maskedarray
+----------------------
+
+Should masked arrays be filled before processing or not?
+--------------------------------------------------------
+
+In the current implementation, most operations on masked arrays involve
+the following steps:
+
+ * the input arrays are filled
+ * the operation is performed on the filled arrays
+ * the mask is set for the results, from the combination of the input masks and the mask corresponding to the domain of the operation.
+
+For example, consider the division of two masked arrays::
+
+  import numpy
+  import maskedarray as ma
+  x = ma.array([1,2,3,4],mask=[1,0,0,0], dtype=numpy.float_)
+  y = ma.array([-1,0,1,2], mask=[0,0,0,1], dtype=numpy.float_)
+
+The division of x by y is then computed as::
+
+  d1 = x.filled(0) # d1 = array([0., 2., 3., 4.])
+  d2 = y.filled(1) # array([-1.,  0.,  1.,  1.])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  result = (d1/d2).view(MaskedArray) # masked_array([-0. inf, 3., 4.])
+  result._mask = logical_or(m, dm)
+
+Note that a division by zero takes place. To avoid it, we can consider
+to fill the input arrays, taking the domain mask into account, so that::
+
+  d1 = x._data.copy() # d1 = array([1., 2., 3., 4.])
+  d2 = y._data.copy() # array([-1.,  0.,  1.,  2.])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  numpy.putmask(d2, dm, 1) # d2 = array([-1.,  1.,  1.,  2.])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  result = (d1/d2).view(MaskedArray) # masked_array([-1. 0., 3., 2.])
+  result._mask = logical_or(m, dm)
+
+Note that the *.copy()* is required to avoid updating the inputs with
+*putmask*.  The *.filled()* method also involves a *.copy()*.
+
+A third possibility consists in avoid filling the arrays::
+
+  d1 = x._data # d1 = array([1., 2., 3., 4.])
+  d2 = y._data # array([-1.,  0.,  1.,  2.])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  result = (d1/d2).view(MaskedArray) # masked_array([-1. inf, 3., 2.])
+  result._mask = logical_or(m, dm)
+
+Note that here again the division by zero takes place.
+
+A quick benchmark gives the following results:
+
+ * *numpy.ma.divide*  : 2.69 ms per loop
+ * classical division     : 2.21 ms per loop
+ * division w/ prefilling : 2.34 ms per loop
+ * division w/o filling   : 1.55 ms per loop
+
+So, is it worth filling the arrays beforehand ? Yes, if we are interested
+in avoiding floating-point exceptions that may fill the result with infs
+and nans. No, if we are only interested into speed...
+
+
+Thanks
+------
+
+I'd like to thank Paul Dubois, Travis Oliphant and Sasha for the
+original masked array package: without you, I would never have started
+that (it might be argued that I shouldn't have anyway, but that's
+another story...).  I also wish to extend these thanks to Reggie Dugard
+and Eric Firing for their suggestions and numerous improvements.
+
+
+Revision notes
+--------------
+
+  * 08/25/2007 : Creation of this page
+  * 01/23/2007 : The package has been moved to the SciPy sandbox, and is regularly updated: please check out your SVN version!
+
+
+
+



From numpy-svn at scipy.org  Tue Feb 12 06:37:12 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 05:37:12 -0600 (CST)
Subject: [Numpy-svn] r4787 - trunk/numpy/distutils/fcompiler
Message-ID: <20080212113712.2231B39C334@new.scipy.org>

Author: pearu
Date: 2008-02-12 05:37:06 -0600 (Tue, 12 Feb 2008)
New Revision: 4787

Modified:
   trunk/numpy/distutils/fcompiler/hpux.py
Log:
hpux fortran compiler support: patch from an user feedback.

Modified: trunk/numpy/distutils/fcompiler/hpux.py
===================================================================
--- trunk/numpy/distutils/fcompiler/hpux.py	2008-02-10 15:22:01 UTC (rev 4786)
+++ trunk/numpy/distutils/fcompiler/hpux.py	2008-02-12 11:37:06 UTC (rev 4787)
@@ -21,12 +21,15 @@
     module_include_switch = None #XXX: fix me
     pic_flags = ['+pic=long']
     def get_flags(self):
-        return self.pic_flags + ['+ppu']
+        return self.pic_flags + ['+ppu', '+DD64']
     def get_flags_opt(self):
         return ['-O3']
     def get_libraries(self):
         return ['m']
-    def get_version(self, force=0, ok_status=[256,0]):
+   def get_library_dirs(self):
+       opt = ['/usr/lib/hpux64']
+       return opt
+    def get_version(self, force=0, ok_status=[256,0,1]):
         # XXX status==256 may indicate 'unrecognized option' or
         #     'no input file'. So, version_cmd needs more work.
         return FCompiler.get_version(self,force,ok_status)



From numpy-svn at scipy.org  Tue Feb 12 06:49:16 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 05:49:16 -0600 (CST)
Subject: [Numpy-svn] r4788 - trunk/numpy/distutils/fcompiler
Message-ID: <20080212114916.3060239C435@new.scipy.org>

Author: pearu
Date: 2008-02-12 05:49:11 -0600 (Tue, 12 Feb 2008)
New Revision: 4788

Modified:
   trunk/numpy/distutils/fcompiler/hpux.py
Log:
Fix type. Sorry about that.

Modified: trunk/numpy/distutils/fcompiler/hpux.py
===================================================================
--- trunk/numpy/distutils/fcompiler/hpux.py	2008-02-12 11:37:06 UTC (rev 4787)
+++ trunk/numpy/distutils/fcompiler/hpux.py	2008-02-12 11:49:11 UTC (rev 4788)
@@ -26,9 +26,9 @@
         return ['-O3']
     def get_libraries(self):
         return ['m']
-   def get_library_dirs(self):
-       opt = ['/usr/lib/hpux64']
-       return opt
+    def get_library_dirs(self):
+        opt = ['/usr/lib/hpux64']
+        return opt
     def get_version(self, force=0, ok_status=[256,0,1]):
         # XXX status==256 may indicate 'unrecognized option' or
         #     'no input file'. So, version_cmd needs more work.



From numpy-svn at scipy.org  Tue Feb 12 13:19:39 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 12:19:39 -0600 (CST)
Subject: [Numpy-svn] r4789 - trunk/numpy/core/tests
Message-ID: <20080212181939.6CBE139C173@new.scipy.org>

Author: charris
Date: 2008-02-12 12:19:37 -0600 (Tue, 12 Feb 2008)
New Revision: 4789

Modified:
   trunk/numpy/core/tests/test_multiarray.py
Log:
Add tests of the sort and argsort methods preparatory to merging new
type specific versions for strings and unicode.


Modified: trunk/numpy/core/tests/test_multiarray.py
===================================================================
--- trunk/numpy/core/tests/test_multiarray.py	2008-02-12 11:49:11 UTC (rev 4788)
+++ trunk/numpy/core/tests/test_multiarray.py	2008-02-12 18:19:37 UTC (rev 4789)
@@ -250,6 +250,174 @@
         self.failUnlessRaises(ValueError, lambda: a.transpose(0,0))
         self.failUnlessRaises(ValueError, lambda: a.transpose(0,1,2))
 
+    def check_sort(self):
+        # all c scalar sorts use the same code with different types
+        # so it suffices to run a quick check with one type. The number
+        # of sorted items must be greater than ~50 to check the actual
+        # algorithm because quick and merge sort fall over to insertion
+        # sort for small arrays.
+        a = np.arange(100)
+        b = a[::-1].copy()
+        for kind in ['q','m','h'] :
+            msg = "scalar sort, kind=%s" % kind
+            c = a.copy();
+            c.sort(kind=kind)
+            assert_equal(c, a, msg)
+            c = b.copy();
+            c.sort(kind=kind)
+            assert_equal(c, a, msg)
+
+        # test complex sorts. These use the same code as the scalars
+        # but the compare fuction differs.
+        ai = a*1j + 1
+        bi = b*1j + 1
+        for kind in ['q','m','h'] :
+            msg = "complex sort, real part == 1, kind=%s" % kind
+            c = ai.copy();
+            c.sort(kind=kind)
+            assert_equal(c, ai, msg)
+            c = bi.copy();
+            c.sort(kind=kind)
+            assert_equal(c, ai, msg)
+        ai = a + 1j
+        bi = b + 1j
+        for kind in ['q','m','h'] :
+            msg = "complex sort, imag part == 1, kind=%s" % kind
+            c = ai.copy();
+            c.sort(kind=kind)
+            assert_equal(c, ai, msg)
+            c = bi.copy();
+            c.sort(kind=kind)
+            assert_equal(c, ai, msg)
+
+        # test string sorts. Only quicksort is available at this time.
+        s = 'aaaaaaaa'
+        a = np.array([s + chr(i) for i in range(100)])
+        b = a[::-1].copy()
+        for kind in ['q'] :
+            msg = "string sort, kind=%s" % kind
+            c = a.copy();
+            c.sort(kind=kind)
+            assert_equal(c, a, msg)
+            c = b.copy();
+            c.sort(kind=kind)
+            assert_equal(c, a, msg)
+
+        # test unicode sort. Only quicksort is available at this time.
+        s = 'aaaaaaaa'
+        a = np.array([s + chr(i) for i in range(100)], dtype=np.unicode)
+        b = a[::-1].copy()
+        for kind in ['q'] :
+            msg = "unicode sort, kind=%s" % kind
+            c = a.copy();
+            c.sort(kind=kind)
+            assert_equal(c, a, msg)
+            c = b.copy();
+            c.sort(kind=kind)
+            assert_equal(c, a, msg)
+
+        # todo, check object array sorts.
+
+        # check axis handling. This should be the same for all type
+        # specific sorts, so we only check it for one type and one kind
+        a = np.array([[3,2],[1,0]])
+        b = np.array([[1,0],[3,2]])
+        c = np.array([[2,3],[0,1]])
+        d = a.copy()
+        d.sort(axis=0)
+        assert_equal(d, b, "test sort with axis=0")
+        d = a.copy()
+        d.sort(axis=1)
+        assert_equal(d, c, "test sort with axis=1")
+        d = a.copy()
+        d.sort()
+        assert_equal(d, c, "test sort with default axis")
+        # using None is known fail at this point
+        # d = a.copy()
+        # d.sort(axis=None)
+        #assert_equal(d, c, "test sort with axis=None")
+
+    def check_argsort(self):
+        # all c scalar argsorts use the same code with different types
+        # so it suffices to run a quick check with one type. The number
+        # of sorted items must be greater than ~50 to check the actual
+        # algorithm because quick and merge sort fall over to insertion
+        # sort for small arrays.
+        a = np.arange(100)
+        b = a[::-1].copy()
+        for kind in ['q','m','h'] :
+            msg = "scalar argsort, kind=%s" % kind
+            assert_equal(a.copy().argsort(kind=kind), a, msg)
+            assert_equal(b.copy().argsort(kind=kind), b, msg)
+
+        # test complex argsorts. These use the same code as the scalars
+        # but the compare fuction differs.
+        ai = a*1j + 1
+        bi = b*1j + 1
+        for kind in ['q','m','h'] :
+            msg = "complex argsort, kind=%s" % kind
+            assert_equal(ai.copy().argsort(kind=kind), a, msg)
+            assert_equal(bi.copy().argsort(kind=kind), b, msg)
+        ai = a + 1j
+        bi = b + 1j
+        for kind in ['q','m','h'] :
+            msg = "complex argsort, kind=%s" % kind
+            assert_equal(ai.copy().argsort(kind=kind), a, msg)
+            assert_equal(bi.copy().argsort(kind=kind), b, msg)
+
+        # test string argsorts. Only quick and merge sort are
+        # available at this time.
+        s = 'aaaaaaaa'
+        a = np.array([s + chr(i) for i in range(100)])
+        b = a[::-1].copy()
+        r = arange(100)
+        rr = r[::-1].copy()
+        for kind in ['q', 'm'] :
+            msg = "string argsort, kind=%s" % kind
+            assert_equal(a.copy().argsort(kind=kind), r, msg)
+            assert_equal(b.copy().argsort(kind=kind), rr, msg)
+
+        # test unicode argsorts. Only quick and merge sort are
+        # available at this time.
+        s = 'aaaaaaaa'
+        a = np.array([s + chr(i) for i in range(100)], dtype=np.unicode)
+        b = a[::-1].copy()
+        r = arange(100)
+        rr = r[::-1].copy()
+        for kind in ['q', 'm'] :
+            msg = "unicode argsort, kind=%s" % kind
+            assert_equal(a.copy().argsort(kind=kind), r, msg)
+            assert_equal(b.copy().argsort(kind=kind), rr, msg)
+
+        # todo, check object array argsorts.
+
+        # check axis handling. This should be the same for all type
+        # specific argsorts, so we only check it for one type and one kind
+        a = np.array([[3,2],[1,0]])
+        b = np.array([[1,1],[0,0]])
+        c = np.array([[1,0],[1,0]])
+        assert_equal(a.copy().argsort(axis=0), b)
+        assert_equal(a.copy().argsort(axis=1), c)
+        assert_equal(a.copy().argsort(), c)
+        # using None is known fail at this point
+        #assert_equal(a.copy().argsort(axis=None, c)
+
+        # check that stable argsorts are stable
+        r = np.arange(100)
+        # scalars
+        a = np.zeros(100)
+        assert_equal(a.argsort(kind='m'), r)
+        # complex
+        a = np.zeros(100, dtype=np.complex)
+        assert_equal(a.argsort(kind='m'), r)
+        # string
+        a = np.array(['aaaaaaaaa' for i in range(100)])
+        assert_equal(a.argsort(kind='m'), r)
+        # unicode
+        a = np.array(['aaaaaaaaa' for i in range(100)], dtype=np.unicode)
+        assert_equal(a.argsort(kind='m'), r)
+
+
 class TestSubscripting(NumpyTestCase):
     def check_test_zero_rank(self):
         x = array([1,2,3])



From numpy-svn at scipy.org  Tue Feb 12 16:32:00 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 15:32:00 -0600 (CST)
Subject: [Numpy-svn] r4790 - trunk/numpy/random/mtrand
Message-ID: <20080212213200.6DA1E39C048@new.scipy.org>

Author: rkern
Date: 2008-02-12 15:31:58 -0600 (Tue, 12 Feb 2008)
New Revision: 4790

Modified:
   trunk/numpy/random/mtrand/mtrand.c
   trunk/numpy/random/mtrand/mtrand.pyx
Log:
Make sure that multivariate_normal() uses the standard_normal() method rather than the function so as to use the same consistent state.

Modified: trunk/numpy/random/mtrand/mtrand.c
===================================================================
--- trunk/numpy/random/mtrand/mtrand.c	2008-02-12 18:19:37 UTC (rev 4789)
+++ trunk/numpy/random/mtrand/mtrand.c	2008-02-12 21:31:58 UTC (rev 4790)
@@ -1,16 +1,32 @@
-/* Generated by Pyrex 0.9.5.1a on Fri Nov 23 17:16:35 2007 */
+/* Generated by Pyrex 0.9.6.4 on Tue Feb 12 15:30:45 2008 */
 
+#define PY_SSIZE_T_CLEAN
 #include "Python.h"
 #include "structmember.h"
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
 #endif
+#if PY_VERSION_HEX < 0x02050000
+  typedef int Py_ssize_t;
+  #define PY_SSIZE_T_MAX INT_MAX
+  #define PY_SSIZE_T_MIN INT_MIN
+  #define PyInt_FromSsize_t(z) PyInt_FromLong(z)
+  #define PyInt_AsSsize_t(o)	PyInt_AsLong(o)
+#endif
+#ifndef WIN32
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+#endif
 #ifdef __cplusplus
 #define __PYX_EXTERN_C extern "C"
 #else
 #define __PYX_EXTERN_C extern
 #endif
-__PYX_EXTERN_C double pow(double, double);
+#include <math.h>
 #include "string.h"
 #include "math.h"
 #include "numpy/arrayobject.h"
@@ -28,7 +44,7 @@
 static char *__pyx_filename;
 static char **__pyx_f;
 
-static int __Pyx_GetStarArgs(PyObject **args, PyObject **kwds, char *kwd_list[], int nargs, PyObject **args2, PyObject **kwds2); /*proto*/
+static int __Pyx_GetStarArgs(PyObject **args, PyObject **kwds, char *kwd_list[],     Py_ssize_t nargs, PyObject **args2, PyObject **kwds2, char rqd_kwds[]); /*proto*/
 
 static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list); /*proto*/
 
@@ -39,7 +55,7 @@
 static PyObject *__Pyx_UnpackItem(PyObject *); /*proto*/
 static int __Pyx_EndUnpack(PyObject *); /*proto*/
 
-static PyObject *__Pyx_GetExcValue(void); /*proto*/
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
 
 static int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
 
@@ -49,16 +65,34 @@
 
 static PyTypeObject *__Pyx_ImportType(char *module_name, char *class_name, long size);  /*proto*/
 
+static PyObject *__Pyx_ImportModule(char *name); /*proto*/
+
 static void __Pyx_AddTraceback(char *funcname); /*proto*/
 
 /* Declarations from mtrand */
 
+typedef double (*__pyx_t_6mtrand_rk_cont0)(rk_state *);
 
+typedef double (*__pyx_t_6mtrand_rk_cont1)(rk_state *,double);
+
+typedef double (*__pyx_t_6mtrand_rk_cont2)(rk_state *,double,double);
+
+typedef double (*__pyx_t_6mtrand_rk_cont3)(rk_state *,double,double,double);
+
+typedef long (*__pyx_t_6mtrand_rk_disc0)(rk_state *);
+
+typedef long (*__pyx_t_6mtrand_rk_discnp)(rk_state *,long,double);
+
+typedef long (*__pyx_t_6mtrand_rk_discnmN)(rk_state *,long,long,long);
+
+typedef long (*__pyx_t_6mtrand_rk_discd)(rk_state *,double);
+
 struct __pyx_obj_6mtrand_RandomState {
   PyObject_HEAD
-  rk_state (*internal_state);
+  rk_state *internal_state;
 };
 
+
 static PyTypeObject *__pyx_ptype_6mtrand_dtype = 0;
 static PyTypeObject *__pyx_ptype_6mtrand_ndarray = 0;
 static PyTypeObject *__pyx_ptype_6mtrand_flatiter = 0;
@@ -123,26 +157,27 @@
 static PyObject *__pyx_k58;
 static PyObject *__pyx_k59;
 static PyObject *__pyx_k60;
-static PyObject *(__pyx_f_6mtrand_cont0_array(rk_state (*),double ((*)(rk_state (*))),PyObject *)); /*proto*/
-static PyObject *(__pyx_f_6mtrand_cont1_array_sc(rk_state (*),double ((*)(rk_state (*),double )),PyObject *,double )); /*proto*/
-static PyObject *(__pyx_f_6mtrand_cont1_array(rk_state (*),double ((*)(rk_state (*),double )),PyObject *,PyArrayObject *)); /*proto*/
-static PyObject *(__pyx_f_6mtrand_cont2_array_sc(rk_state (*),double ((*)(rk_state (*),double ,double )),PyObject *,double ,double )); /*proto*/
-static PyObject *(__pyx_f_6mtrand_cont2_array(rk_state (*),double ((*)(rk_state (*),double ,double )),PyObject *,PyArrayObject *,PyArrayObject *)); /*proto*/
-static PyObject *(__pyx_f_6mtrand_cont3_array_sc(rk_state (*),double ((*)(rk_state (*),double ,double ,double )),PyObject *,double ,double ,double )); /*proto*/
-static PyObject *(__pyx_f_6mtrand_cont3_array(rk_state (*),double ((*)(rk_state (*),double ,double ,double )),PyObject *,PyArrayObject *,PyArrayObject *,PyArrayObject *)); /*proto*/
-static PyObject *(__pyx_f_6mtrand_disc0_array(rk_state (*),long ((*)(rk_state (*))),PyObject *)); /*proto*/
-static PyObject *(__pyx_f_6mtrand_discnp_array_sc(rk_state (*),long ((*)(rk_state (*),long ,double )),PyObject *,long ,double )); /*proto*/
-static PyObject *(__pyx_f_6mtrand_discnp_array(rk_state (*),long ((*)(rk_state (*),long ,double )),PyObject *,PyArrayObject *,PyArrayObject *)); /*proto*/
-static PyObject *(__pyx_f_6mtrand_discnmN_array_sc(rk_state (*),long ((*)(rk_state (*),long ,long ,long )),PyObject *,long ,long ,long )); /*proto*/
-static PyObject *(__pyx_f_6mtrand_discnmN_array(rk_state (*),long ((*)(rk_state (*),long ,long ,long )),PyObject *,PyArrayObject *,PyArrayObject *,PyArrayObject *)); /*proto*/
-static PyObject *(__pyx_f_6mtrand_discd_array_sc(rk_state (*),long ((*)(rk_state (*),double )),PyObject *,double )); /*proto*/
-static PyObject *(__pyx_f_6mtrand_discd_array(rk_state (*),long ((*)(rk_state (*),double )),PyObject *,PyArrayObject *)); /*proto*/
-static double (__pyx_f_6mtrand_kahan_sum(double (*),long )); /*proto*/
+static PyObject *__pyx_f_6mtrand_cont0_array(rk_state *,__pyx_t_6mtrand_rk_cont0,PyObject *); /*proto*/
+static PyObject *__pyx_f_6mtrand_cont1_array_sc(rk_state *,__pyx_t_6mtrand_rk_cont1,PyObject *,double); /*proto*/
+static PyObject *__pyx_f_6mtrand_cont1_array(rk_state *,__pyx_t_6mtrand_rk_cont1,PyObject *,PyArrayObject *); /*proto*/
+static PyObject *__pyx_f_6mtrand_cont2_array_sc(rk_state *,__pyx_t_6mtrand_rk_cont2,PyObject *,double,double); /*proto*/
+static PyObject *__pyx_f_6mtrand_cont2_array(rk_state *,__pyx_t_6mtrand_rk_cont2,PyObject *,PyArrayObject *,PyArrayObject *); /*proto*/
+static PyObject *__pyx_f_6mtrand_cont3_array_sc(rk_state *,__pyx_t_6mtrand_rk_cont3,PyObject *,double,double,double); /*proto*/
+static PyObject *__pyx_f_6mtrand_cont3_array(rk_state *,__pyx_t_6mtrand_rk_cont3,PyObject *,PyArrayObject *,PyArrayObject *,PyArrayObject *); /*proto*/
+static PyObject *__pyx_f_6mtrand_disc0_array(rk_state *,__pyx_t_6mtrand_rk_disc0,PyObject *); /*proto*/
+static PyObject *__pyx_f_6mtrand_discnp_array_sc(rk_state *,__pyx_t_6mtrand_rk_discnp,PyObject *,long,double); /*proto*/
+static PyObject *__pyx_f_6mtrand_discnp_array(rk_state *,__pyx_t_6mtrand_rk_discnp,PyObject *,PyArrayObject *,PyArrayObject *); /*proto*/
+static PyObject *__pyx_f_6mtrand_discnmN_array_sc(rk_state *,__pyx_t_6mtrand_rk_discnmN,PyObject *,long,long,long); /*proto*/
+static PyObject *__pyx_f_6mtrand_discnmN_array(rk_state *,__pyx_t_6mtrand_rk_discnmN,PyObject *,PyArrayObject *,PyArrayObject *,PyArrayObject *); /*proto*/
+static PyObject *__pyx_f_6mtrand_discd_array_sc(rk_state *,__pyx_t_6mtrand_rk_discd,PyObject *,double); /*proto*/
+static PyObject *__pyx_f_6mtrand_discd_array(rk_state *,__pyx_t_6mtrand_rk_discd,PyObject *,PyArrayObject *); /*proto*/
+static double __pyx_f_6mtrand_kahan_sum(double *,long); /*proto*/
 
 
 /* Implementation of mtrand */
 
 
+static PyObject *__pyx_n_numpy;
 static PyObject *__pyx_n__sp;
 static PyObject *__pyx_n__rand;
 static PyObject *__pyx_n_seed;
@@ -191,13 +226,12 @@
 static PyObject *__pyx_n_dirichlet;
 static PyObject *__pyx_n_shuffle;
 static PyObject *__pyx_n_permutation;
-static PyObject *__pyx_n_numpy;
 
 static PyObject *__pyx_n_empty;
 static PyObject *__pyx_n_float64;
 
-static PyObject *__pyx_f_6mtrand_cont0_array(rk_state (*__pyx_v_state),double ((*__pyx_v_func)(rk_state (*))),PyObject *__pyx_v_size) {
-  double (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_cont0_array(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_cont0 __pyx_v_func,PyObject *__pyx_v_size) {
+  double *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -209,11 +243,9 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":129 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":129 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":130 */
     __pyx_2 = PyFloat_FromDouble(__pyx_v_func(__pyx_v_state)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 130; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -222,7 +254,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":132 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":132 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 132; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 132; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -242,20 +274,18 @@
     arrayObject = ((PyArrayObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":133 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":133 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":134 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":134 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":135 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":135 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":136 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":137 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":137 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -276,8 +306,8 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_f_6mtrand_cont1_array_sc(rk_state (*__pyx_v_state),double ((*__pyx_v_func)(rk_state (*),double )),PyObject *__pyx_v_size,double __pyx_v_a) {
-  double (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_cont1_array_sc(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_cont1 __pyx_v_func,PyObject *__pyx_v_size,double __pyx_v_a) {
+  double *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -289,11 +319,9 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":146 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":146 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":147 */
     __pyx_2 = PyFloat_FromDouble(__pyx_v_func(__pyx_v_state,__pyx_v_a)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 147; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -302,7 +330,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":149 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":149 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 149; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 149; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -322,20 +350,18 @@
     arrayObject = ((PyArrayObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":150 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":150 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":151 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":151 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":152 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":152 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":153 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,__pyx_v_a);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":154 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":154 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -360,11 +386,11 @@
 
 static PyObject *__pyx_k61p;
 
-static char (__pyx_k61[]) = "size is not compatible with inputs";
+static char __pyx_k61[] = "size is not compatible with inputs";
 
-static PyObject *__pyx_f_6mtrand_cont1_array(rk_state (*__pyx_v_state),double ((*__pyx_v_func)(rk_state (*),double )),PyObject *__pyx_v_size,PyArrayObject *__pyx_v_oa) {
-  double (*__pyx_v_array_data);
-  double (*__pyx_v_oa_data);
+static PyObject *__pyx_f_6mtrand_cont1_array(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_cont1 __pyx_v_func,PyObject *__pyx_v_size,PyArrayObject *__pyx_v_oa) {
+  double *__pyx_v_array_data;
+  double *__pyx_v_oa_data;
   PyArrayObject *arrayObject;
   npy_intp __pyx_v_length;
   npy_intp __pyx_v_i;
@@ -382,44 +408,44 @@
   __pyx_v_itera = ((PyArrayIterObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_multi = ((PyArrayMultiIterObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":165 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":165 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":166 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":166 */
     __pyx_2 = PyArray_SimpleNew(__pyx_v_oa->nd,__pyx_v_oa->dimensions,NPY_DOUBLE); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
     Py_DECREF(((PyObject *)arrayObject));
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":167 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":167 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":168 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":168 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":169 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":169 */
     __pyx_2 = PyArray_IterNew(((PyObject *)__pyx_v_oa)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 169; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayIterObject *)__pyx_2)));
     Py_DECREF(((PyObject *)__pyx_v_itera));
     __pyx_v_itera = ((PyArrayIterObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":170 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":170 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":171 */
-      (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(((double (*))__pyx_v_itera->dataptr)[0]));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":171 */
+      (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(((double *)__pyx_v_itera->dataptr)[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":172 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":172 */
       PyArray_ITER_NEXT(__pyx_v_itera);
     }
     goto __pyx_L2;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":174 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":174 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 174; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 174; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -439,21 +465,19 @@
     arrayObject = ((PyArrayObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":175 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":175 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":176 */
-    __pyx_3 = PyArray_MultiIterNew(2,((void (*))arrayObject),((void (*))__pyx_v_oa)); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":176 */
+    __pyx_3 = PyArray_MultiIterNew(2,((void *)arrayObject),((void *)__pyx_v_oa)); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_3)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_3);
     Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":178 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":178 */
     __pyx_1 = (__pyx_v_multi->size != PyArray_SIZE(arrayObject));
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":179 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 179; goto __pyx_L1;}
       __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 179; goto __pyx_L1;}
       Py_INCREF(__pyx_k61p);
@@ -468,23 +492,23 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":180 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":180 */
     __pyx_5 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_5; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":181 */
-      __pyx_v_oa_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":181 */
+      __pyx_v_oa_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":182 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":182 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_oa_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":183 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":183 */
       PyArray_MultiIter_NEXTi(__pyx_v_multi,1);
     }
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":184 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":184 */
   Py_INCREF(((PyObject *)arrayObject));
   __pyx_r = ((PyObject *)arrayObject);
   goto __pyx_L0;
@@ -506,8 +530,8 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_f_6mtrand_cont2_array_sc(rk_state (*__pyx_v_state),double ((*__pyx_v_func)(rk_state (*),double ,double )),PyObject *__pyx_v_size,double __pyx_v_a,double __pyx_v_b) {
-  double (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_cont2_array_sc(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_cont2 __pyx_v_func,PyObject *__pyx_v_size,double __pyx_v_a,double __pyx_v_b) {
+  double *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -519,11 +543,9 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":193 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":193 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":194 */
     __pyx_2 = PyFloat_FromDouble(__pyx_v_func(__pyx_v_state,__pyx_v_a,__pyx_v_b)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 194; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -532,7 +554,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":196 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":196 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 196; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 196; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -552,20 +574,18 @@
     arrayObject = ((PyArrayObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":197 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":197 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":198 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":198 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":199 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":199 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":200 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,__pyx_v_a,__pyx_v_b);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":201 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":201 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -588,12 +608,12 @@
 
 static PyObject *__pyx_k62p;
 
-static char (__pyx_k62[]) = "size is not compatible with inputs";
+static char __pyx_k62[] = "size is not compatible with inputs";
 
-static PyObject *__pyx_f_6mtrand_cont2_array(rk_state (*__pyx_v_state),double ((*__pyx_v_func)(rk_state (*),double ,double )),PyObject *__pyx_v_size,PyArrayObject *__pyx_v_oa,PyArrayObject *__pyx_v_ob) {
-  double (*__pyx_v_array_data);
-  double (*__pyx_v_oa_data);
-  double (*__pyx_v_ob_data);
+static PyObject *__pyx_f_6mtrand_cont2_array(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_cont2 __pyx_v_func,PyObject *__pyx_v_size,PyArrayObject *__pyx_v_oa,PyArrayObject *__pyx_v_ob) {
+  double *__pyx_v_array_data;
+  double *__pyx_v_oa_data;
+  double *__pyx_v_ob_data;
   PyArrayObject *arrayObject;
   npy_intp __pyx_v_i;
   PyArrayMultiIterObject *__pyx_v_multi;
@@ -609,48 +629,48 @@
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_multi = ((PyArrayMultiIterObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":214 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":214 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":215 */
-    __pyx_2 = PyArray_MultiIterNew(2,((void (*))__pyx_v_oa),((void (*))__pyx_v_ob)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":215 */
+    __pyx_2 = PyArray_MultiIterNew(2,((void *)__pyx_v_oa),((void *)__pyx_v_ob)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_2)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":216 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":216 */
     __pyx_2 = PyArray_SimpleNew(__pyx_v_multi->nd,__pyx_v_multi->dimensions,NPY_DOUBLE); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 216; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
     Py_DECREF(((PyObject *)arrayObject));
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":217 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":217 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":218 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":218 */
     __pyx_3 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_3; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":219 */
-      __pyx_v_oa_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,0));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":219 */
+      __pyx_v_oa_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,0));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":220 */
-      __pyx_v_ob_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":220 */
+      __pyx_v_ob_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":221 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":221 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_oa_data[0]),(__pyx_v_ob_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":222 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":222 */
       PyArray_MultiIter_NEXT(__pyx_v_multi);
     }
     goto __pyx_L2;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":224 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":224 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 224; goto __pyx_L1;}
     __pyx_4 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 224; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -670,21 +690,19 @@
     arrayObject = ((PyArrayObject *)__pyx_5);
     Py_DECREF(__pyx_5); __pyx_5 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":225 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":225 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":226 */
-    __pyx_4 = PyArray_MultiIterNew(3,((void (*))arrayObject),((void (*))__pyx_v_oa),((void (*))__pyx_v_ob)); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 226; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":226 */
+    __pyx_4 = PyArray_MultiIterNew(3,((void *)arrayObject),((void *)__pyx_v_oa),((void *)__pyx_v_ob)); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 226; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_4)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":227 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":227 */
     __pyx_1 = (__pyx_v_multi->size != PyArray_SIZE(arrayObject));
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":228 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 228; goto __pyx_L1;}
       __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 228; goto __pyx_L1;}
       Py_INCREF(__pyx_k62p);
@@ -699,29 +717,29 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":229 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":229 */
     __pyx_3 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_3; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":230 */
-      __pyx_v_oa_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":230 */
+      __pyx_v_oa_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":231 */
-      __pyx_v_ob_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,2));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":231 */
+      __pyx_v_ob_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,2));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":232 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":232 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_oa_data[0]),(__pyx_v_ob_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":233 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":233 */
       PyArray_MultiIter_NEXTi(__pyx_v_multi,1);
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":234 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":234 */
       PyArray_MultiIter_NEXTi(__pyx_v_multi,2);
     }
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":235 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":235 */
   Py_INCREF(((PyObject *)arrayObject));
   __pyx_r = ((PyObject *)arrayObject);
   goto __pyx_L0;
@@ -743,8 +761,8 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_f_6mtrand_cont3_array_sc(rk_state (*__pyx_v_state),double ((*__pyx_v_func)(rk_state (*),double ,double ,double )),PyObject *__pyx_v_size,double __pyx_v_a,double __pyx_v_b,double __pyx_v_c) {
-  double (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_cont3_array_sc(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_cont3 __pyx_v_func,PyObject *__pyx_v_size,double __pyx_v_a,double __pyx_v_b,double __pyx_v_c) {
+  double *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -756,11 +774,9 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":245 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":245 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":246 */
     __pyx_2 = PyFloat_FromDouble(__pyx_v_func(__pyx_v_state,__pyx_v_a,__pyx_v_b,__pyx_v_c)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 246; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -769,7 +785,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":248 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":248 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -789,20 +805,18 @@
     arrayObject = ((PyArrayObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":249 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":249 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":250 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":250 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":251 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":251 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":252 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,__pyx_v_a,__pyx_v_b,__pyx_v_c);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":253 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":253 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -825,13 +839,13 @@
 
 static PyObject *__pyx_k63p;
 
-static char (__pyx_k63[]) = "size is not compatible with inputs";
+static char __pyx_k63[] = "size is not compatible with inputs";
 
-static PyObject *__pyx_f_6mtrand_cont3_array(rk_state (*__pyx_v_state),double ((*__pyx_v_func)(rk_state (*),double ,double ,double )),PyObject *__pyx_v_size,PyArrayObject *__pyx_v_oa,PyArrayObject *__pyx_v_ob,PyArrayObject *__pyx_v_oc) {
-  double (*__pyx_v_array_data);
-  double (*__pyx_v_oa_data);
-  double (*__pyx_v_ob_data);
-  double (*__pyx_v_oc_data);
+static PyObject *__pyx_f_6mtrand_cont3_array(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_cont3 __pyx_v_func,PyObject *__pyx_v_size,PyArrayObject *__pyx_v_oa,PyArrayObject *__pyx_v_ob,PyArrayObject *__pyx_v_oc) {
+  double *__pyx_v_array_data;
+  double *__pyx_v_oa_data;
+  double *__pyx_v_ob_data;
+  double *__pyx_v_oc_data;
   PyArrayObject *arrayObject;
   npy_intp __pyx_v_i;
   PyArrayMultiIterObject *__pyx_v_multi;
@@ -848,51 +862,51 @@
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_multi = ((PyArrayMultiIterObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":267 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":267 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":268 */
-    __pyx_2 = PyArray_MultiIterNew(3,((void (*))__pyx_v_oa),((void (*))__pyx_v_ob),((void (*))__pyx_v_oc)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 268; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":268 */
+    __pyx_2 = PyArray_MultiIterNew(3,((void *)__pyx_v_oa),((void *)__pyx_v_ob),((void *)__pyx_v_oc)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 268; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_2)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":269 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":269 */
     __pyx_2 = PyArray_SimpleNew(__pyx_v_multi->nd,__pyx_v_multi->dimensions,NPY_DOUBLE); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
     Py_DECREF(((PyObject *)arrayObject));
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":270 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":270 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":271 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":271 */
     __pyx_3 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_3; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":272 */
-      __pyx_v_oa_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,0));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":272 */
+      __pyx_v_oa_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,0));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":273 */
-      __pyx_v_ob_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":273 */
+      __pyx_v_ob_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":274 */
-      __pyx_v_oc_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,2));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":274 */
+      __pyx_v_oc_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,2));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":275 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":275 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_oa_data[0]),(__pyx_v_ob_data[0]),(__pyx_v_oc_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":276 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":276 */
       PyArray_MultiIter_NEXT(__pyx_v_multi);
     }
     goto __pyx_L2;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":278 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":278 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 278; goto __pyx_L1;}
     __pyx_4 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 278; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -912,21 +926,19 @@
     arrayObject = ((PyArrayObject *)__pyx_5);
     Py_DECREF(__pyx_5); __pyx_5 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":279 */
-    __pyx_v_array_data = ((double (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":279 */
+    __pyx_v_array_data = ((double *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":280 */
-    __pyx_4 = PyArray_MultiIterNew(4,((void (*))arrayObject),((void (*))__pyx_v_oa),((void (*))__pyx_v_ob),((void (*))__pyx_v_oc)); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 280; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":280 */
+    __pyx_4 = PyArray_MultiIterNew(4,((void *)arrayObject),((void *)__pyx_v_oa),((void *)__pyx_v_ob),((void *)__pyx_v_oc)); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 280; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_4)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":282 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":282 */
     __pyx_1 = (__pyx_v_multi->size != PyArray_SIZE(arrayObject));
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":283 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; goto __pyx_L1;}
       __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; goto __pyx_L1;}
       Py_INCREF(__pyx_k63p);
@@ -941,29 +953,29 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":284 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":284 */
     __pyx_3 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_3; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":285 */
-      __pyx_v_oa_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":285 */
+      __pyx_v_oa_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":286 */
-      __pyx_v_ob_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,2));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":286 */
+      __pyx_v_ob_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,2));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":287 */
-      __pyx_v_oc_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,3));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":287 */
+      __pyx_v_oc_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,3));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":288 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":288 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_oa_data[0]),(__pyx_v_ob_data[0]),(__pyx_v_oc_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":289 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":289 */
       PyArray_MultiIter_NEXT(__pyx_v_multi);
     }
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":290 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":290 */
   Py_INCREF(((PyObject *)arrayObject));
   __pyx_r = ((PyObject *)arrayObject);
   goto __pyx_L0;
@@ -988,8 +1000,8 @@
 
 static PyObject *__pyx_n_int;
 
-static PyObject *__pyx_f_6mtrand_disc0_array(rk_state (*__pyx_v_state),long ((*__pyx_v_func)(rk_state (*))),PyObject *__pyx_v_size) {
-  long (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_disc0_array(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_disc0 __pyx_v_func,PyObject *__pyx_v_size) {
+  long *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -1001,11 +1013,9 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":298 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":298 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":299 */
     __pyx_2 = PyInt_FromLong(__pyx_v_func(__pyx_v_state)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 299; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -1014,7 +1024,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":301 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":301 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -1032,20 +1042,18 @@
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":302 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":302 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":303 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":303 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":304 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":304 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":305 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":306 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":306 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -1066,8 +1074,8 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_f_6mtrand_discnp_array_sc(rk_state (*__pyx_v_state),long ((*__pyx_v_func)(rk_state (*),long ,double )),PyObject *__pyx_v_size,long __pyx_v_n,double __pyx_v_p) {
-  long (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_discnp_array_sc(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_discnp __pyx_v_func,PyObject *__pyx_v_size,long __pyx_v_n,double __pyx_v_p) {
+  long *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -1079,11 +1087,9 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":314 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":314 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":315 */
     __pyx_2 = PyInt_FromLong(__pyx_v_func(__pyx_v_state,__pyx_v_n,__pyx_v_p)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 315; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -1092,7 +1098,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":317 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":317 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 317; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 317; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -1110,20 +1116,18 @@
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":318 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":318 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":319 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":319 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":320 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":320 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":321 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,__pyx_v_n,__pyx_v_p);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":322 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":322 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -1146,14 +1150,14 @@
 
 static PyObject *__pyx_k64p;
 
-static char (__pyx_k64[]) = "size is not compatible with inputs";
+static char __pyx_k64[] = "size is not compatible with inputs";
 
-static PyObject *__pyx_f_6mtrand_discnp_array(rk_state (*__pyx_v_state),long ((*__pyx_v_func)(rk_state (*),long ,double )),PyObject *__pyx_v_size,PyArrayObject *__pyx_v_on,PyArrayObject *__pyx_v_op) {
-  long (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_discnp_array(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_discnp __pyx_v_func,PyObject *__pyx_v_size,PyArrayObject *__pyx_v_on,PyArrayObject *__pyx_v_op) {
+  long *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   npy_intp __pyx_v_i;
-  double (*__pyx_v_op_data);
-  long (*__pyx_v_on_data);
+  double *__pyx_v_op_data;
+  long *__pyx_v_on_data;
   PyArrayMultiIterObject *__pyx_v_multi;
   PyObject *__pyx_r;
   int __pyx_1;
@@ -1167,48 +1171,48 @@
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_multi = ((PyArrayMultiIterObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":333 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":333 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":334 */
-    __pyx_2 = PyArray_MultiIterNew(2,((void (*))__pyx_v_on),((void (*))__pyx_v_op)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 334; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":334 */
+    __pyx_2 = PyArray_MultiIterNew(2,((void *)__pyx_v_on),((void *)__pyx_v_op)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 334; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_2)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":335 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":335 */
     __pyx_2 = PyArray_SimpleNew(__pyx_v_multi->nd,__pyx_v_multi->dimensions,NPY_LONG); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 335; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
     Py_DECREF(((PyObject *)arrayObject));
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":336 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":336 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":337 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":337 */
     __pyx_3 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_3; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":338 */
-      __pyx_v_on_data = ((long (*))PyArray_MultiIter_DATA(__pyx_v_multi,0));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":338 */
+      __pyx_v_on_data = ((long *)PyArray_MultiIter_DATA(__pyx_v_multi,0));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":339 */
-      __pyx_v_op_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":339 */
+      __pyx_v_op_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":340 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":340 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_on_data[0]),(__pyx_v_op_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":341 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":341 */
       PyArray_MultiIter_NEXT(__pyx_v_multi);
     }
     goto __pyx_L2;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":343 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":343 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 343; goto __pyx_L1;}
     __pyx_4 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 343; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -1226,21 +1230,19 @@
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":344 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":344 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":345 */
-    __pyx_4 = PyArray_MultiIterNew(3,((void (*))arrayObject),((void (*))__pyx_v_on),((void (*))__pyx_v_op)); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":345 */
+    __pyx_4 = PyArray_MultiIterNew(3,((void *)arrayObject),((void *)__pyx_v_on),((void *)__pyx_v_op)); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_4)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":346 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":346 */
     __pyx_1 = (__pyx_v_multi->size != PyArray_SIZE(arrayObject));
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":347 */
       __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 347; goto __pyx_L1;}
       __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 347; goto __pyx_L1;}
       Py_INCREF(__pyx_k64p);
@@ -1255,29 +1257,29 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":348 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":348 */
     __pyx_3 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_3; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":349 */
-      __pyx_v_on_data = ((long (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":349 */
+      __pyx_v_on_data = ((long *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":350 */
-      __pyx_v_op_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,2));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":350 */
+      __pyx_v_op_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,2));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":351 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":351 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_on_data[0]),(__pyx_v_op_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":352 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":352 */
       PyArray_MultiIter_NEXTi(__pyx_v_multi,1);
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":353 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":353 */
       PyArray_MultiIter_NEXTi(__pyx_v_multi,2);
     }
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":355 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":355 */
   Py_INCREF(((PyObject *)arrayObject));
   __pyx_r = ((PyObject *)arrayObject);
   goto __pyx_L0;
@@ -1299,8 +1301,8 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_f_6mtrand_discnmN_array_sc(rk_state (*__pyx_v_state),long ((*__pyx_v_func)(rk_state (*),long ,long ,long )),PyObject *__pyx_v_size,long __pyx_v_n,long __pyx_v_m,long __pyx_v_N) {
-  long (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_discnmN_array_sc(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_discnmN __pyx_v_func,PyObject *__pyx_v_size,long __pyx_v_n,long __pyx_v_m,long __pyx_v_N) {
+  long *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -1312,11 +1314,9 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":364 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":364 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":365 */
     __pyx_2 = PyInt_FromLong(__pyx_v_func(__pyx_v_state,__pyx_v_n,__pyx_v_m,__pyx_v_N)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -1325,7 +1325,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":367 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":367 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 367; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 367; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -1343,20 +1343,18 @@
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":368 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":368 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":369 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":369 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":370 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":370 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":371 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,__pyx_v_n,__pyx_v_m,__pyx_v_N);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":372 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":372 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -1379,13 +1377,13 @@
 
 static PyObject *__pyx_k65p;
 
-static char (__pyx_k65[]) = "size is not compatible with inputs";
+static char __pyx_k65[] = "size is not compatible with inputs";
 
-static PyObject *__pyx_f_6mtrand_discnmN_array(rk_state (*__pyx_v_state),long ((*__pyx_v_func)(rk_state (*),long ,long ,long )),PyObject *__pyx_v_size,PyArrayObject *__pyx_v_on,PyArrayObject *__pyx_v_om,PyArrayObject *__pyx_v_oN) {
-  long (*__pyx_v_array_data);
-  long (*__pyx_v_on_data);
-  long (*__pyx_v_om_data);
-  long (*__pyx_v_oN_data);
+static PyObject *__pyx_f_6mtrand_discnmN_array(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_discnmN __pyx_v_func,PyObject *__pyx_v_size,PyArrayObject *__pyx_v_on,PyArrayObject *__pyx_v_om,PyArrayObject *__pyx_v_oN) {
+  long *__pyx_v_array_data;
+  long *__pyx_v_on_data;
+  long *__pyx_v_om_data;
+  long *__pyx_v_oN_data;
   PyArrayObject *arrayObject;
   npy_intp __pyx_v_i;
   PyArrayMultiIterObject *__pyx_v_multi;
@@ -1402,51 +1400,51 @@
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_multi = ((PyArrayMultiIterObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":385 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":385 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":386 */
-    __pyx_2 = PyArray_MultiIterNew(3,((void (*))__pyx_v_on),((void (*))__pyx_v_om),((void (*))__pyx_v_oN)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 386; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":386 */
+    __pyx_2 = PyArray_MultiIterNew(3,((void *)__pyx_v_on),((void *)__pyx_v_om),((void *)__pyx_v_oN)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 386; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_2)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":387 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":387 */
     __pyx_2 = PyArray_SimpleNew(__pyx_v_multi->nd,__pyx_v_multi->dimensions,NPY_LONG); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
     Py_DECREF(((PyObject *)arrayObject));
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":388 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":388 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":389 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":389 */
     __pyx_3 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_3; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":390 */
-      __pyx_v_on_data = ((long (*))PyArray_MultiIter_DATA(__pyx_v_multi,0));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":390 */
+      __pyx_v_on_data = ((long *)PyArray_MultiIter_DATA(__pyx_v_multi,0));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":391 */
-      __pyx_v_om_data = ((long (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":391 */
+      __pyx_v_om_data = ((long *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":392 */
-      __pyx_v_oN_data = ((long (*))PyArray_MultiIter_DATA(__pyx_v_multi,2));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":392 */
+      __pyx_v_oN_data = ((long *)PyArray_MultiIter_DATA(__pyx_v_multi,2));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":393 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":393 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_on_data[0]),(__pyx_v_om_data[0]),(__pyx_v_oN_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":394 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":394 */
       PyArray_MultiIter_NEXT(__pyx_v_multi);
     }
     goto __pyx_L2;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":396 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":396 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; goto __pyx_L1;}
     __pyx_4 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -1464,21 +1462,19 @@
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":397 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":397 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":398 */
-    __pyx_4 = PyArray_MultiIterNew(4,((void (*))arrayObject),((void (*))__pyx_v_on),((void (*))__pyx_v_om),((void (*))__pyx_v_oN)); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":398 */
+    __pyx_4 = PyArray_MultiIterNew(4,((void *)arrayObject),((void *)__pyx_v_on),((void *)__pyx_v_om),((void *)__pyx_v_oN)); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_4)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_4);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":400 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":400 */
     __pyx_1 = (__pyx_v_multi->size != PyArray_SIZE(arrayObject));
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":401 */
       __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 401; goto __pyx_L1;}
       __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 401; goto __pyx_L1;}
       Py_INCREF(__pyx_k65p);
@@ -1493,29 +1489,29 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":402 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":402 */
     __pyx_3 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_3; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":403 */
-      __pyx_v_on_data = ((long (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":403 */
+      __pyx_v_on_data = ((long *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":404 */
-      __pyx_v_om_data = ((long (*))PyArray_MultiIter_DATA(__pyx_v_multi,2));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":404 */
+      __pyx_v_om_data = ((long *)PyArray_MultiIter_DATA(__pyx_v_multi,2));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":405 */
-      __pyx_v_oN_data = ((long (*))PyArray_MultiIter_DATA(__pyx_v_multi,3));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":405 */
+      __pyx_v_oN_data = ((long *)PyArray_MultiIter_DATA(__pyx_v_multi,3));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":406 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":406 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_on_data[0]),(__pyx_v_om_data[0]),(__pyx_v_oN_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":407 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":407 */
       PyArray_MultiIter_NEXT(__pyx_v_multi);
     }
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":409 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":409 */
   Py_INCREF(((PyObject *)arrayObject));
   __pyx_r = ((PyObject *)arrayObject);
   goto __pyx_L0;
@@ -1538,8 +1534,8 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_f_6mtrand_discd_array_sc(rk_state (*__pyx_v_state),long ((*__pyx_v_func)(rk_state (*),double )),PyObject *__pyx_v_size,double __pyx_v_a) {
-  long (*__pyx_v_array_data);
+static PyObject *__pyx_f_6mtrand_discd_array_sc(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_discd __pyx_v_func,PyObject *__pyx_v_size,double __pyx_v_a) {
+  long *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -1551,11 +1547,9 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":417 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":417 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":418 */
     __pyx_2 = PyInt_FromLong(__pyx_v_func(__pyx_v_state,__pyx_v_a)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -1564,7 +1558,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":420 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":420 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -1582,20 +1576,18 @@
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":421 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":421 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":422 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":422 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":423 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":423 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":424 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,__pyx_v_a);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":425 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":425 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -1618,11 +1610,11 @@
 
 static PyObject *__pyx_k66p;
 
-static char (__pyx_k66[]) = "size is not compatible with inputs";
+static char __pyx_k66[] = "size is not compatible with inputs";
 
-static PyObject *__pyx_f_6mtrand_discd_array(rk_state (*__pyx_v_state),long ((*__pyx_v_func)(rk_state (*),double )),PyObject *__pyx_v_size,PyArrayObject *__pyx_v_oa) {
-  long (*__pyx_v_array_data);
-  double (*__pyx_v_oa_data);
+static PyObject *__pyx_f_6mtrand_discd_array(rk_state *__pyx_v_state,__pyx_t_6mtrand_rk_discd __pyx_v_func,PyObject *__pyx_v_size,PyArrayObject *__pyx_v_oa) {
+  long *__pyx_v_array_data;
+  double *__pyx_v_oa_data;
   PyArrayObject *arrayObject;
   npy_intp __pyx_v_length;
   npy_intp __pyx_v_i;
@@ -1640,44 +1632,44 @@
   __pyx_v_multi = ((PyArrayMultiIterObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_itera = ((PyArrayIterObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":436 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":436 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":437 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":437 */
     __pyx_2 = PyArray_SimpleNew(__pyx_v_oa->nd,__pyx_v_oa->dimensions,NPY_LONG); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
     Py_DECREF(((PyObject *)arrayObject));
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":438 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":438 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":439 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":439 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":440 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":440 */
     __pyx_2 = PyArray_IterNew(((PyObject *)__pyx_v_oa)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 440; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayIterObject *)__pyx_2)));
     Py_DECREF(((PyObject *)__pyx_v_itera));
     __pyx_v_itera = ((PyArrayIterObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":441 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":441 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":442 */
-      (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(((double (*))__pyx_v_itera->dataptr)[0]));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":442 */
+      (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(((double *)__pyx_v_itera->dataptr)[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":443 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":443 */
       PyArray_ITER_NEXT(__pyx_v_itera);
     }
     goto __pyx_L2;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":445 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":445 */
     __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 445; goto __pyx_L1;}
     __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_empty); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 445; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -1695,21 +1687,19 @@
     arrayObject = ((PyArrayObject *)__pyx_2);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":446 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":446 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":447 */
-    __pyx_3 = PyArray_MultiIterNew(2,((void (*))arrayObject),((void (*))__pyx_v_oa)); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":447 */
+    __pyx_3 = PyArray_MultiIterNew(2,((void *)arrayObject),((void *)__pyx_v_oa)); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayMultiIterObject *)__pyx_3)));
     Py_DECREF(((PyObject *)__pyx_v_multi));
     __pyx_v_multi = ((PyArrayMultiIterObject *)__pyx_3);
     Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":448 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":448 */
     __pyx_1 = (__pyx_v_multi->size != PyArray_SIZE(arrayObject));
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":449 */
       __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; goto __pyx_L1;}
       __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; goto __pyx_L1;}
       Py_INCREF(__pyx_k66p);
@@ -1724,23 +1714,23 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":450 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":450 */
     __pyx_5 = __pyx_v_multi->size;
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_5; ++__pyx_v_i) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":451 */
-      __pyx_v_oa_data = ((double (*))PyArray_MultiIter_DATA(__pyx_v_multi,1));
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":451 */
+      __pyx_v_oa_data = ((double *)PyArray_MultiIter_DATA(__pyx_v_multi,1));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":452 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":452 */
       (__pyx_v_array_data[__pyx_v_i]) = __pyx_v_func(__pyx_v_state,(__pyx_v_oa_data[0]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":453 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":453 */
       PyArray_MultiIter_NEXTi(__pyx_v_multi,1);
     }
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":454 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":454 */
   Py_INCREF(((PyObject *)arrayObject));
   __pyx_r = ((PyObject *)arrayObject);
   goto __pyx_L0;
@@ -1762,7 +1752,7 @@
   return __pyx_r;
 }
 
-static double __pyx_f_6mtrand_kahan_sum(double (*__pyx_v_darr),long __pyx_v_n) {
+static double __pyx_f_6mtrand_kahan_sum(double *__pyx_v_darr,long __pyx_v_n) {
   double __pyx_v_c;
   double __pyx_v_y;
   double __pyx_v_t;
@@ -1770,29 +1760,29 @@
   long __pyx_v_i;
   double __pyx_r;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":459 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":459 */
   __pyx_v_sum = (__pyx_v_darr[0]);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":460 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":460 */
   __pyx_v_c = 0.0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":461 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":461 */
   for (__pyx_v_i = 1; __pyx_v_i < __pyx_v_n; ++__pyx_v_i) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":462 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":462 */
     __pyx_v_y = ((__pyx_v_darr[__pyx_v_i]) - __pyx_v_c);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":463 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":463 */
     __pyx_v_t = (__pyx_v_sum + __pyx_v_y);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":464 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":464 */
     __pyx_v_c = ((__pyx_v_t - __pyx_v_sum) - __pyx_v_y);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":465 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":465 */
     __pyx_v_sum = __pyx_v_t;
   }
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":466 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":466 */
   __pyx_r = __pyx_v_sum;
   goto __pyx_L0;
 
@@ -1814,10 +1804,10 @@
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_seed);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":489 */
-  ((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state = ((rk_state (*))PyMem_Malloc((sizeof(rk_state ))));
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":489 */
+  ((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state = ((rk_state *)PyMem_Malloc((sizeof(rk_state))));
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":491 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":491 */
   __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_seed); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 491; goto __pyx_L1;}
   __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 491; goto __pyx_L1;}
   Py_INCREF(__pyx_v_seed);
@@ -1845,15 +1835,13 @@
 static void __pyx_f_6mtrand_11RandomState___dealloc__(PyObject *__pyx_v_self) {
   int __pyx_1;
   Py_INCREF(__pyx_v_self);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":494 */
   __pyx_1 = (((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state != NULL);
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":495 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":495 */
     PyMem_Free(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":496 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":496 */
     ((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state = NULL;
     goto __pyx_L2;
   }
@@ -1883,11 +1871,9 @@
   Py_INCREF(__pyx_v_seed);
   arrayObject_obj = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":510 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":510 */
   __pyx_1 = __pyx_v_seed == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":511 */
     __pyx_v_errcode = rk_randomseed(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state);
     goto __pyx_L2;
   }
@@ -1903,23 +1889,21 @@
   Py_DECREF(__pyx_4); __pyx_4 = 0;
   Py_DECREF(__pyx_2); __pyx_2 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":513 */
     __pyx_5 = PyInt_AsUnsignedLongMask(__pyx_v_seed); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 513; goto __pyx_L1;}
     rk_seed(__pyx_5,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state);
     goto __pyx_L2;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":515 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":515 */
     __pyx_3 = PyArray_ContiguousFromObject(__pyx_v_seed,NPY_LONG,1,1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 515; goto __pyx_L1;}
     Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
     Py_DECREF(((PyObject *)arrayObject_obj));
     arrayObject_obj = ((PyArrayObject *)__pyx_3);
     Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":516 */
-    init_by_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,((unsigned long (*))arrayObject_obj->data),(arrayObject_obj->dimensions[0]));
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":516 */
+    init_by_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,((unsigned long *)arrayObject_obj->data),(arrayObject_obj->dimensions[0]));
   }
   __pyx_L2:;
 
@@ -1958,7 +1942,7 @@
   Py_INCREF(__pyx_v_self);
   arrayObject_state = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":525 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":525 */
   __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_empty); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
@@ -1979,10 +1963,10 @@
   arrayObject_state = ((PyArrayObject *)__pyx_1);
   Py_DECREF(__pyx_1); __pyx_1 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":526 */
-  memcpy(((void (*))arrayObject_state->data),((void (*))((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state->key),(624 * (sizeof(long ))));
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":526 */
+  memcpy(((void *)arrayObject_state->data),((void *)((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state->key),(624 * (sizeof(long))));
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":527 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":527 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_asarray); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -2002,7 +1986,7 @@
   arrayObject_state = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":528 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":528 */
   __pyx_1 = PyInt_FromLong(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state->pos); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; goto __pyx_L1;}
   __pyx_2 = PyTuple_New(3); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; goto __pyx_L1;}
   Py_INCREF(__pyx_n_MT19937);
@@ -2035,8 +2019,8 @@
 static PyObject *__pyx_k69p;
 static PyObject *__pyx_k70p;
 
-static char (__pyx_k69[]) = "algorithm must be 'MT19937'";
-static char (__pyx_k70[]) = "state must be 624 longs";
+static char __pyx_k69[] = "algorithm must be 'MT19937'";
+static char __pyx_k70[] = "state must be 624 longs";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_set_state(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_set_state[] = "Set the state from a tuple.\n\n        state = (\'MT19937\', int key[624], int pos)\n\n        set_state(state)\n        ";
@@ -2051,6 +2035,7 @@
   PyObject *__pyx_2 = 0;
   int __pyx_3;
   PyObject *__pyx_4 = 0;
+  PyObject *__pyx_5 = 0;
   static char *__pyx_argnames[] = {"state",0};
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O", __pyx_argnames, &__pyx_v_state)) return 0;
   Py_INCREF(__pyx_v_self);
@@ -2059,7 +2044,7 @@
   __pyx_v_algorithm_name = Py_None; Py_INCREF(Py_None);
   __pyx_v_key = Py_None; Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":539 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":539 */
   __pyx_1 = PyInt_FromLong(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 539; goto __pyx_L1;}
   __pyx_2 = PyObject_GetItem(__pyx_v_state, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 539; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
@@ -2067,12 +2052,10 @@
   __pyx_v_algorithm_name = __pyx_2;
   __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":540 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":540 */
   if (PyObject_Cmp(__pyx_v_algorithm_name, __pyx_n_MT19937, &__pyx_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 540; goto __pyx_L1;}
   __pyx_3 = __pyx_3 != 0;
   if (__pyx_3) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":541 */
     __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 541; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 541; goto __pyx_L1;}
     Py_INCREF(__pyx_k69p);
@@ -2087,8 +2070,8 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":542 */
-  __pyx_1 = PySequence_GetSlice(__pyx_v_state, 1, 0x7fffffff); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 542; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":542 */
+  __pyx_1 = PySequence_GetSlice(__pyx_v_state, 1, PY_SSIZE_T_MAX); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 542; goto __pyx_L1;}
   __pyx_2 = PyObject_GetIter(__pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 542; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
   __pyx_4 = __Pyx_UnpackItem(__pyx_2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 542; goto __pyx_L1;}
@@ -2102,10 +2085,8 @@
   if (__Pyx_EndUnpack(__pyx_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 542; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":543 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":543 */
   /*try:*/ {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":544 */
     __pyx_4 = PyArray_ContiguousFromObject(__pyx_v_key,NPY_ULONG,1,1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; goto __pyx_L3;}
     Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
     Py_DECREF(((PyObject *)arrayObject_obj));
@@ -2118,37 +2099,35 @@
   Py_XDECREF(__pyx_2); __pyx_2 = 0;
   Py_XDECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":545 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":545 */
   __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_TypeError); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 545; goto __pyx_L1;}
   __pyx_3 = PyErr_ExceptionMatches(__pyx_1);
   Py_DECREF(__pyx_1); __pyx_1 = 0;
   if (__pyx_3) {
     __Pyx_AddTraceback("mtrand.set_state");
-    __pyx_2 = __Pyx_GetExcValue(); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 545; goto __pyx_L1;}
-    Py_DECREF(__pyx_2); __pyx_2 = 0;
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":547 */
-    __pyx_4 = PyArray_ContiguousFromObject(__pyx_v_key,NPY_LONG,1,1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; goto __pyx_L1;}
-    Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
+    if (__Pyx_GetException(&__pyx_2, &__pyx_4, &__pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 545; goto __pyx_L1;}
+    __pyx_5 = PyArray_ContiguousFromObject(__pyx_v_key,NPY_LONG,1,1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; goto __pyx_L1;}
+    Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_5)));
     Py_DECREF(((PyObject *)arrayObject_obj));
-    arrayObject_obj = ((PyArrayObject *)__pyx_4);
+    arrayObject_obj = ((PyArrayObject *)__pyx_5);
+    Py_DECREF(__pyx_5); __pyx_5 = 0;
+    Py_DECREF(__pyx_2); __pyx_2 = 0;
     Py_DECREF(__pyx_4); __pyx_4 = 0;
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
     goto __pyx_L4;
   }
   goto __pyx_L1;
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":548 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":548 */
   __pyx_3 = ((arrayObject_obj->dimensions[0]) != 624);
   if (__pyx_3) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":549 */
-    __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; goto __pyx_L1;}
+    __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; goto __pyx_L1;}
     Py_INCREF(__pyx_k70p);
     PyTuple_SET_ITEM(__pyx_2, 0, __pyx_k70p);
-    __pyx_4 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; goto __pyx_L1;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
+    __pyx_4 = PyObject_CallObject(__pyx_5, __pyx_2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; goto __pyx_L1;}
+    Py_DECREF(__pyx_5); __pyx_5 = 0;
     Py_DECREF(__pyx_2); __pyx_2 = 0;
     __Pyx_Raise(__pyx_4, 0, 0);
     Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -2157,10 +2136,10 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":550 */
-  memcpy(((void (*))((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state->key),((void (*))arrayObject_obj->data),(624 * (sizeof(long ))));
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":550 */
+  memcpy(((void *)((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state->key),((void *)arrayObject_obj->data),(624 * (sizeof(long))));
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":551 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":551 */
   ((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state->pos = __pyx_v_pos;
 
   __pyx_r = Py_None; Py_INCREF(Py_None);
@@ -2169,6 +2148,7 @@
   Py_XDECREF(__pyx_1);
   Py_XDECREF(__pyx_2);
   Py_XDECREF(__pyx_4);
+  Py_XDECREF(__pyx_5);
   __Pyx_AddTraceback("mtrand.RandomState.set_state");
   __pyx_r = 0;
   __pyx_L0:;
@@ -2188,8 +2168,6 @@
   static char *__pyx_argnames[] = {0};
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "", __pyx_argnames)) return 0;
   Py_INCREF(__pyx_v_self);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":555 */
   __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_get_state); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; goto __pyx_L1;}
   __pyx_2 = PyObject_CallObject(__pyx_1, 0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
@@ -2220,8 +2198,6 @@
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O", __pyx_argnames, &__pyx_v_state)) return 0;
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_state);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":558 */
   __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_set_state); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; goto __pyx_L1;}
   __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; goto __pyx_L1;}
   Py_INCREF(__pyx_v_state);
@@ -2258,8 +2234,6 @@
   static char *__pyx_argnames[] = {0};
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "", __pyx_argnames)) return 0;
   Py_INCREF(__pyx_v_self);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":561 */
   __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_random); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
@@ -2305,8 +2279,6 @@
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "|O", __pyx_argnames, &__pyx_v_size)) return 0;
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_size);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":569 */
   __pyx_1 = __pyx_f_6mtrand_cont0_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_double,__pyx_v_size); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; goto __pyx_L1;}
   __pyx_r = __pyx_1;
   __pyx_1 = 0;
@@ -2335,8 +2307,6 @@
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "|O", __pyx_argnames, &__pyx_v_size)) return 0;
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_size);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":576 */
   __pyx_1 = __pyx_f_6mtrand_disc0_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_long,__pyx_v_size); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 576; goto __pyx_L1;}
   __pyx_r = __pyx_1;
   __pyx_1 = 0;
@@ -2356,7 +2326,7 @@
 
 static PyObject *__pyx_k71p;
 
-static char (__pyx_k71[]) = "low >= high";
+static char __pyx_k71[] = "low >= high";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_randint(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_randint[] = "Return random integers x such that low <= x < high.\n\n        randint(low, high=None, size=None) -> random values\n\n        If high is None, then 0 <= x < low.\n        ";
@@ -2367,7 +2337,7 @@
   long __pyx_v_lo;
   long __pyx_v_hi;
   long __pyx_v_diff;
-  long (*__pyx_v_array_data);
+  long *__pyx_v_array_data;
   PyArrayObject *arrayObject;
   long __pyx_v_length;
   long __pyx_v_i;
@@ -2387,38 +2357,36 @@
   Py_INCREF(__pyx_v_size);
   arrayObject = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":591 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":591 */
   __pyx_1 = __pyx_v_high == Py_None;
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":592 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":592 */
     __pyx_v_lo = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":593 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":593 */
     __pyx_2 = PyInt_AsLong(__pyx_v_low); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; goto __pyx_L1;}
     __pyx_v_hi = __pyx_2;
     goto __pyx_L2;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":595 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":595 */
     __pyx_2 = PyInt_AsLong(__pyx_v_low); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 595; goto __pyx_L1;}
     __pyx_v_lo = __pyx_2;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":596 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":596 */
     __pyx_2 = PyInt_AsLong(__pyx_v_high); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 596; goto __pyx_L1;}
     __pyx_v_hi = __pyx_2;
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":598 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":598 */
   __pyx_v_diff = ((__pyx_v_hi - __pyx_v_lo) - 1);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":599 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":599 */
   __pyx_1 = (__pyx_v_diff < 0);
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":600 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; goto __pyx_L1;}
     Py_INCREF(__pyx_k71p);
@@ -2433,12 +2401,10 @@
   }
   __pyx_L3:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":602 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":602 */
   __pyx_1 = __pyx_v_size == Py_None;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":603 */
-    __pyx_3 = PyInt_FromLong((((long )rk_interval(__pyx_v_diff,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state)) + __pyx_v_lo)); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 603; goto __pyx_L1;}
+    __pyx_3 = PyInt_FromLong((((long)rk_interval(__pyx_v_diff,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state)) + __pyx_v_lo)); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 603; goto __pyx_L1;}
     __pyx_r = __pyx_3;
     __pyx_3 = 0;
     goto __pyx_L0;
@@ -2446,7 +2412,7 @@
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":605 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":605 */
     __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 605; goto __pyx_L1;}
     __pyx_5 = PyObject_GetAttr(__pyx_4, __pyx_n_empty); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 605; goto __pyx_L1;}
     Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -2464,20 +2430,18 @@
     arrayObject = ((PyArrayObject *)__pyx_3);
     Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":606 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":606 */
     __pyx_v_length = PyArray_SIZE(arrayObject);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":607 */
-    __pyx_v_array_data = ((long (*))arrayObject->data);
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":607 */
+    __pyx_v_array_data = ((long *)arrayObject->data);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":608 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":608 */
     for (__pyx_v_i = 0; __pyx_v_i < __pyx_v_length; ++__pyx_v_i) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":609 */
-      (__pyx_v_array_data[__pyx_v_i]) = (__pyx_v_lo + ((long )rk_interval(__pyx_v_diff,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state)));
+      (__pyx_v_array_data[__pyx_v_i]) = (__pyx_v_lo + ((long)rk_interval(__pyx_v_diff,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state)));
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":610 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":610 */
     Py_INCREF(((PyObject *)arrayObject));
     __pyx_r = ((PyObject *)arrayObject);
     goto __pyx_L0;
@@ -2505,7 +2469,7 @@
 static char __pyx_doc_6mtrand_11RandomState_bytes[] = "Return random bytes.\n\n        bytes(length) -> str\n        ";
 static PyObject *__pyx_f_6mtrand_11RandomState_bytes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   unsigned int __pyx_v_length;
-  void (*__pyx_v_bytes);
+  void *__pyx_v_bytes;
   PyObject *__pyx_v_bytestring;
   PyObject *__pyx_r;
   PyObject *__pyx_1 = 0;
@@ -2514,19 +2478,19 @@
   Py_INCREF(__pyx_v_self);
   __pyx_v_bytestring = Py_None; Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":618 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":618 */
   __pyx_1 = PyString_FromStringAndSize(NULL,__pyx_v_length); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 618; goto __pyx_L1;}
   Py_DECREF(__pyx_v_bytestring);
   __pyx_v_bytestring = __pyx_1;
   __pyx_1 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":619 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":619 */
   __pyx_v_bytes = PyString_AS_STRING(__pyx_v_bytestring);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":620 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":620 */
   rk_fill(__pyx_v_bytes,__pyx_v_length,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":621 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":621 */
   Py_INCREF(__pyx_v_bytestring);
   __pyx_r = __pyx_v_bytestring;
   goto __pyx_L0;
@@ -2576,17 +2540,15 @@
   __pyx_v_odiff = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_temp = Py_None; Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":632 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":632 */
   __pyx_v_flow = PyFloat_AsDouble(__pyx_v_low);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":633 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":633 */
   __pyx_v_fhigh = PyFloat_AsDouble(__pyx_v_high);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":634 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":634 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":635 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_uniform,__pyx_v_size,__pyx_v_flow,(__pyx_v_fhigh - __pyx_v_flow)); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -2595,24 +2557,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":636 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":636 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":637 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":637 */
   __pyx_2 = PyArray_FROM_OTF(__pyx_v_low,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
   Py_DECREF(((PyObject *)__pyx_v_olow));
   __pyx_v_olow = ((PyArrayObject *)__pyx_2);
   Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":638 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":638 */
   __pyx_2 = PyArray_FROM_OTF(__pyx_v_high,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 638; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
   Py_DECREF(((PyObject *)__pyx_v_ohigh));
   __pyx_v_ohigh = ((PyArrayObject *)__pyx_2);
   Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":639 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":639 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 639; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_subtract); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 639; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -2628,17 +2590,17 @@
   __pyx_v_temp = __pyx_4;
   __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":640 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":640 */
   Py_INCREF(__pyx_v_temp);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":642 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":642 */
   __pyx_3 = PyArray_EnsureArray(__pyx_v_temp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_odiff));
   __pyx_v_odiff = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":643 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":643 */
   __pyx_2 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_uniform,__pyx_v_size,__pyx_v_olow,__pyx_v_odiff); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 643; goto __pyx_L1;}
   __pyx_r = __pyx_2;
   __pyx_2 = 0;
@@ -2664,7 +2626,6 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_n_len;
 static PyObject *__pyx_n_size;
 
 
@@ -2673,13 +2634,14 @@
 static PyObject *__pyx_f_6mtrand_11RandomState_rand(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_args = 0;
   PyObject *__pyx_r;
-  PyObject *__pyx_1 = 0;
-  PyObject *__pyx_2 = 0;
+  Py_ssize_t __pyx_1;
+  int __pyx_2;
   PyObject *__pyx_3 = 0;
-  int __pyx_4;
+  PyObject *__pyx_4 = 0;
   PyObject *__pyx_5 = 0;
+  PyObject *__pyx_6 = 0;
   static char *__pyx_argnames[] = {0};
-  if (__Pyx_GetStarArgs(&__pyx_args, &__pyx_kwds, __pyx_argnames, 0, &__pyx_v_args, 0) < 0) return 0;
+  if (__Pyx_GetStarArgs(&__pyx_args, &__pyx_kwds, __pyx_argnames, 0, &__pyx_v_args, 0, 0) < 0) return 0;
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "", __pyx_argnames)) {
     Py_XDECREF(__pyx_args);
     Py_XDECREF(__pyx_kwds);
@@ -2687,44 +2649,28 @@
     return 0;
   }
   Py_INCREF(__pyx_v_self);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":656 */
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; goto __pyx_L1;}
-  __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_args);
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_args);
-  __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_1 = PyInt_FromLong(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; goto __pyx_L1;}
-  if (PyObject_Cmp(__pyx_3, __pyx_1, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; goto __pyx_L1;}
-  __pyx_4 = __pyx_4 == 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  if (__pyx_4) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":657 */
-    __pyx_2 = PyObject_GetAttr(__pyx_v_self, __pyx_n_random_sample); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; goto __pyx_L1;}
-    __pyx_3 = PyObject_CallObject(__pyx_2, 0); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; goto __pyx_L1;}
-    Py_DECREF(__pyx_2); __pyx_2 = 0;
-    __pyx_r = __pyx_3;
-    __pyx_3 = 0;
+  __pyx_1 = PyObject_Length(__pyx_v_args); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; goto __pyx_L1;}
+  __pyx_2 = (__pyx_1 == 0);
+  if (__pyx_2) {
+    __pyx_3 = PyObject_GetAttr(__pyx_v_self, __pyx_n_random_sample); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; goto __pyx_L1;}
+    __pyx_4 = PyObject_CallObject(__pyx_3, 0); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; goto __pyx_L1;}
+    Py_DECREF(__pyx_3); __pyx_3 = 0;
+    __pyx_r = __pyx_4;
+    __pyx_4 = 0;
     goto __pyx_L0;
     goto __pyx_L2;
   }
   /*else*/ {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":659 */
-    __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_random_sample); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
-    __pyx_2 = PyTuple_New(0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
-    __pyx_3 = PyDict_New(); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
-    if (PyDict_SetItem(__pyx_3, __pyx_n_size, __pyx_v_args) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
-    __pyx_5 = PyEval_CallObjectWithKeywords(__pyx_1, __pyx_2, __pyx_3); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
-    Py_DECREF(__pyx_2); __pyx_2 = 0;
+    __pyx_3 = PyObject_GetAttr(__pyx_v_self, __pyx_n_random_sample); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
+    __pyx_4 = PyTuple_New(0); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
+    __pyx_5 = PyDict_New(); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
+    if (PyDict_SetItem(__pyx_5, __pyx_n_size, __pyx_v_args) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
+    __pyx_6 = PyEval_CallObjectWithKeywords(__pyx_3, __pyx_4, __pyx_5); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 659; goto __pyx_L1;}
     Py_DECREF(__pyx_3); __pyx_3 = 0;
-    __pyx_r = __pyx_5;
-    __pyx_5 = 0;
+    Py_DECREF(__pyx_4); __pyx_4 = 0;
+    Py_DECREF(__pyx_5); __pyx_5 = 0;
+    __pyx_r = __pyx_6;
+    __pyx_6 = 0;
     goto __pyx_L0;
   }
   __pyx_L2:;
@@ -2732,10 +2678,10 @@
   __pyx_r = Py_None; Py_INCREF(Py_None);
   goto __pyx_L0;
   __pyx_L1:;
-  Py_XDECREF(__pyx_1);
-  Py_XDECREF(__pyx_2);
   Py_XDECREF(__pyx_3);
+  Py_XDECREF(__pyx_4);
   Py_XDECREF(__pyx_5);
+  Py_XDECREF(__pyx_6);
   __Pyx_AddTraceback("mtrand.RandomState.rand");
   __pyx_r = 0;
   __pyx_L0:;
@@ -2751,12 +2697,13 @@
 static PyObject *__pyx_f_6mtrand_11RandomState_randn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_args = 0;
   PyObject *__pyx_r;
-  PyObject *__pyx_1 = 0;
-  PyObject *__pyx_2 = 0;
+  Py_ssize_t __pyx_1;
+  int __pyx_2;
   PyObject *__pyx_3 = 0;
-  int __pyx_4;
+  PyObject *__pyx_4 = 0;
+  PyObject *__pyx_5 = 0;
   static char *__pyx_argnames[] = {0};
-  if (__Pyx_GetStarArgs(&__pyx_args, &__pyx_kwds, __pyx_argnames, 0, &__pyx_v_args, 0) < 0) return 0;
+  if (__Pyx_GetStarArgs(&__pyx_args, &__pyx_kwds, __pyx_argnames, 0, &__pyx_v_args, 0, 0) < 0) return 0;
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "", __pyx_argnames)) {
     Py_XDECREF(__pyx_args);
     Py_XDECREF(__pyx_kwds);
@@ -2764,43 +2711,27 @@
     return 0;
   }
   Py_INCREF(__pyx_v_self);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":671 */
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; goto __pyx_L1;}
-  __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_args);
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_args);
-  __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_1 = PyInt_FromLong(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; goto __pyx_L1;}
-  if (PyObject_Cmp(__pyx_3, __pyx_1, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; goto __pyx_L1;}
-  __pyx_4 = __pyx_4 == 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  if (__pyx_4) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":672 */
-    __pyx_2 = PyObject_GetAttr(__pyx_v_self, __pyx_n_standard_normal); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 672; goto __pyx_L1;}
-    __pyx_3 = PyObject_CallObject(__pyx_2, 0); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 672; goto __pyx_L1;}
-    Py_DECREF(__pyx_2); __pyx_2 = 0;
-    __pyx_r = __pyx_3;
-    __pyx_3 = 0;
+  __pyx_1 = PyObject_Length(__pyx_v_args); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; goto __pyx_L1;}
+  __pyx_2 = (__pyx_1 == 0);
+  if (__pyx_2) {
+    __pyx_3 = PyObject_GetAttr(__pyx_v_self, __pyx_n_standard_normal); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 672; goto __pyx_L1;}
+    __pyx_4 = PyObject_CallObject(__pyx_3, 0); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 672; goto __pyx_L1;}
+    Py_DECREF(__pyx_3); __pyx_3 = 0;
+    __pyx_r = __pyx_4;
+    __pyx_4 = 0;
     goto __pyx_L0;
     goto __pyx_L2;
   }
   /*else*/ {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":674 */
-    __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_standard_normal); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; goto __pyx_L1;}
-    __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; goto __pyx_L1;}
+    __pyx_3 = PyObject_GetAttr(__pyx_v_self, __pyx_n_standard_normal); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; goto __pyx_L1;}
+    __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; goto __pyx_L1;}
     Py_INCREF(__pyx_v_args);
-    PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_args);
-    __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; goto __pyx_L1;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
-    Py_DECREF(__pyx_2); __pyx_2 = 0;
-    __pyx_r = __pyx_3;
-    __pyx_3 = 0;
+    PyTuple_SET_ITEM(__pyx_4, 0, __pyx_v_args);
+    __pyx_5 = PyObject_CallObject(__pyx_3, __pyx_4); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; goto __pyx_L1;}
+    Py_DECREF(__pyx_3); __pyx_3 = 0;
+    Py_DECREF(__pyx_4); __pyx_4 = 0;
+    __pyx_r = __pyx_5;
+    __pyx_5 = 0;
     goto __pyx_L0;
   }
   __pyx_L2:;
@@ -2808,9 +2739,9 @@
   __pyx_r = Py_None; Py_INCREF(Py_None);
   goto __pyx_L0;
   __pyx_L1:;
-  Py_XDECREF(__pyx_1);
-  Py_XDECREF(__pyx_2);
   Py_XDECREF(__pyx_3);
+  Py_XDECREF(__pyx_4);
+  Py_XDECREF(__pyx_5);
   __Pyx_AddTraceback("mtrand.RandomState.randn");
   __pyx_r = 0;
   __pyx_L0:;
@@ -2841,16 +2772,16 @@
   Py_INCREF(__pyx_v_high);
   Py_INCREF(__pyx_v_size);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":683 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":683 */
   __pyx_1 = __pyx_v_high == Py_None;
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":684 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":684 */
     Py_INCREF(__pyx_v_low);
     Py_DECREF(__pyx_v_high);
     __pyx_v_high = __pyx_v_low;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":685 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":685 */
     __pyx_2 = PyInt_FromLong(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; goto __pyx_L1;}
     Py_DECREF(__pyx_v_low);
     __pyx_v_low = __pyx_2;
@@ -2859,7 +2790,7 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":686 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":686 */
   __pyx_2 = PyObject_GetAttr(__pyx_v_self, __pyx_n_randint); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; goto __pyx_L1;}
   __pyx_3 = PyInt_FromLong(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; goto __pyx_L1;}
   __pyx_4 = PyNumber_Add(__pyx_v_high, __pyx_3); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; goto __pyx_L1;}
@@ -2905,8 +2836,6 @@
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "|O", __pyx_argnames, &__pyx_v_size)) return 0;
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_size);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":694 */
   __pyx_1 = __pyx_f_6mtrand_cont0_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_gauss,__pyx_v_size); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; goto __pyx_L1;}
   __pyx_r = __pyx_1;
   __pyx_1 = 0;
@@ -2930,8 +2859,8 @@
 static PyObject *__pyx_k73p;
 static PyObject *__pyx_k74p;
 
-static char (__pyx_k73[]) = "scale <= 0";
-static char (__pyx_k74[]) = "scale <= 0";
+static char __pyx_k73[] = "scale <= 0";
+static char __pyx_k74[] = "scale <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_normal(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_normal[] = "Normal distribution (mean=loc, stdev=scale).\n\n        normal(loc=0.0, scale=1.0, size=None) -> random values\n        ";
@@ -2961,21 +2890,19 @@
   __pyx_v_oloc = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_oscale = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":704 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":704 */
   __pyx_v_floc = PyFloat_AsDouble(__pyx_v_loc);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":705 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":705 */
   __pyx_v_fscale = PyFloat_AsDouble(__pyx_v_scale);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":706 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":706 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":707 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":707 */
     __pyx_1 = (__pyx_v_fscale <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":708 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; goto __pyx_L1;}
       Py_INCREF(__pyx_k73p);
@@ -2990,7 +2917,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":709 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":709 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_normal,__pyx_v_size,__pyx_v_floc,__pyx_v_fscale); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -2999,24 +2926,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":711 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":711 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":713 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":713 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_loc,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oloc));
   __pyx_v_oloc = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":714 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":714 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_scale,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_oscale));
   __pyx_v_oscale = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":715 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":715 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -3041,8 +2968,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":716 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 716; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 716; goto __pyx_L1;}
     Py_INCREF(__pyx_k74p);
@@ -3057,7 +2982,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":717 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":717 */
   __pyx_5 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_normal,__pyx_v_size,__pyx_v_oloc,__pyx_v_oscale); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 717; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -3087,10 +3012,10 @@
 static PyObject *__pyx_k77p;
 static PyObject *__pyx_k78p;
 
-static char (__pyx_k75[]) = "a <= 0";
-static char (__pyx_k76[]) = "b <= 0";
-static char (__pyx_k77[]) = "a <= 0";
-static char (__pyx_k78[]) = "b <= 0";
+static char __pyx_k75[] = "a <= 0";
+static char __pyx_k76[] = "b <= 0";
+static char __pyx_k77[] = "a <= 0";
+static char __pyx_k78[] = "b <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_beta(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_beta[] = "Beta distribution over [0, 1].\n\n        beta(a, b, size=None) -> random values\n        ";
@@ -3118,21 +3043,19 @@
   __pyx_v_oa = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_ob = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":727 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":727 */
   __pyx_v_fa = PyFloat_AsDouble(__pyx_v_a);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":728 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":728 */
   __pyx_v_fb = PyFloat_AsDouble(__pyx_v_b);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":729 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":729 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":730 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":730 */
     __pyx_1 = (__pyx_v_fa <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":731 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 731; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 731; goto __pyx_L1;}
       Py_INCREF(__pyx_k75p);
@@ -3147,11 +3070,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":732 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":732 */
     __pyx_1 = (__pyx_v_fb <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":733 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 733; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 733; goto __pyx_L1;}
       Py_INCREF(__pyx_k76p);
@@ -3166,7 +3087,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":734 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":734 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_beta,__pyx_v_size,__pyx_v_fa,__pyx_v_fb); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 734; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -3175,24 +3096,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":736 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":736 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":738 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":738 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_a,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 738; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oa));
   __pyx_v_oa = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":739 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":739 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_b,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 739; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_ob));
   __pyx_v_ob = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":740 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":740 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 740; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 740; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -3217,8 +3138,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 740; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":741 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 741; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 741; goto __pyx_L1;}
     Py_INCREF(__pyx_k77p);
@@ -3233,7 +3152,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":742 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":742 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 742; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 742; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -3258,8 +3177,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_3); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 742; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":743 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 743; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 743; goto __pyx_L1;}
     Py_INCREF(__pyx_k78p);
@@ -3274,7 +3191,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":744 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":744 */
   __pyx_3 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_beta,__pyx_v_size,__pyx_v_oa,__pyx_v_ob); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; goto __pyx_L1;}
   __pyx_r = __pyx_3;
   __pyx_3 = 0;
@@ -3302,8 +3219,8 @@
 static PyObject *__pyx_k79p;
 static PyObject *__pyx_k80p;
 
-static char (__pyx_k79[]) = "scale <= 0";
-static char (__pyx_k80[]) = "scale <= 0";
+static char __pyx_k79[] = "scale <= 0";
+static char __pyx_k80[] = "scale <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_exponential(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_exponential[] = "Exponential distribution.\n\n        exponential(scale=1.0, size=None) -> random values\n        ";
@@ -3327,18 +3244,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_oscale = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":754 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":754 */
   __pyx_v_fscale = PyFloat_AsDouble(__pyx_v_scale);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":755 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":755 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":756 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":756 */
     __pyx_1 = (__pyx_v_fscale <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":757 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 757; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 757; goto __pyx_L1;}
       Py_INCREF(__pyx_k79p);
@@ -3353,7 +3268,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":758 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":758 */
     __pyx_2 = __pyx_f_6mtrand_cont1_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_exponential,__pyx_v_size,__pyx_v_fscale); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -3362,17 +3277,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":760 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":760 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":762 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":762 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_scale,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oscale));
   __pyx_v_oscale = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":763 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":763 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -3397,8 +3312,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":764 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 764; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 764; goto __pyx_L1;}
     Py_INCREF(__pyx_k80p);
@@ -3413,7 +3326,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":765 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":765 */
   __pyx_5 = __pyx_f_6mtrand_cont1_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_exponential,__pyx_v_size,__pyx_v_oscale); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 765; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -3447,8 +3360,6 @@
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "|O", __pyx_argnames, &__pyx_v_size)) return 0;
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_size);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":772 */
   __pyx_1 = __pyx_f_6mtrand_cont0_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_standard_exponential,__pyx_v_size); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 772; goto __pyx_L1;}
   __pyx_r = __pyx_1;
   __pyx_1 = 0;
@@ -3469,8 +3380,8 @@
 static PyObject *__pyx_k81p;
 static PyObject *__pyx_k82p;
 
-static char (__pyx_k81[]) = "shape <= 0";
-static char (__pyx_k82[]) = "shape <= 0";
+static char __pyx_k81[] = "shape <= 0";
+static char __pyx_k82[] = "shape <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_standard_gamma(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_standard_gamma[] = "Standard Gamma distribution.\n\n        standard_gamma(shape, size=None) -> random values\n        ";
@@ -3493,18 +3404,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_oshape = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":782 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":782 */
   __pyx_v_fshape = PyFloat_AsDouble(__pyx_v_shape);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":783 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":783 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":784 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":784 */
     __pyx_1 = (__pyx_v_fshape <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":785 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 785; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 785; goto __pyx_L1;}
       Py_INCREF(__pyx_k81p);
@@ -3519,7 +3428,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":786 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":786 */
     __pyx_2 = __pyx_f_6mtrand_cont1_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_standard_gamma,__pyx_v_size,__pyx_v_fshape); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -3528,17 +3437,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":788 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":788 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":789 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":789 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_shape,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oshape));
   __pyx_v_oshape = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":790 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":790 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -3563,8 +3472,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":791 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 791; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 791; goto __pyx_L1;}
     Py_INCREF(__pyx_k82p);
@@ -3579,7 +3486,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":792 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":792 */
   __pyx_5 = __pyx_f_6mtrand_cont1_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_standard_gamma,__pyx_v_size,__pyx_v_oshape); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 792; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -3607,10 +3514,10 @@
 static PyObject *__pyx_k85p;
 static PyObject *__pyx_k86p;
 
-static char (__pyx_k83[]) = "shape <= 0";
-static char (__pyx_k84[]) = "scale <= 0";
-static char (__pyx_k85[]) = "shape <= 0";
-static char (__pyx_k86[]) = "scale <= 0";
+static char __pyx_k83[] = "shape <= 0";
+static char __pyx_k84[] = "scale <= 0";
+static char __pyx_k85[] = "shape <= 0";
+static char __pyx_k86[] = "scale <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_gamma(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_gamma[] = "Gamma distribution.\n\n        gamma(shape, scale=1.0, size=None) -> random values\n        ";
@@ -3639,21 +3546,19 @@
   __pyx_v_oshape = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_oscale = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":802 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":802 */
   __pyx_v_fshape = PyFloat_AsDouble(__pyx_v_shape);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":803 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":803 */
   __pyx_v_fscale = PyFloat_AsDouble(__pyx_v_scale);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":804 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":804 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":805 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":805 */
     __pyx_1 = (__pyx_v_fshape <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":806 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 806; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 806; goto __pyx_L1;}
       Py_INCREF(__pyx_k83p);
@@ -3668,11 +3573,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":807 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":807 */
     __pyx_1 = (__pyx_v_fscale <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":808 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 808; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 808; goto __pyx_L1;}
       Py_INCREF(__pyx_k84p);
@@ -3687,7 +3590,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":809 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":809 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_gamma,__pyx_v_size,__pyx_v_fshape,__pyx_v_fscale); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -3696,24 +3599,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":811 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":811 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":812 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":812 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_shape,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 812; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oshape));
   __pyx_v_oshape = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":813 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":813 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_scale,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 813; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_oscale));
   __pyx_v_oscale = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":814 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":814 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 814; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 814; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -3738,8 +3641,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 814; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":815 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 815; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 815; goto __pyx_L1;}
     Py_INCREF(__pyx_k85p);
@@ -3754,7 +3655,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":816 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":816 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 816; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 816; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -3779,8 +3680,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_3); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 816; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":817 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 817; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 817; goto __pyx_L1;}
     Py_INCREF(__pyx_k86p);
@@ -3795,7 +3694,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":818 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":818 */
   __pyx_3 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_gamma,__pyx_v_size,__pyx_v_oshape,__pyx_v_oscale); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 818; goto __pyx_L1;}
   __pyx_r = __pyx_3;
   __pyx_3 = 0;
@@ -3825,10 +3724,10 @@
 static PyObject *__pyx_k89p;
 static PyObject *__pyx_k90p;
 
-static char (__pyx_k87[]) = "shape <= 0";
-static char (__pyx_k88[]) = "scale <= 0";
-static char (__pyx_k89[]) = "dfnum <= 0";
-static char (__pyx_k90[]) = "dfden <= 0";
+static char __pyx_k87[] = "shape <= 0";
+static char __pyx_k88[] = "scale <= 0";
+static char __pyx_k89[] = "dfnum <= 0";
+static char __pyx_k90[] = "dfden <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_f(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_f[] = "F distribution.\n\n        f(dfnum, dfden, size=None) -> random values\n        ";
@@ -3856,21 +3755,19 @@
   __pyx_v_odfnum = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_odfden = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":828 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":828 */
   __pyx_v_fdfnum = PyFloat_AsDouble(__pyx_v_dfnum);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":829 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":829 */
   __pyx_v_fdfden = PyFloat_AsDouble(__pyx_v_dfden);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":830 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":830 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":831 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":831 */
     __pyx_1 = (__pyx_v_fdfnum <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":832 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 832; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 832; goto __pyx_L1;}
       Py_INCREF(__pyx_k87p);
@@ -3885,11 +3782,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":833 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":833 */
     __pyx_1 = (__pyx_v_fdfden <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":834 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; goto __pyx_L1;}
       Py_INCREF(__pyx_k88p);
@@ -3904,7 +3799,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":835 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":835 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_f,__pyx_v_size,__pyx_v_fdfnum,__pyx_v_fdfden); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 835; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -3913,24 +3808,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":837 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":837 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":839 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":839 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_dfnum,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_odfnum));
   __pyx_v_odfnum = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":840 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":840 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_dfden,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 840; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_odfden));
   __pyx_v_odfden = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":841 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":841 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 841; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 841; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -3955,8 +3850,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 841; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":842 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 842; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 842; goto __pyx_L1;}
     Py_INCREF(__pyx_k89p);
@@ -3971,7 +3864,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":843 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":843 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -3996,8 +3889,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_3); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":844 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 844; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 844; goto __pyx_L1;}
     Py_INCREF(__pyx_k90p);
@@ -4012,7 +3903,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":845 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":845 */
   __pyx_3 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_f,__pyx_v_size,__pyx_v_odfnum,__pyx_v_odfden); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 845; goto __pyx_L1;}
   __pyx_r = __pyx_3;
   __pyx_3 = 0;
@@ -4046,12 +3937,12 @@
 static PyObject *__pyx_k95p;
 static PyObject *__pyx_k96p;
 
-static char (__pyx_k91[]) = "dfnum <= 1";
-static char (__pyx_k92[]) = "dfden <= 0";
-static char (__pyx_k93[]) = "nonc < 0";
-static char (__pyx_k94[]) = "dfnum <= 1";
-static char (__pyx_k95[]) = "dfden <= 0";
-static char (__pyx_k96[]) = "nonc < 0";
+static char __pyx_k91[] = "dfnum <= 1";
+static char __pyx_k92[] = "dfden <= 0";
+static char __pyx_k93[] = "nonc < 0";
+static char __pyx_k94[] = "dfnum <= 1";
+static char __pyx_k95[] = "dfden <= 0";
+static char __pyx_k96[] = "nonc < 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_noncentral_f(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_noncentral_f[] = "Noncentral F distribution.\n\n        noncentral_f(dfnum, dfden, nonc, size=None) -> random values\n        ";
@@ -4084,24 +3975,22 @@
   __pyx_v_odfden = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_ononc = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":855 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":855 */
   __pyx_v_fdfnum = PyFloat_AsDouble(__pyx_v_dfnum);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":856 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":856 */
   __pyx_v_fdfden = PyFloat_AsDouble(__pyx_v_dfden);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":857 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":857 */
   __pyx_v_fnonc = PyFloat_AsDouble(__pyx_v_nonc);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":858 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":858 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":859 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":859 */
     __pyx_1 = (__pyx_v_fdfnum <= 1);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":860 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 860; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 860; goto __pyx_L1;}
       Py_INCREF(__pyx_k91p);
@@ -4116,11 +4005,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":861 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":861 */
     __pyx_1 = (__pyx_v_fdfden <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":862 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 862; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 862; goto __pyx_L1;}
       Py_INCREF(__pyx_k92p);
@@ -4135,11 +4022,9 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":863 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":863 */
     __pyx_1 = (__pyx_v_fnonc < 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":864 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; goto __pyx_L1;}
       Py_INCREF(__pyx_k93p);
@@ -4154,7 +4039,7 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":865 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":865 */
     __pyx_2 = __pyx_f_6mtrand_cont3_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_noncentral_f,__pyx_v_size,__pyx_v_fdfnum,__pyx_v_fdfden,__pyx_v_fnonc); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 865; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -4163,31 +4048,31 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":868 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":868 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":870 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":870 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_dfnum,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_odfnum));
   __pyx_v_odfnum = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":871 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":871 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_dfden,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_odfden));
   __pyx_v_odfden = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":872 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":872 */
   __pyx_2 = PyArray_FROM_OTF(__pyx_v_nonc,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 872; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
   Py_DECREF(((PyObject *)__pyx_v_ononc));
   __pyx_v_ononc = ((PyArrayObject *)__pyx_2);
   Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":874 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":874 */
   __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 874; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_3, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 874; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
@@ -4212,8 +4097,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 874; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":875 */
     __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; goto __pyx_L1;}
     Py_INCREF(__pyx_k94p);
@@ -4228,7 +4111,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":876 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":876 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -4253,8 +4136,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_4); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":877 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 877; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 877; goto __pyx_L1;}
     Py_INCREF(__pyx_k95p);
@@ -4269,7 +4150,7 @@
   }
   __pyx_L7:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":878 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":878 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; goto __pyx_L1;}
   __pyx_5 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -4294,8 +4175,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_2); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":879 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 879; goto __pyx_L1;}
     __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 879; goto __pyx_L1;}
     Py_INCREF(__pyx_k96p);
@@ -4310,7 +4189,7 @@
   }
   __pyx_L8:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":880 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":880 */
   __pyx_2 = __pyx_f_6mtrand_cont3_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_noncentral_f,__pyx_v_size,__pyx_v_odfnum,__pyx_v_odfden,__pyx_v_ononc); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 880; goto __pyx_L1;}
   __pyx_r = __pyx_2;
   __pyx_2 = 0;
@@ -4340,8 +4219,8 @@
 static PyObject *__pyx_k97p;
 static PyObject *__pyx_k98p;
 
-static char (__pyx_k97[]) = "df <= 0";
-static char (__pyx_k98[]) = "df <= 0";
+static char __pyx_k97[] = "df <= 0";
+static char __pyx_k98[] = "df <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_chisquare(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_chisquare[] = "Chi^2 distribution.\n\n        chisquare(df, size=None) -> random values\n        ";
@@ -4364,18 +4243,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_odf = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":891 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":891 */
   __pyx_v_fdf = PyFloat_AsDouble(__pyx_v_df);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":892 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":892 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":893 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":893 */
     __pyx_1 = (__pyx_v_fdf <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":894 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; goto __pyx_L1;}
       Py_INCREF(__pyx_k97p);
@@ -4390,7 +4267,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":895 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":895 */
     __pyx_2 = __pyx_f_6mtrand_cont1_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_chisquare,__pyx_v_size,__pyx_v_fdf); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 895; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -4399,17 +4276,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":897 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":897 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":899 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":899 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_df,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 899; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_odf));
   __pyx_v_odf = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":900 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":900 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 900; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 900; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -4434,8 +4311,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 900; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":901 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 901; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 901; goto __pyx_L1;}
     Py_INCREF(__pyx_k98p);
@@ -4450,7 +4325,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":902 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":902 */
   __pyx_5 = __pyx_f_6mtrand_cont1_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_chisquare,__pyx_v_size,__pyx_v_odf); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 902; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -4478,10 +4353,10 @@
 static PyObject *__pyx_k101p;
 static PyObject *__pyx_k102p;
 
-static char (__pyx_k99[]) = "df <= 0";
-static char (__pyx_k100[]) = "nonc <= 0";
-static char (__pyx_k101[]) = "df <= 1";
-static char (__pyx_k102[]) = "nonc < 0";
+static char __pyx_k99[] = "df <= 0";
+static char __pyx_k100[] = "nonc <= 0";
+static char __pyx_k101[] = "df <= 1";
+static char __pyx_k102[] = "nonc < 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_noncentral_chisquare(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_noncentral_chisquare[] = "Noncentral Chi^2 distribution.\n\n        noncentral_chisquare(df, nonc, size=None) -> random values\n        ";
@@ -4509,21 +4384,19 @@
   __pyx_v_odf = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_ononc = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":911 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":911 */
   __pyx_v_fdf = PyFloat_AsDouble(__pyx_v_df);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":912 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":912 */
   __pyx_v_fnonc = PyFloat_AsDouble(__pyx_v_nonc);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":913 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":913 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":914 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":914 */
     __pyx_1 = (__pyx_v_fdf <= 1);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":915 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 915; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 915; goto __pyx_L1;}
       Py_INCREF(__pyx_k99p);
@@ -4538,11 +4411,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":916 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":916 */
     __pyx_1 = (__pyx_v_fnonc <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":917 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; goto __pyx_L1;}
       Py_INCREF(__pyx_k100p);
@@ -4557,7 +4428,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":918 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":918 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_noncentral_chisquare,__pyx_v_size,__pyx_v_fdf,__pyx_v_fnonc); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 918; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -4566,24 +4437,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":921 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":921 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":923 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":923 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_df,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_odf));
   __pyx_v_odf = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":924 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":924 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_nonc,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 924; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_ononc));
   __pyx_v_ononc = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":925 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":925 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 925; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 925; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -4608,8 +4479,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 925; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":926 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; goto __pyx_L1;}
     Py_INCREF(__pyx_k101p);
@@ -4624,7 +4493,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":927 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":927 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -4649,8 +4518,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_3); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":928 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; goto __pyx_L1;}
     Py_INCREF(__pyx_k102p);
@@ -4665,7 +4532,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":929 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":929 */
   __pyx_3 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_noncentral_chisquare,__pyx_v_size,__pyx_v_odf,__pyx_v_ononc); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; goto __pyx_L1;}
   __pyx_r = __pyx_3;
   __pyx_3 = 0;
@@ -4701,8 +4568,6 @@
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "|O", __pyx_argnames, &__pyx_v_size)) return 0;
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_size);
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":937 */
   __pyx_1 = __pyx_f_6mtrand_cont0_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_standard_cauchy,__pyx_v_size); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; goto __pyx_L1;}
   __pyx_r = __pyx_1;
   __pyx_1 = 0;
@@ -4723,8 +4588,8 @@
 static PyObject *__pyx_k103p;
 static PyObject *__pyx_k104p;
 
-static char (__pyx_k103[]) = "df <= 0";
-static char (__pyx_k104[]) = "df <= 0";
+static char __pyx_k103[] = "df <= 0";
+static char __pyx_k104[] = "df <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_standard_t(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_standard_t[] = "Standard Student\'s t distribution with df degrees of freedom.\n\n        standard_t(df, size=None)\n        ";
@@ -4747,18 +4612,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_odf = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":947 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":947 */
   __pyx_v_fdf = PyFloat_AsDouble(__pyx_v_df);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":948 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":948 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":949 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":949 */
     __pyx_1 = (__pyx_v_fdf <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":950 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 950; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 950; goto __pyx_L1;}
       Py_INCREF(__pyx_k103p);
@@ -4773,7 +4636,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":951 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":951 */
     __pyx_2 = __pyx_f_6mtrand_cont1_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_standard_t,__pyx_v_size,__pyx_v_fdf); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 951; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -4782,17 +4645,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":953 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":953 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":955 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":955 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_df,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 955; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_odf));
   __pyx_v_odf = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":956 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":956 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 956; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 956; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -4817,8 +4680,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 956; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":957 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 957; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 957; goto __pyx_L1;}
     Py_INCREF(__pyx_k104p);
@@ -4833,7 +4694,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":958 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":958 */
   __pyx_5 = __pyx_f_6mtrand_cont1_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_standard_t,__pyx_v_size,__pyx_v_odf); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 958; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -4859,8 +4720,8 @@
 static PyObject *__pyx_k105p;
 static PyObject *__pyx_k106p;
 
-static char (__pyx_k105[]) = "kappa < 0";
-static char (__pyx_k106[]) = "kappa < 0";
+static char __pyx_k105[] = "kappa < 0";
+static char __pyx_k106[] = "kappa < 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_vonmises(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_vonmises[] = "von Mises circular distribution with mode mu and dispersion parameter\n        kappa on [-pi, pi].\n\n        vonmises(mu, kappa, size=None)\n        ";
@@ -4888,21 +4749,19 @@
   __pyx_v_omu = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_okappa = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":969 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":969 */
   __pyx_v_fmu = PyFloat_AsDouble(__pyx_v_mu);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":970 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":970 */
   __pyx_v_fkappa = PyFloat_AsDouble(__pyx_v_kappa);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":971 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":971 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":972 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":972 */
     __pyx_1 = (__pyx_v_fkappa < 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":973 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; goto __pyx_L1;}
       Py_INCREF(__pyx_k105p);
@@ -4917,7 +4776,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":974 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":974 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_vonmises,__pyx_v_size,__pyx_v_fmu,__pyx_v_fkappa); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -4926,24 +4785,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":976 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":976 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":978 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":978 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_mu,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 978; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_omu));
   __pyx_v_omu = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":979 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":979 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_kappa,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_okappa));
   __pyx_v_okappa = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":980 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":980 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -4968,8 +4827,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":981 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; goto __pyx_L1;}
     Py_INCREF(__pyx_k106p);
@@ -4984,7 +4841,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":982 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":982 */
   __pyx_5 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_vonmises,__pyx_v_size,__pyx_v_omu,__pyx_v_okappa); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 982; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -5012,8 +4869,8 @@
 static PyObject *__pyx_k107p;
 static PyObject *__pyx_k108p;
 
-static char (__pyx_k107[]) = "a <= 0";
-static char (__pyx_k108[]) = "a <= 0";
+static char __pyx_k107[] = "a <= 0";
+static char __pyx_k108[] = "a <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_pareto(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_pareto[] = "Pareto distribution.\n\n        pareto(a, size=None)\n        ";
@@ -5036,18 +4893,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_oa = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":992 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":992 */
   __pyx_v_fa = PyFloat_AsDouble(__pyx_v_a);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":993 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":993 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":994 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":994 */
     __pyx_1 = (__pyx_v_fa <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":995 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; goto __pyx_L1;}
       Py_INCREF(__pyx_k107p);
@@ -5062,7 +4917,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":996 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":996 */
     __pyx_2 = __pyx_f_6mtrand_cont1_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_pareto,__pyx_v_size,__pyx_v_fa); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 996; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -5071,17 +4926,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":998 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":998 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1000 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1000 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_a,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oa));
   __pyx_v_oa = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1001 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1001 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1001; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1001; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -5106,8 +4961,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1001; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1002 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; goto __pyx_L1;}
     Py_INCREF(__pyx_k108p);
@@ -5122,7 +4975,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1003 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1003 */
   __pyx_5 = __pyx_f_6mtrand_cont1_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_pareto,__pyx_v_size,__pyx_v_oa); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1003; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -5148,8 +5001,8 @@
 static PyObject *__pyx_k109p;
 static PyObject *__pyx_k110p;
 
-static char (__pyx_k109[]) = "a <= 0";
-static char (__pyx_k110[]) = "a <= 0";
+static char __pyx_k109[] = "a <= 0";
+static char __pyx_k110[] = "a <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_weibull(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_weibull[] = "Weibull distribution.\n\n        weibull(a, size=None)\n        ";
@@ -5172,18 +5025,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_oa = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1013 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1013 */
   __pyx_v_fa = PyFloat_AsDouble(__pyx_v_a);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1014 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1014 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1015 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1015 */
     __pyx_1 = (__pyx_v_fa <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1016 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1016; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1016; goto __pyx_L1;}
       Py_INCREF(__pyx_k109p);
@@ -5198,7 +5049,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1017 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1017 */
     __pyx_2 = __pyx_f_6mtrand_cont1_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_weibull,__pyx_v_size,__pyx_v_fa); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1017; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -5207,17 +5058,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1019 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1019 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1021 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1021 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_a,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1021; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oa));
   __pyx_v_oa = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1022 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1022 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -5242,8 +5093,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1023 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; goto __pyx_L1;}
     Py_INCREF(__pyx_k110p);
@@ -5258,7 +5107,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1024 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1024 */
   __pyx_5 = __pyx_f_6mtrand_cont1_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_weibull,__pyx_v_size,__pyx_v_oa); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1024; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -5284,8 +5133,8 @@
 static PyObject *__pyx_k111p;
 static PyObject *__pyx_k112p;
 
-static char (__pyx_k111[]) = "a <= 0";
-static char (__pyx_k112[]) = "a <= 0";
+static char __pyx_k111[] = "a <= 0";
+static char __pyx_k112[] = "a <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_power(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_power[] = "Power distribution.\n\n        power(a, size=None)\n        ";
@@ -5308,18 +5157,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_oa = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1034 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1034 */
   __pyx_v_fa = PyFloat_AsDouble(__pyx_v_a);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1035 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1035 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1036 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1036 */
     __pyx_1 = (__pyx_v_fa <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1037 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; goto __pyx_L1;}
       Py_INCREF(__pyx_k111p);
@@ -5334,7 +5181,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1038 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1038 */
     __pyx_2 = __pyx_f_6mtrand_cont1_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_power,__pyx_v_size,__pyx_v_fa); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1038; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -5343,17 +5190,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1040 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1040 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1042 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1042 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_a,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1042; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oa));
   __pyx_v_oa = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1043 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1043 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1043; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1043; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -5378,8 +5225,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1043; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1044 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; goto __pyx_L1;}
     Py_INCREF(__pyx_k112p);
@@ -5394,7 +5239,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1045 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1045 */
   __pyx_5 = __pyx_f_6mtrand_cont1_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_power,__pyx_v_size,__pyx_v_oa); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1045; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -5420,8 +5265,8 @@
 static PyObject *__pyx_k113p;
 static PyObject *__pyx_k114p;
 
-static char (__pyx_k113[]) = "scale <= 0";
-static char (__pyx_k114[]) = "scale <= 0";
+static char __pyx_k113[] = "scale <= 0";
+static char __pyx_k114[] = "scale <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_laplace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_laplace[] = "Laplace distribution.\n        \n        laplace(loc=0.0, scale=1.0, size=None)\n        ";
@@ -5451,21 +5296,19 @@
   __pyx_v_oloc = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_oscale = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1055 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1055 */
   __pyx_v_floc = PyFloat_AsDouble(__pyx_v_loc);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1056 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1056 */
   __pyx_v_fscale = PyFloat_AsDouble(__pyx_v_scale);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1057 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1057 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1058 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1058 */
     __pyx_1 = (__pyx_v_fscale <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1059 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1059; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1059; goto __pyx_L1;}
       Py_INCREF(__pyx_k113p);
@@ -5480,7 +5323,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1060 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1060 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_laplace,__pyx_v_size,__pyx_v_floc,__pyx_v_fscale); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1060; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -5489,24 +5332,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1062 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1062 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1063 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1063 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_loc,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1063; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_3, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1063; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_oloc));
   __pyx_v_oloc = ((PyArrayObject *)__pyx_3);
   __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1064 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1064 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_scale,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1064; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_4, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1064; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_oscale));
   __pyx_v_oscale = ((PyArrayObject *)__pyx_4);
   __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1065 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1065 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1065; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1065; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -5531,8 +5374,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1065; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1066 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1066; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1066; goto __pyx_L1;}
     Py_INCREF(__pyx_k114p);
@@ -5547,7 +5388,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1067 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1067 */
   __pyx_5 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_laplace,__pyx_v_size,__pyx_v_oloc,__pyx_v_oscale); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1067; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -5575,8 +5416,8 @@
 static PyObject *__pyx_k115p;
 static PyObject *__pyx_k116p;
 
-static char (__pyx_k115[]) = "scale <= 0";
-static char (__pyx_k116[]) = "scale <= 0";
+static char __pyx_k115[] = "scale <= 0";
+static char __pyx_k116[] = "scale <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_gumbel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_gumbel[] = "Gumbel distribution.\n        \n        gumbel(loc=0.0, scale=1.0, size=None)\n        ";
@@ -5606,21 +5447,19 @@
   __pyx_v_oloc = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_oscale = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1077 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1077 */
   __pyx_v_floc = PyFloat_AsDouble(__pyx_v_loc);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1078 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1078 */
   __pyx_v_fscale = PyFloat_AsDouble(__pyx_v_scale);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1079 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1079 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1080 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1080 */
     __pyx_1 = (__pyx_v_fscale <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1081 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1081; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1081; goto __pyx_L1;}
       Py_INCREF(__pyx_k115p);
@@ -5635,7 +5474,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1082 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1082 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_gumbel,__pyx_v_size,__pyx_v_floc,__pyx_v_fscale); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1082; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -5644,24 +5483,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1084 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1084 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1085 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1085 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_loc,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1085; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_3, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1085; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_oloc));
   __pyx_v_oloc = ((PyArrayObject *)__pyx_3);
   __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1086 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1086 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_scale,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1086; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_4, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1086; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_oscale));
   __pyx_v_oscale = ((PyArrayObject *)__pyx_4);
   __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1087 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1087 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1087; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1087; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -5686,8 +5525,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1087; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1088 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1088; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1088; goto __pyx_L1;}
     Py_INCREF(__pyx_k116p);
@@ -5702,7 +5539,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1089 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1089 */
   __pyx_5 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_gumbel,__pyx_v_size,__pyx_v_oloc,__pyx_v_oscale); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1089; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -5730,8 +5567,8 @@
 static PyObject *__pyx_k117p;
 static PyObject *__pyx_k118p;
 
-static char (__pyx_k117[]) = "scale <= 0";
-static char (__pyx_k118[]) = "scale <= 0";
+static char __pyx_k117[] = "scale <= 0";
+static char __pyx_k118[] = "scale <= 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_logistic(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_logistic[] = "Logistic distribution.\n        \n        logistic(loc=0.0, scale=1.0, size=None)\n        ";
@@ -5761,21 +5598,19 @@
   __pyx_v_oloc = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_oscale = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1099 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1099 */
   __pyx_v_floc = PyFloat_AsDouble(__pyx_v_loc);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1100 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1100 */
   __pyx_v_fscale = PyFloat_AsDouble(__pyx_v_scale);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1101 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1101 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1102 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1102 */
     __pyx_1 = (__pyx_v_fscale <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1103 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1103; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1103; goto __pyx_L1;}
       Py_INCREF(__pyx_k117p);
@@ -5790,7 +5625,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1104 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1104 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_logistic,__pyx_v_size,__pyx_v_floc,__pyx_v_fscale); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1104; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -5799,24 +5634,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1106 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1106 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1107 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1107 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_loc,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1107; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_3, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1107; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_oloc));
   __pyx_v_oloc = ((PyArrayObject *)__pyx_3);
   __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1108 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1108 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_scale,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1108; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_4, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1108; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_oscale));
   __pyx_v_oscale = ((PyArrayObject *)__pyx_4);
   __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1109 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1109 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1109; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1109; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -5841,8 +5676,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1109; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1110 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; goto __pyx_L1;}
     Py_INCREF(__pyx_k118p);
@@ -5857,7 +5690,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1111 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1111 */
   __pyx_5 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_logistic,__pyx_v_size,__pyx_v_oloc,__pyx_v_oscale); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1111; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -5885,8 +5718,8 @@
 static PyObject *__pyx_k119p;
 static PyObject *__pyx_k120p;
 
-static char (__pyx_k119[]) = "sigma <= 0";
-static char (__pyx_k120[]) = "sigma <= 0.0";
+static char __pyx_k119[] = "sigma <= 0";
+static char __pyx_k120[] = "sigma <= 0.0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_lognormal(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_lognormal[] = "Log-normal distribution.\n        \n        Note that the mean parameter is not the mean of this distribution, but \n        the underlying normal distribution.\n        \n            lognormal(mean, sigma) <=> exp(normal(mean, sigma))\n        \n        lognormal(mean=0.0, sigma=1.0, size=None)\n        ";
@@ -5916,21 +5749,19 @@
   __pyx_v_omean = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_osigma = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1126 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1126 */
   __pyx_v_fmean = PyFloat_AsDouble(__pyx_v_mean);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1127 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1127 */
   __pyx_v_fsigma = PyFloat_AsDouble(__pyx_v_sigma);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1129 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1129 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1130 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1130 */
     __pyx_1 = (__pyx_v_fsigma <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1131 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1131; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1131; goto __pyx_L1;}
       Py_INCREF(__pyx_k119p);
@@ -5945,7 +5776,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1132 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1132 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_lognormal,__pyx_v_size,__pyx_v_fmean,__pyx_v_fsigma); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1132; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -5954,24 +5785,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1134 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1134 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1136 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1136 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_mean,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1136; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_3, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1136; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_omean));
   __pyx_v_omean = ((PyArrayObject *)__pyx_3);
   __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1137 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1137 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_sigma,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1137; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_4, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1137; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_osigma));
   __pyx_v_osigma = ((PyArrayObject *)__pyx_4);
   __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1138 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1138 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1138; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1138; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -5996,8 +5827,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1138; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1139 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1139; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1139; goto __pyx_L1;}
     Py_INCREF(__pyx_k120p);
@@ -6012,7 +5841,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1140 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1140 */
   __pyx_5 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_lognormal,__pyx_v_size,__pyx_v_omean,__pyx_v_osigma); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1140; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -6040,8 +5869,8 @@
 static PyObject *__pyx_k121p;
 static PyObject *__pyx_k122p;
 
-static char (__pyx_k121[]) = "scale <= 0";
-static char (__pyx_k122[]) = "scale <= 0.0";
+static char __pyx_k121[] = "scale <= 0";
+static char __pyx_k122[] = "scale <= 0.0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_rayleigh(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_rayleigh[] = "Rayleigh distribution.\n        \n        rayleigh(scale=1.0, size=None)\n        ";
@@ -6065,18 +5894,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_oscale = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1150 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1150 */
   __pyx_v_fscale = PyFloat_AsDouble(__pyx_v_scale);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1152 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1152 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1153 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1153 */
     __pyx_1 = (__pyx_v_fscale <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1154 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1154; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1154; goto __pyx_L1;}
       Py_INCREF(__pyx_k121p);
@@ -6091,7 +5918,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1155 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1155 */
     __pyx_2 = __pyx_f_6mtrand_cont1_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_rayleigh,__pyx_v_size,__pyx_v_fscale); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1155; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -6100,17 +5927,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1157 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1157 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1159 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1159 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_scale,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1159; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oscale));
   __pyx_v_oscale = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1160 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1160 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1160; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1160; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -6135,8 +5962,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1160; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1161 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1161; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1161; goto __pyx_L1;}
     Py_INCREF(__pyx_k122p);
@@ -6151,7 +5976,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1162 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1162 */
   __pyx_5 = __pyx_f_6mtrand_cont1_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_rayleigh,__pyx_v_size,__pyx_v_oscale); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1162; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -6179,10 +6004,10 @@
 static PyObject *__pyx_k125p;
 static PyObject *__pyx_k126p;
 
-static char (__pyx_k123[]) = "mean <= 0";
-static char (__pyx_k124[]) = "scale <= 0";
-static char (__pyx_k125[]) = "mean <= 0.0";
-static char (__pyx_k126[]) = "scale <= 0.0";
+static char __pyx_k123[] = "mean <= 0";
+static char __pyx_k124[] = "scale <= 0";
+static char __pyx_k125[] = "mean <= 0.0";
+static char __pyx_k126[] = "scale <= 0.0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_wald(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_wald[] = "Wald (inverse Gaussian) distribution.\n        \n        wald(mean, scale, size=None)\n        ";
@@ -6210,21 +6035,19 @@
   __pyx_v_omean = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_oscale = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1172 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1172 */
   __pyx_v_fmean = PyFloat_AsDouble(__pyx_v_mean);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1173 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1173 */
   __pyx_v_fscale = PyFloat_AsDouble(__pyx_v_scale);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1174 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1174 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1175 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1175 */
     __pyx_1 = (__pyx_v_fmean <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1176 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1176; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1176; goto __pyx_L1;}
       Py_INCREF(__pyx_k123p);
@@ -6239,11 +6062,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1177 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1177 */
     __pyx_1 = (__pyx_v_fscale <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1178 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1178; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1178; goto __pyx_L1;}
       Py_INCREF(__pyx_k124p);
@@ -6258,7 +6079,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1179 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1179 */
     __pyx_2 = __pyx_f_6mtrand_cont2_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_wald,__pyx_v_size,__pyx_v_fmean,__pyx_v_fscale); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1179; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -6267,24 +6088,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1181 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1181 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1182 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1182 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_mean,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1182; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_3, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1182; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_omean));
   __pyx_v_omean = ((PyArrayObject *)__pyx_3);
   __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1183 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1183 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_scale,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1183; goto __pyx_L1;}
   if (!__Pyx_TypeTest(__pyx_4, __pyx_ptype_6mtrand_ndarray)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1183; goto __pyx_L1;}
   Py_DECREF(((PyObject *)__pyx_v_oscale));
   __pyx_v_oscale = ((PyArrayObject *)__pyx_4);
   __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1184 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1184 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1184; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1184; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -6309,8 +6130,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1184; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1185 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1185; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1185; goto __pyx_L1;}
     Py_INCREF(__pyx_k125p);
@@ -6347,8 +6166,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_3); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1186; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1187 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1187; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1187; goto __pyx_L1;}
     Py_INCREF(__pyx_k126p);
@@ -6363,7 +6180,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1188 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1188 */
   __pyx_3 = __pyx_f_6mtrand_cont2_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_wald,__pyx_v_size,__pyx_v_omean,__pyx_v_oscale); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1188; goto __pyx_L1;}
   __pyx_r = __pyx_3;
   __pyx_3 = 0;
@@ -6398,12 +6215,12 @@
 static PyObject *__pyx_k131p;
 static PyObject *__pyx_k132p;
 
-static char (__pyx_k127[]) = "left > mode";
-static char (__pyx_k128[]) = "mode > right";
-static char (__pyx_k129[]) = "left == right";
-static char (__pyx_k130[]) = "left > mode";
-static char (__pyx_k131[]) = "mode > right";
-static char (__pyx_k132[]) = "left == right";
+static char __pyx_k127[] = "left > mode";
+static char __pyx_k128[] = "mode > right";
+static char __pyx_k129[] = "left == right";
+static char __pyx_k130[] = "left > mode";
+static char __pyx_k131[] = "mode > right";
+static char __pyx_k132[] = "left == right";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_triangular(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_triangular[] = "Triangular distribution starting at left, peaking at mode, and \n        ending at right (left <= mode <= right).\n        \n        triangular(left, mode, right, size=None)\n        ";
@@ -6436,24 +6253,22 @@
   __pyx_v_omode = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_oright = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1201 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1201 */
   __pyx_v_fleft = PyFloat_AsDouble(__pyx_v_left);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1202 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1202 */
   __pyx_v_fright = PyFloat_AsDouble(__pyx_v_right);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1203 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1203 */
   __pyx_v_fmode = PyFloat_AsDouble(__pyx_v_mode);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1204 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1204 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1205 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1205 */
     __pyx_1 = (__pyx_v_fleft > __pyx_v_fmode);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1206 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1206; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1206; goto __pyx_L1;}
       Py_INCREF(__pyx_k127p);
@@ -6468,11 +6283,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1207 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1207 */
     __pyx_1 = (__pyx_v_fmode > __pyx_v_fright);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1208 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1208; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1208; goto __pyx_L1;}
       Py_INCREF(__pyx_k128p);
@@ -6487,11 +6300,9 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1209 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1209 */
     __pyx_1 = (__pyx_v_fleft == __pyx_v_fright);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1210 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; goto __pyx_L1;}
       Py_INCREF(__pyx_k129p);
@@ -6506,7 +6317,7 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1211 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1211 */
     __pyx_2 = __pyx_f_6mtrand_cont3_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_triangular,__pyx_v_size,__pyx_v_fleft,__pyx_v_fmode,__pyx_v_fright); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1211; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -6515,31 +6326,31 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1214 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1214 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1215 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1215 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_left,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oleft));
   __pyx_v_oleft = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1216 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1216 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_mode,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1216; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_omode));
   __pyx_v_omode = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1217 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1217 */
   __pyx_2 = PyArray_FROM_OTF(__pyx_v_right,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1217; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
   Py_DECREF(((PyObject *)__pyx_v_oright));
   __pyx_v_oright = ((PyArrayObject *)__pyx_2);
   Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1219 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1219 */
   __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1219; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_3, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1219; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
@@ -6563,8 +6374,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_2); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1219; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1220 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1220; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1220; goto __pyx_L1;}
     Py_INCREF(__pyx_k130p);
@@ -6579,7 +6388,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1221 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1221 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1221; goto __pyx_L1;}
   __pyx_5 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1221; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -6603,8 +6412,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_2); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1221; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1222 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1222; goto __pyx_L1;}
     __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1222; goto __pyx_L1;}
     Py_INCREF(__pyx_k131p);
@@ -6619,7 +6426,7 @@
   }
   __pyx_L7:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1223 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1223 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1223; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1223; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -6643,8 +6450,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_2); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1223; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1224 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1224; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1224; goto __pyx_L1;}
     Py_INCREF(__pyx_k132p);
@@ -6659,7 +6464,7 @@
   }
   __pyx_L8:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1225 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1225 */
   __pyx_2 = __pyx_f_6mtrand_cont3_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_triangular,__pyx_v_size,__pyx_v_oleft,__pyx_v_omode,__pyx_v_oright); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1225; goto __pyx_L1;}
   __pyx_r = __pyx_2;
   __pyx_2 = 0;
@@ -6693,12 +6498,12 @@
 static PyObject *__pyx_k137p;
 static PyObject *__pyx_k138p;
 
-static char (__pyx_k133[]) = "n <= 0";
-static char (__pyx_k134[]) = "p < 0";
-static char (__pyx_k135[]) = "p > 1";
-static char (__pyx_k136[]) = "n <= 0";
-static char (__pyx_k137[]) = "p < 0";
-static char (__pyx_k138[]) = "p > 1";
+static char __pyx_k133[] = "n <= 0";
+static char __pyx_k134[] = "p < 0";
+static char __pyx_k135[] = "p > 1";
+static char __pyx_k136[] = "n <= 0";
+static char __pyx_k137[] = "p < 0";
+static char __pyx_k138[] = "p > 1";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_binomial(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_binomial[] = "Binomial distribution of n trials and p probability of success.\n\n        binomial(n, p, size=None) -> random values\n        ";
@@ -6726,21 +6531,19 @@
   __pyx_v_on = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_op = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1238 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1238 */
   __pyx_v_fp = PyFloat_AsDouble(__pyx_v_p);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1239 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1239 */
   __pyx_v_ln = PyInt_AsLong(__pyx_v_n);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1240 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1240 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1241 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1241 */
     __pyx_1 = (__pyx_v_ln <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1242 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1242; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1242; goto __pyx_L1;}
       Py_INCREF(__pyx_k133p);
@@ -6755,11 +6558,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1243 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1243 */
     __pyx_1 = (__pyx_v_fp < 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1244 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1244; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1244; goto __pyx_L1;}
       Py_INCREF(__pyx_k134p);
@@ -6774,8 +6575,6 @@
     }
     __pyx_1 = (__pyx_v_fp > 1);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1246 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1246; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1246; goto __pyx_L1;}
       Py_INCREF(__pyx_k135p);
@@ -6790,7 +6589,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1247 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1247 */
     __pyx_2 = __pyx_f_6mtrand_discnp_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_binomial,__pyx_v_size,__pyx_v_ln,__pyx_v_fp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1247; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -6799,24 +6598,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1249 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1249 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1251 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1251 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_n,NPY_LONG,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1251; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_on));
   __pyx_v_on = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1252 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1252 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_p,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1252; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_op));
   __pyx_v_op = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1253 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1253 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1253; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1253; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -6841,8 +6640,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1253; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1254 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1254; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1254; goto __pyx_L1;}
     Py_INCREF(__pyx_k136p);
@@ -6857,7 +6654,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1255 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1255 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1255; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1255; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -6882,8 +6679,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_3); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1255; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1256 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1256; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1256; goto __pyx_L1;}
     Py_INCREF(__pyx_k137p);
@@ -6898,7 +6693,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1257 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1257 */
   __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1257; goto __pyx_L1;}
   __pyx_5 = PyObject_GetAttr(__pyx_3, __pyx_n_any); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1257; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
@@ -6923,8 +6718,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_4); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1257; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1258 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1258; goto __pyx_L1;}
     __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1258; goto __pyx_L1;}
     Py_INCREF(__pyx_k138p);
@@ -6939,7 +6732,7 @@
   }
   __pyx_L7:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1259 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1259 */
   __pyx_4 = __pyx_f_6mtrand_discnp_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_binomial,__pyx_v_size,__pyx_v_on,__pyx_v_op); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1259; goto __pyx_L1;}
   __pyx_r = __pyx_4;
   __pyx_4 = 0;
@@ -6971,12 +6764,12 @@
 static PyObject *__pyx_k143p;
 static PyObject *__pyx_k144p;
 
-static char (__pyx_k139[]) = "n <= 0";
-static char (__pyx_k140[]) = "p < 0";
-static char (__pyx_k141[]) = "p > 1";
-static char (__pyx_k142[]) = "n <= 0";
-static char (__pyx_k143[]) = "p < 0";
-static char (__pyx_k144[]) = "p > 1";
+static char __pyx_k139[] = "n <= 0";
+static char __pyx_k140[] = "p < 0";
+static char __pyx_k141[] = "p > 1";
+static char __pyx_k142[] = "n <= 0";
+static char __pyx_k143[] = "p < 0";
+static char __pyx_k144[] = "p > 1";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_negative_binomial(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_negative_binomial[] = "Negative Binomial distribution.\n\n        negative_binomial(n, p, size=None) -> random values\n        ";
@@ -7004,21 +6797,19 @@
   __pyx_v_on = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_op = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1271 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1271 */
   __pyx_v_fp = PyFloat_AsDouble(__pyx_v_p);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1272 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1272 */
   __pyx_v_ln = PyInt_AsLong(__pyx_v_n);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1273 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1273 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1274 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1274 */
     __pyx_1 = (__pyx_v_ln <= 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1275 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1275; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1275; goto __pyx_L1;}
       Py_INCREF(__pyx_k139p);
@@ -7033,11 +6824,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1276 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1276 */
     __pyx_1 = (__pyx_v_fp < 0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1277 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1277; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1277; goto __pyx_L1;}
       Py_INCREF(__pyx_k140p);
@@ -7052,8 +6841,6 @@
     }
     __pyx_1 = (__pyx_v_fp > 1);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1279 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1279; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1279; goto __pyx_L1;}
       Py_INCREF(__pyx_k141p);
@@ -7068,7 +6855,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1280 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1280 */
     __pyx_2 = __pyx_f_6mtrand_discnp_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_negative_binomial,__pyx_v_size,__pyx_v_ln,__pyx_v_fp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1280; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -7077,24 +6864,24 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1283 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1283 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1285 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1285 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_n,NPY_LONG,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1285; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_on));
   __pyx_v_on = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1286 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1286 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_p,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1286; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_op));
   __pyx_v_op = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1287 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1287 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1287; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1287; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -7119,8 +6906,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1287; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1288 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1288; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1288; goto __pyx_L1;}
     Py_INCREF(__pyx_k142p);
@@ -7135,7 +6920,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1289 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1289 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1289; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1289; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -7160,8 +6945,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_3); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1289; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1290 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1290; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1290; goto __pyx_L1;}
     Py_INCREF(__pyx_k143p);
@@ -7176,7 +6959,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1291 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1291 */
   __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1291; goto __pyx_L1;}
   __pyx_5 = PyObject_GetAttr(__pyx_3, __pyx_n_any); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1291; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
@@ -7201,8 +6984,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_4); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1291; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1292 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1292; goto __pyx_L1;}
     __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1292; goto __pyx_L1;}
     Py_INCREF(__pyx_k144p);
@@ -7217,7 +6998,7 @@
   }
   __pyx_L7:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1293 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1293 */
   __pyx_4 = __pyx_f_6mtrand_discnp_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_negative_binomial,__pyx_v_size,__pyx_v_on,__pyx_v_op); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1293; goto __pyx_L1;}
   __pyx_r = __pyx_4;
   __pyx_4 = 0;
@@ -7245,8 +7026,8 @@
 static PyObject *__pyx_k145p;
 static PyObject *__pyx_k146p;
 
-static char (__pyx_k145[]) = "lam < 0";
-static char (__pyx_k146[]) = "lam < 0";
+static char __pyx_k145[] = "lam < 0";
+static char __pyx_k146[] = "lam < 0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_poisson(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_poisson[] = "Poisson distribution.\n\n        poisson(lam=1.0, size=None) -> random values\n        ";
@@ -7270,21 +7051,19 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_olam = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1303 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1303 */
   __pyx_v_flam = PyFloat_AsDouble(__pyx_v_lam);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1304 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1304 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1305 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1305 */
     __pyx_2 = PyInt_FromLong(0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1305; goto __pyx_L1;}
     if (PyObject_Cmp(__pyx_v_lam, __pyx_2, &__pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1305; goto __pyx_L1;}
     __pyx_1 = __pyx_1 < 0;
     Py_DECREF(__pyx_2); __pyx_2 = 0;
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1306 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1306; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1306; goto __pyx_L1;}
       Py_INCREF(__pyx_k145p);
@@ -7299,7 +7078,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1307 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1307 */
     __pyx_2 = __pyx_f_6mtrand_discd_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_poisson,__pyx_v_size,__pyx_v_flam); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1307; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -7308,17 +7087,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1309 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1309 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1311 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1311 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_lam,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1311; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_olam));
   __pyx_v_olam = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1312 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1312 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1312; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1312; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -7343,8 +7122,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1312; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1313 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; goto __pyx_L1;}
     Py_INCREF(__pyx_k146p);
@@ -7359,7 +7136,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1314 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1314 */
   __pyx_5 = __pyx_f_6mtrand_discd_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_poisson,__pyx_v_size,__pyx_v_olam); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1314; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -7385,8 +7162,8 @@
 static PyObject *__pyx_k147p;
 static PyObject *__pyx_k148p;
 
-static char (__pyx_k147[]) = "a <= 1.0";
-static char (__pyx_k148[]) = "a <= 1.0";
+static char __pyx_k147[] = "a <= 1.0";
+static char __pyx_k148[] = "a <= 1.0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_zipf(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_zipf[] = "Zipf distribution.\n        \n        zipf(a, size=None)\n        ";
@@ -7409,18 +7186,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_oa = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1324 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1324 */
   __pyx_v_fa = PyFloat_AsDouble(__pyx_v_a);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1325 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1325 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1326 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1326 */
     __pyx_1 = (__pyx_v_fa <= 1.0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1327 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1327; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1327; goto __pyx_L1;}
       Py_INCREF(__pyx_k147p);
@@ -7435,7 +7210,7 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1328 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1328 */
     __pyx_2 = __pyx_f_6mtrand_discd_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_zipf,__pyx_v_size,__pyx_v_fa); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1328; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -7444,17 +7219,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1330 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1330 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1332 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1332 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_a,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1332; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_oa));
   __pyx_v_oa = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1333 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1333 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1333; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1333; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -7479,8 +7254,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1333; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1334 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1334; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1334; goto __pyx_L1;}
     Py_INCREF(__pyx_k148p);
@@ -7495,7 +7268,7 @@
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1335 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1335 */
   __pyx_5 = __pyx_f_6mtrand_discd_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_zipf,__pyx_v_size,__pyx_v_oa); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1335; goto __pyx_L1;}
   __pyx_r = __pyx_5;
   __pyx_5 = 0;
@@ -7523,10 +7296,10 @@
 static PyObject *__pyx_k151p;
 static PyObject *__pyx_k152p;
 
-static char (__pyx_k149[]) = "p < 0.0";
-static char (__pyx_k150[]) = "p > 1.0";
-static char (__pyx_k151[]) = "p < 0.0";
-static char (__pyx_k152[]) = "p > 1.0";
+static char __pyx_k149[] = "p < 0.0";
+static char __pyx_k150[] = "p > 1.0";
+static char __pyx_k151[] = "p < 0.0";
+static char __pyx_k152[] = "p > 1.0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_geometric(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_geometric[] = "Geometric distribution with p being the probability of \"success\" on\n        an individual trial.\n        \n        geometric(p, size=None)\n        ";
@@ -7549,18 +7322,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_op = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1346 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1346 */
   __pyx_v_fp = PyFloat_AsDouble(__pyx_v_p);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1347 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1347 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1348 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1348 */
     __pyx_1 = (__pyx_v_fp < 0.0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1349 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1349; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1349; goto __pyx_L1;}
       Py_INCREF(__pyx_k149p);
@@ -7575,11 +7346,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1350 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1350 */
     __pyx_1 = (__pyx_v_fp > 1.0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1351 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1351; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1351; goto __pyx_L1;}
       Py_INCREF(__pyx_k150p);
@@ -7594,7 +7363,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1352 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1352 */
     __pyx_2 = __pyx_f_6mtrand_discd_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_geometric,__pyx_v_size,__pyx_v_fp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1352; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -7603,17 +7372,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1354 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1354 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1357 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1357 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_p,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1357; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_op));
   __pyx_v_op = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1358 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1358 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1358; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1358; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -7638,8 +7407,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1358; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1359 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1359; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1359; goto __pyx_L1;}
     Py_INCREF(__pyx_k151p);
@@ -7654,7 +7421,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1360 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1360 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1360; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1360; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -7679,8 +7446,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_2); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1360; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1361 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1361; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1361; goto __pyx_L1;}
     Py_INCREF(__pyx_k152p);
@@ -7695,7 +7460,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1362 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1362 */
   __pyx_2 = __pyx_f_6mtrand_discd_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_geometric,__pyx_v_size,__pyx_v_op); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1362; goto __pyx_L1;}
   __pyx_r = __pyx_2;
   __pyx_2 = 0;
@@ -7729,14 +7494,14 @@
 static PyObject *__pyx_k159p;
 static PyObject *__pyx_k160p;
 
-static char (__pyx_k153[]) = "ngood < 1";
-static char (__pyx_k154[]) = "nbad < 1";
-static char (__pyx_k155[]) = "nsample < 1";
-static char (__pyx_k156[]) = "ngood + nbad < nsample";
-static char (__pyx_k157[]) = "ngood < 1";
-static char (__pyx_k158[]) = "nbad < 1";
-static char (__pyx_k159[]) = "nsample < 1";
-static char (__pyx_k160[]) = "ngood + nbad < nsample";
+static char __pyx_k153[] = "ngood < 1";
+static char __pyx_k154[] = "nbad < 1";
+static char __pyx_k155[] = "nsample < 1";
+static char __pyx_k156[] = "ngood + nbad < nsample";
+static char __pyx_k157[] = "ngood < 1";
+static char __pyx_k158[] = "nbad < 1";
+static char __pyx_k159[] = "nsample < 1";
+static char __pyx_k160[] = "ngood + nbad < nsample";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_hypergeometric(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_hypergeometric[] = "Hypergeometric distribution.\n        \n        Consider an urn with ngood \"good\" balls and nbad \"bad\" balls. If one \n        were to draw nsample balls from the urn without replacement, then \n        the hypergeometric distribution describes the distribution of \"good\" \n        balls in the sample.\n        \n        hypergeometric(ngood, nbad, nsample, size=None)        \n        ";
@@ -7770,27 +7535,25 @@
   __pyx_v_onbad = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
   __pyx_v_onsample = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1377 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1377 */
   __pyx_v_lngood = PyInt_AsLong(__pyx_v_ngood);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1378 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1378 */
   __pyx_v_lnbad = PyInt_AsLong(__pyx_v_nbad);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1379 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1379 */
   __pyx_v_lnsample = PyInt_AsLong(__pyx_v_nsample);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1380 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1380 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1381 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1381 */
     __pyx_2 = PyInt_FromLong(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1381; goto __pyx_L1;}
     if (PyObject_Cmp(__pyx_v_ngood, __pyx_2, &__pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1381; goto __pyx_L1;}
     __pyx_1 = __pyx_1 < 0;
     Py_DECREF(__pyx_2); __pyx_2 = 0;
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1382 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1382; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1382; goto __pyx_L1;}
       Py_INCREF(__pyx_k153p);
@@ -7805,14 +7568,12 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1383 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1383 */
     __pyx_2 = PyInt_FromLong(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1383; goto __pyx_L1;}
     if (PyObject_Cmp(__pyx_v_nbad, __pyx_2, &__pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1383; goto __pyx_L1;}
     __pyx_1 = __pyx_1 < 0;
     Py_DECREF(__pyx_2); __pyx_2 = 0;
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1384 */
       __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1384; goto __pyx_L1;}
       __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1384; goto __pyx_L1;}
       Py_INCREF(__pyx_k154p);
@@ -7827,14 +7588,12 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1385 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1385 */
     __pyx_3 = PyInt_FromLong(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1385; goto __pyx_L1;}
     if (PyObject_Cmp(__pyx_v_nsample, __pyx_3, &__pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1385; goto __pyx_L1;}
     __pyx_1 = __pyx_1 < 0;
     Py_DECREF(__pyx_3); __pyx_3 = 0;
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1386 */
       __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1386; goto __pyx_L1;}
       __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1386; goto __pyx_L1;}
       Py_INCREF(__pyx_k155p);
@@ -7849,14 +7608,12 @@
     }
     __pyx_L5:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1387 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1387 */
     __pyx_4 = PyNumber_Add(__pyx_v_ngood, __pyx_v_nbad); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1387; goto __pyx_L1;}
     if (PyObject_Cmp(__pyx_4, __pyx_v_nsample, &__pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1387; goto __pyx_L1;}
     __pyx_1 = __pyx_1 < 0;
     Py_DECREF(__pyx_4); __pyx_4 = 0;
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1388 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1388; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1388; goto __pyx_L1;}
       Py_INCREF(__pyx_k156p);
@@ -7871,7 +7628,7 @@
     }
     __pyx_L6:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1389 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1389 */
     __pyx_2 = __pyx_f_6mtrand_discnmN_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_hypergeometric,__pyx_v_size,__pyx_v_lngood,__pyx_v_lnbad,__pyx_v_lnsample); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1389; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -7880,31 +7637,31 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1393 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1393 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1395 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1395 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_ngood,NPY_LONG,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1395; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_ongood));
   __pyx_v_ongood = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1396 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1396 */
   __pyx_4 = PyArray_FROM_OTF(__pyx_v_nbad,NPY_LONG,NPY_ALIGNED); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1396; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_4)));
   Py_DECREF(((PyObject *)__pyx_v_onbad));
   __pyx_v_onbad = ((PyArrayObject *)__pyx_4);
   Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1397 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1397 */
   __pyx_2 = PyArray_FROM_OTF(__pyx_v_nsample,NPY_LONG,NPY_ALIGNED); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1397; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
   Py_DECREF(((PyObject *)__pyx_v_onsample));
   __pyx_v_onsample = ((PyArrayObject *)__pyx_2);
   Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1398 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1398 */
   __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1398; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_3, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1398; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
@@ -7929,8 +7686,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1398; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1399 */
     __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1399; goto __pyx_L1;}
     __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1399; goto __pyx_L1;}
     Py_INCREF(__pyx_k157p);
@@ -7945,7 +7700,7 @@
   }
   __pyx_L7:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1400 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1400 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1400; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1400; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -7970,8 +7725,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_4); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1400; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1401 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1401; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1401; goto __pyx_L1;}
     Py_INCREF(__pyx_k158p);
@@ -7986,7 +7739,7 @@
   }
   __pyx_L8:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1402 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1402 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1402; goto __pyx_L1;}
   __pyx_5 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1402; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -8011,8 +7764,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_2); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1402; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1403 */
     __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1403; goto __pyx_L1;}
     __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1403; goto __pyx_L1;}
     Py_INCREF(__pyx_k159p);
@@ -8027,7 +7778,7 @@
   }
   __pyx_L9:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1404 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1404 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1404; goto __pyx_L1;}
   __pyx_4 = PyObject_GetAttr(__pyx_2, __pyx_n_any); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1404; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -8062,8 +7813,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_3); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1404; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1405 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1405; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1405; goto __pyx_L1;}
     Py_INCREF(__pyx_k160p);
@@ -8078,7 +7827,7 @@
   }
   __pyx_L10:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1406 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1406 */
   __pyx_6 = __pyx_f_6mtrand_discnmN_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_hypergeometric,__pyx_v_size,__pyx_v_ongood,__pyx_v_onbad,__pyx_v_onsample); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1406; goto __pyx_L1;}
   __pyx_r = __pyx_6;
   __pyx_6 = 0;
@@ -8111,10 +7860,10 @@
 static PyObject *__pyx_k163p;
 static PyObject *__pyx_k164p;
 
-static char (__pyx_k161[]) = "p < 0.0";
-static char (__pyx_k162[]) = "p > 1.0";
-static char (__pyx_k163[]) = "p < 0.0";
-static char (__pyx_k164[]) = "p > 1.0";
+static char __pyx_k161[] = "p < 0.0";
+static char __pyx_k162[] = "p > 1.0";
+static char __pyx_k163[] = "p < 0.0";
+static char __pyx_k164[] = "p > 1.0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_logseries(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_logseries[] = "Logarithmic series distribution.\n        \n        logseries(p, size=None)\n        ";
@@ -8137,18 +7886,16 @@
   Py_INCREF(__pyx_v_size);
   __pyx_v_op = ((PyArrayObject *)Py_None); Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1417 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1417 */
   __pyx_v_fp = PyFloat_AsDouble(__pyx_v_p);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1418 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1418 */
   __pyx_1 = (!PyErr_Occurred());
   if (__pyx_1) {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1419 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1419 */
     __pyx_1 = (__pyx_v_fp < 0.0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1420 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1420; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1420; goto __pyx_L1;}
       Py_INCREF(__pyx_k161p);
@@ -8163,11 +7910,9 @@
     }
     __pyx_L3:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1421 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1421 */
     __pyx_1 = (__pyx_v_fp > 1.0);
     if (__pyx_1) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1422 */
       __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1422; goto __pyx_L1;}
       __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1422; goto __pyx_L1;}
       Py_INCREF(__pyx_k162p);
@@ -8182,7 +7927,7 @@
     }
     __pyx_L4:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1423 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1423 */
     __pyx_2 = __pyx_f_6mtrand_discd_array_sc(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_logseries,__pyx_v_size,__pyx_v_fp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1423; goto __pyx_L1;}
     __pyx_r = __pyx_2;
     __pyx_2 = 0;
@@ -8191,17 +7936,17 @@
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1425 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1425 */
   PyErr_Clear();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1427 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1427 */
   __pyx_3 = PyArray_FROM_OTF(__pyx_v_p,NPY_DOUBLE,NPY_ALIGNED); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1427; goto __pyx_L1;}
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_3)));
   Py_DECREF(((PyObject *)__pyx_v_op));
   __pyx_v_op = ((PyArrayObject *)__pyx_3);
   Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1428 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1428 */
   __pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1428; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_any); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1428; goto __pyx_L1;}
   Py_DECREF(__pyx_4); __pyx_4 = 0;
@@ -8226,8 +7971,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_5); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1428; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1429 */
     __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1429; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1429; goto __pyx_L1;}
     Py_INCREF(__pyx_k163p);
@@ -8242,7 +7985,7 @@
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1430 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1430 */
   __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; goto __pyx_L1;}
   __pyx_3 = PyObject_GetAttr(__pyx_5, __pyx_n_any); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; goto __pyx_L1;}
   Py_DECREF(__pyx_5); __pyx_5 = 0;
@@ -8267,8 +8010,6 @@
   __pyx_1 = PyObject_IsTrue(__pyx_2); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
   if (__pyx_1) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1431 */
     __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1431; goto __pyx_L1;}
     __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1431; goto __pyx_L1;}
     Py_INCREF(__pyx_k164p);
@@ -8283,7 +8024,7 @@
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1432 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1432 */
   __pyx_2 = __pyx_f_6mtrand_discd_array(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,rk_logseries,__pyx_v_size,__pyx_v_op); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1432; goto __pyx_L1;}
   __pyx_r = __pyx_2;
   __pyx_2 = 0;
@@ -8308,7 +8049,6 @@
 
 static PyObject *__pyx_n_array;
 static PyObject *__pyx_n_shape;
-static PyObject *__pyx_n_isinstance;
 static PyObject *__pyx_n_list;
 static PyObject *__pyx_n_append;
 static PyObject *__pyx_n_multiply;
@@ -8323,10 +8063,10 @@
 static PyObject *__pyx_k167p;
 static PyObject *__pyx_k168p;
 
-static char (__pyx_k165[]) = "mean must be 1 dimensional";
-static char (__pyx_k166[]) = "cov must be 2 dimensional and square";
-static char (__pyx_k167[]) = "mean and cov must have same length";
-static char (__pyx_k168[]) = "numpy.dual";
+static char __pyx_k165[] = "mean must be 1 dimensional";
+static char __pyx_k166[] = "cov must be 2 dimensional and square";
+static char __pyx_k167[] = "mean and cov must have same length";
+static char __pyx_k168[] = "numpy.dual";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_multivariate_normal(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_multivariate_normal[] = "Return an array containing multivariate normally distributed random numbers\n        with specified mean and covariance.\n\n        multivariate_normal(mean, cov) -> random values\n        multivariate_normal(mean, cov, [m, n, ...]) -> random values\n\n        mean must be a 1 dimensional array. cov must be a square two dimensional\n        array with the same number of rows and columns as mean has elements.\n\n        The first form returns a single 1-D array containing a multivariate\n        normal.\n\n        The second form returns an array of shape (m, n, ..., cov.shape[0]).\n        In this case, output[i,j,...,:] is a 1-D array containing a multivariate\n        normal.\n        ";
@@ -8346,7 +8086,8 @@
   PyObject *__pyx_2 = 0;
   PyObject *__pyx_3 = 0;
   int __pyx_4;
-  PyObject *__pyx_5 = 0;
+  Py_ssize_t __pyx_5;
+  PyObject *__pyx_6 = 0;
   static char *__pyx_argnames[] = {"mean","cov","size",0};
   __pyx_v_size = __pyx_k58;
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "OO|O", __pyx_argnames, &__pyx_v_mean, &__pyx_v_cov, &__pyx_v_size)) return 0;
@@ -8362,7 +8103,7 @@
   __pyx_v_s = Py_None; Py_INCREF(Py_None);
   __pyx_v_v = Py_None; Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1453 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1453 */
   __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1453; goto __pyx_L1;}
   __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_array); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1453; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
@@ -8376,7 +8117,7 @@
   __pyx_v_mean = __pyx_3;
   __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1454 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1454 */
   __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1454; goto __pyx_L1;}
   __pyx_1 = PyObject_GetAttr(__pyx_2, __pyx_n_array); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1454; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
@@ -8390,11 +8131,9 @@
   __pyx_v_cov = __pyx_2;
   __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1455 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1455 */
   __pyx_4 = __pyx_v_size == Py_None;
   if (__pyx_4) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1456 */
     __pyx_1 = PyList_New(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1456; goto __pyx_L1;}
     Py_DECREF(__pyx_v_shape);
     __pyx_v_shape = __pyx_1;
@@ -8402,38 +8141,25 @@
     goto __pyx_L2;
   }
   /*else*/ {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1458 */
     Py_INCREF(__pyx_v_size);
     Py_DECREF(__pyx_v_shape);
     __pyx_v_shape = __pyx_v_size;
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1459 */
-  __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; goto __pyx_L1;}
-  __pyx_2 = PyObject_GetAttr(__pyx_v_mean, __pyx_n_shape); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; goto __pyx_L1;}
-  __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_1, 0, __pyx_2);
-  __pyx_2 = 0;
-  __pyx_2 = PyObject_CallObject(__pyx_3, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1459 */
+  __pyx_3 = PyObject_GetAttr(__pyx_v_mean, __pyx_n_shape); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; goto __pyx_L1;}
+  __pyx_5 = PyObject_Length(__pyx_3); if (__pyx_5 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  __pyx_3 = PyInt_FromLong(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; goto __pyx_L1;}
-  if (PyObject_Cmp(__pyx_2, __pyx_3, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; goto __pyx_L1;}
-  __pyx_4 = __pyx_4 != 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  __pyx_4 = (__pyx_5 != 1);
   if (__pyx_4) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1460 */
-    __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; goto __pyx_L1;}
-    __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; goto __pyx_L1;}
+    __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; goto __pyx_L1;}
+    __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; goto __pyx_L1;}
     Py_INCREF(__pyx_k165p);
-    PyTuple_SET_ITEM(__pyx_2, 0, __pyx_k165p);
-    __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; goto __pyx_L1;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
+    PyTuple_SET_ITEM(__pyx_1, 0, __pyx_k165p);
+    __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
     __Pyx_Raise(__pyx_3, 0, 0);
     Py_DECREF(__pyx_3); __pyx_3 = 0;
     {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; goto __pyx_L1;}
@@ -8441,291 +8167,255 @@
   }
   __pyx_L3:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1461 */
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1461 */
   __pyx_2 = PyObject_GetAttr(__pyx_v_cov, __pyx_n_shape); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-  __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_3, 0, __pyx_2);
-  __pyx_2 = 0;
-  __pyx_2 = PyObject_CallObject(__pyx_1, __pyx_3); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_1 = PyInt_FromLong(2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-  if (PyObject_Cmp(__pyx_2, __pyx_1, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-  __pyx_4 = __pyx_4 != 0;
+  __pyx_5 = PyObject_Length(__pyx_2); if (__pyx_5 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_4 = (__pyx_5 != 2);
   if (!__pyx_4) {
-    __pyx_3 = PyObject_GetAttr(__pyx_v_cov, __pyx_n_shape); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-    __pyx_2 = PyInt_FromLong(0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-    __pyx_1 = PyObject_GetItem(__pyx_3, __pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    __pyx_1 = PyObject_GetAttr(__pyx_v_cov, __pyx_n_shape); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    __pyx_3 = PyInt_FromLong(0); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    __pyx_2 = PyObject_GetItem(__pyx_1, __pyx_3); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
     Py_DECREF(__pyx_3); __pyx_3 = 0;
-    Py_DECREF(__pyx_2); __pyx_2 = 0;
-    __pyx_3 = PyObject_GetAttr(__pyx_v_cov, __pyx_n_shape); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-    __pyx_2 = PyInt_FromLong(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
-    __pyx_5 = PyObject_GetItem(__pyx_3, __pyx_2); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    __pyx_1 = PyObject_GetAttr(__pyx_v_cov, __pyx_n_shape); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    __pyx_3 = PyInt_FromLong(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    __pyx_6 = PyObject_GetItem(__pyx_1, __pyx_3); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
     Py_DECREF(__pyx_3); __pyx_3 = 0;
-    Py_DECREF(__pyx_2); __pyx_2 = 0;
-    if (PyObject_Cmp(__pyx_1, __pyx_5, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
+    if (PyObject_Cmp(__pyx_2, __pyx_6, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; goto __pyx_L1;}
     __pyx_4 = __pyx_4 != 0;
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
-    Py_DECREF(__pyx_5); __pyx_5 = 0;
+    Py_DECREF(__pyx_2); __pyx_2 = 0;
+    Py_DECREF(__pyx_6); __pyx_6 = 0;
   }
   if (__pyx_4) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1462 */
-    __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; goto __pyx_L1;}
-    __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; goto __pyx_L1;}
+    __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; goto __pyx_L1;}
+    __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; goto __pyx_L1;}
     Py_INCREF(__pyx_k166p);
-    PyTuple_SET_ITEM(__pyx_2, 0, __pyx_k166p);
-    __pyx_1 = PyObject_CallObject(__pyx_3, __pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; goto __pyx_L1;}
+    PyTuple_SET_ITEM(__pyx_3, 0, __pyx_k166p);
+    __pyx_2 = PyObject_CallObject(__pyx_1, __pyx_3); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; goto __pyx_L1;}
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
     Py_DECREF(__pyx_3); __pyx_3 = 0;
+    __Pyx_Raise(__pyx_2, 0, 0);
     Py_DECREF(__pyx_2); __pyx_2 = 0;
-    __Pyx_Raise(__pyx_1, 0, 0);
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
     {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; goto __pyx_L1;}
     goto __pyx_L4;
   }
   __pyx_L4:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1463 */
-  __pyx_5 = PyObject_GetAttr(__pyx_v_mean, __pyx_n_shape); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
-  __pyx_3 = PyInt_FromLong(0); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
-  __pyx_2 = PyObject_GetItem(__pyx_5, __pyx_3); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_1 = PyObject_GetAttr(__pyx_v_cov, __pyx_n_shape); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
-  __pyx_5 = PyInt_FromLong(0); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
-  __pyx_3 = PyObject_GetItem(__pyx_1, __pyx_5); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1463 */
+  __pyx_6 = PyObject_GetAttr(__pyx_v_mean, __pyx_n_shape); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
+  __pyx_1 = PyInt_FromLong(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
+  __pyx_3 = PyObject_GetItem(__pyx_6, __pyx_1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
   Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  if (PyObject_Cmp(__pyx_2, __pyx_3, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
-  __pyx_4 = __pyx_4 != 0;
+  __pyx_2 = PyObject_GetAttr(__pyx_v_cov, __pyx_n_shape); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
+  __pyx_6 = PyInt_FromLong(0); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
+  __pyx_1 = PyObject_GetItem(__pyx_2, __pyx_6); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  if (PyObject_Cmp(__pyx_3, __pyx_1, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1463; goto __pyx_L1;}
+  __pyx_4 = __pyx_4 != 0;
   Py_DECREF(__pyx_3); __pyx_3 = 0;
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
   if (__pyx_4) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1464 */
-    __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; goto __pyx_L1;}
-    __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; goto __pyx_L1;}
+    __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; goto __pyx_L1;}
+    __pyx_6 = PyTuple_New(1); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; goto __pyx_L1;}
     Py_INCREF(__pyx_k167p);
-    PyTuple_SET_ITEM(__pyx_5, 0, __pyx_k167p);
-    __pyx_2 = PyObject_CallObject(__pyx_1, __pyx_5); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; goto __pyx_L1;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
-    Py_DECREF(__pyx_5); __pyx_5 = 0;
-    __Pyx_Raise(__pyx_2, 0, 0);
+    PyTuple_SET_ITEM(__pyx_6, 0, __pyx_k167p);
+    __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_6); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
+    Py_DECREF(__pyx_6); __pyx_6 = 0;
+    __Pyx_Raise(__pyx_3, 0, 0);
+    Py_DECREF(__pyx_3); __pyx_3 = 0;
     {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; goto __pyx_L1;}
     goto __pyx_L5;
   }
   __pyx_L5:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1466 */
-  __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_isinstance); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1466 */
   __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; goto __pyx_L1;}
-  __pyx_5 = PyTuple_New(2); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_shape);
-  PyTuple_SET_ITEM(__pyx_5, 0, __pyx_v_shape);
-  PyTuple_SET_ITEM(__pyx_5, 1, __pyx_1);
-  __pyx_1 = 0;
-  __pyx_2 = PyObject_CallObject(__pyx_3, __pyx_5); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  __pyx_4 = PyObject_IsTrue(__pyx_2); if (__pyx_4 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; goto __pyx_L1;}
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  __pyx_4 = PyObject_IsInstance(__pyx_v_shape,__pyx_1); if (__pyx_4 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
   if (__pyx_4) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1467 */
-    __pyx_1 = PyList_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1467; goto __pyx_L1;}
+    __pyx_2 = PyList_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1467; goto __pyx_L1;}
     Py_INCREF(__pyx_v_shape);
-    PyList_SET_ITEM(__pyx_1, 0, __pyx_v_shape);
+    PyList_SET_ITEM(__pyx_2, 0, __pyx_v_shape);
     Py_DECREF(__pyx_v_shape);
-    __pyx_v_shape = __pyx_1;
-    __pyx_1 = 0;
+    __pyx_v_shape = __pyx_2;
+    __pyx_2 = 0;
     goto __pyx_L6;
   }
   __pyx_L6:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1468 */
-  __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_list); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1468; goto __pyx_L1;}
-  __pyx_5 = PySequence_GetSlice(__pyx_v_shape, 0, 0x7fffffff); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1468; goto __pyx_L1;}
-  __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1468; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_5);
-  __pyx_5 = 0;
-  __pyx_1 = PyObject_CallObject(__pyx_3, __pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1468; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1468 */
+  __pyx_6 = __Pyx_GetName(__pyx_b, __pyx_n_list); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1468; goto __pyx_L1;}
+  __pyx_3 = PySequence_GetSlice(__pyx_v_shape, 0, PY_SSIZE_T_MAX); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1468; goto __pyx_L1;}
+  __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1468; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_1, 0, __pyx_3);
+  __pyx_3 = 0;
+  __pyx_2 = PyObject_CallObject(__pyx_6, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1468; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
   Py_DECREF(__pyx_v_final_shape);
-  __pyx_v_final_shape = __pyx_1;
-  __pyx_1 = 0;
+  __pyx_v_final_shape = __pyx_2;
+  __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1469 */
-  __pyx_5 = PyObject_GetAttr(__pyx_v_final_shape, __pyx_n_append); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
-  __pyx_3 = PyObject_GetAttr(__pyx_v_mean, __pyx_n_shape); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
-  __pyx_2 = PyInt_FromLong(0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
-  __pyx_1 = PyObject_GetItem(__pyx_3, __pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1469 */
+  __pyx_3 = PyObject_GetAttr(__pyx_v_final_shape, __pyx_n_append); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
+  __pyx_6 = PyObject_GetAttr(__pyx_v_mean, __pyx_n_shape); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
+  __pyx_1 = PyInt_FromLong(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
+  __pyx_2 = PyObject_GetItem(__pyx_6, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_6 = PyTuple_New(1); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_6, 0, __pyx_2);
+  __pyx_2 = 0;
+  __pyx_1 = PyObject_CallObject(__pyx_3, __pyx_6); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_3, 0, __pyx_1);
-  __pyx_1 = 0;
-  __pyx_2 = PyObject_CallObject(__pyx_5, __pyx_3); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1469; goto __pyx_L1;}
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1473 */
-  __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n_standard_normal); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
-  __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
-  __pyx_3 = PyObject_GetAttr(__pyx_5, __pyx_n_multiply); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  __pyx_2 = PyObject_GetAttr(__pyx_3, __pyx_n_reduce); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_final_shape);
-  PyTuple_SET_ITEM(__pyx_5, 0, __pyx_v_final_shape);
-  __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_5); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_3);
-  __pyx_3 = 0;
-  __pyx_5 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
   Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  Py_DECREF(__pyx_v_x);
-  __pyx_v_x = __pyx_5;
-  __pyx_5 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1474 */
-  __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
-  __pyx_1 = PyObject_GetAttr(__pyx_3, __pyx_n_multiply); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1473 */
+  __pyx_2 = PyObject_GetAttr(__pyx_v_self, __pyx_n_standard_normal); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
+  __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
+  __pyx_6 = PyObject_GetAttr(__pyx_3, __pyx_n_multiply); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_reduce); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
-  __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  __pyx_1 = PyObject_GetAttr(__pyx_6, __pyx_n_reduce); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
   Py_INCREF(__pyx_v_final_shape);
   PyTuple_SET_ITEM(__pyx_3, 0, __pyx_v_final_shape);
-  __pyx_1 = PyObject_CallObject(__pyx_5, __pyx_3); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_5 = PyInt_FromLong(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
-  __pyx_3 = PyNumber_Subtract(__pyx_1, __pyx_5); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  __pyx_6 = PyObject_CallObject(__pyx_1, __pyx_3); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  __pyx_4 = PyInt_AsLong(__pyx_3); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_1 = PySequence_GetSlice(__pyx_v_final_shape, 0, __pyx_4); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
-  __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_5, 0, __pyx_1);
-  __pyx_1 = 0;
-  __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_5); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_1, 0, __pyx_6);
+  __pyx_6 = 0;
+  __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  __pyx_1 = PyObject_GetAttr(__pyx_v_mean, __pyx_n_shape); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; goto __pyx_L1;}
-  __pyx_2 = PyInt_FromLong(0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; goto __pyx_L1;}
-  __pyx_5 = PyObject_GetItem(__pyx_1, __pyx_2); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
+  Py_DECREF(__pyx_v_x);
+  __pyx_v_x = __pyx_3;
+  __pyx_3 = 0;
+
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1474 */
+  __pyx_6 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  __pyx_2 = PyObject_GetAttr(__pyx_6, __pyx_n_multiply); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  __pyx_1 = PyObject_GetAttr(__pyx_2, __pyx_n_reduce); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_1 = PyTuple_New(2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_1, 0, __pyx_3);
-  PyTuple_SET_ITEM(__pyx_1, 1, __pyx_5);
+  __pyx_5 = PyObject_Length(__pyx_v_final_shape); if (__pyx_5 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  __pyx_3 = PySequence_GetSlice(__pyx_v_final_shape, 0, (__pyx_5 - 1)); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  __pyx_6 = PyTuple_New(1); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_6, 0, __pyx_3);
   __pyx_3 = 0;
-  __pyx_5 = 0;
-  if (PyObject_SetAttr(__pyx_v_x, __pyx_n_shape, __pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  __pyx_2 = PyObject_CallObject(__pyx_1, __pyx_6); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  __pyx_3 = PyObject_GetAttr(__pyx_v_mean, __pyx_n_shape); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; goto __pyx_L1;}
+  __pyx_1 = PyInt_FromLong(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; goto __pyx_L1;}
+  __pyx_6 = PyObject_GetItem(__pyx_3, __pyx_1); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; goto __pyx_L1;}
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_3 = PyTuple_New(2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_3, 0, __pyx_2);
+  PyTuple_SET_ITEM(__pyx_3, 1, __pyx_6);
+  __pyx_2 = 0;
+  __pyx_6 = 0;
+  if (PyObject_SetAttr(__pyx_v_x, __pyx_n_shape, __pyx_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; goto __pyx_L1;}
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1483 */
-  __pyx_2 = PyList_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1483 */
+  __pyx_1 = PyList_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; goto __pyx_L1;}
   Py_INCREF(__pyx_n_svd);
-  PyList_SET_ITEM(__pyx_2, 0, __pyx_n_svd);
-  __pyx_3 = __Pyx_Import(__pyx_k168p, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; goto __pyx_L1;}
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_5 = PyObject_GetAttr(__pyx_3, __pyx_n_svd); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; goto __pyx_L1;}
+  PyList_SET_ITEM(__pyx_1, 0, __pyx_n_svd);
+  __pyx_2 = __Pyx_Import(__pyx_k168p, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_6 = PyObject_GetAttr(__pyx_2, __pyx_n_svd); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; goto __pyx_L1;}
   Py_DECREF(__pyx_v_svd);
-  __pyx_v_svd = __pyx_5;
-  __pyx_5 = 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  __pyx_v_svd = __pyx_6;
+  __pyx_6 = 0;
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1485 */
-  __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1485 */
+  __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
   Py_INCREF(__pyx_v_cov);
-  PyTuple_SET_ITEM(__pyx_1, 0, __pyx_v_cov);
-  __pyx_2 = PyObject_CallObject(__pyx_v_svd, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_3, 0, __pyx_v_cov);
+  __pyx_1 = PyObject_CallObject(__pyx_v_svd, __pyx_3); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  __pyx_2 = PyObject_GetIter(__pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
-  __pyx_3 = PyObject_GetIter(__pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_5 = __Pyx_UnpackItem(__pyx_3); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
+  __pyx_6 = __Pyx_UnpackItem(__pyx_2); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
   Py_DECREF(__pyx_v_u);
-  __pyx_v_u = __pyx_5;
-  __pyx_5 = 0;
-  __pyx_1 = __Pyx_UnpackItem(__pyx_3); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
+  __pyx_v_u = __pyx_6;
+  __pyx_6 = 0;
+  __pyx_3 = __Pyx_UnpackItem(__pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
   Py_DECREF(__pyx_v_s);
-  __pyx_v_s = __pyx_1;
-  __pyx_1 = 0;
-  __pyx_2 = __Pyx_UnpackItem(__pyx_3); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
+  __pyx_v_s = __pyx_3;
+  __pyx_3 = 0;
+  __pyx_1 = __Pyx_UnpackItem(__pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
   Py_DECREF(__pyx_v_v);
-  __pyx_v_v = __pyx_2;
-  __pyx_2 = 0;
-  if (__Pyx_EndUnpack(__pyx_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1486 */
-  __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
-  __pyx_1 = PyObject_GetAttr(__pyx_5, __pyx_n_dot); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
-  __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_sqrt); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+  __pyx_v_v = __pyx_1;
+  __pyx_1 = 0;
+  if (__Pyx_EndUnpack(__pyx_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1485; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1486 */
+  __pyx_6 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+  __pyx_3 = PyObject_GetAttr(__pyx_6, __pyx_n_dot); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+  __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_sqrt); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_6 = PyTuple_New(1); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
   Py_INCREF(__pyx_v_s);
-  PyTuple_SET_ITEM(__pyx_5, 0, __pyx_v_s);
-  __pyx_2 = PyObject_CallObject(__pyx_3, __pyx_5); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  __pyx_3 = PyNumber_Multiply(__pyx_v_x, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_6, 0, __pyx_v_s);
+  __pyx_1 = PyObject_CallObject(__pyx_2, __pyx_6); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_5 = PyTuple_New(2); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_5, 0, __pyx_3);
-  Py_INCREF(__pyx_v_v);
-  PyTuple_SET_ITEM(__pyx_5, 1, __pyx_v_v);
-  __pyx_3 = 0;
-  __pyx_2 = PyObject_CallObject(__pyx_1, __pyx_5); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  __pyx_2 = PyNumber_Multiply(__pyx_v_x, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  Py_DECREF(__pyx_v_x);
-  __pyx_v_x = __pyx_2;
+  __pyx_6 = PyTuple_New(2); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_6, 0, __pyx_2);
+  Py_INCREF(__pyx_v_v);
+  PyTuple_SET_ITEM(__pyx_6, 1, __pyx_v_v);
   __pyx_2 = 0;
-
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1489 */
-  __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; goto __pyx_L1;}
-  __pyx_1 = PyObject_GetAttr(__pyx_3, __pyx_n_add); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; goto __pyx_L1;}
+  __pyx_1 = PyObject_CallObject(__pyx_3, __pyx_6); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; goto __pyx_L1;}
   Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_5 = PyTuple_New(3); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
+  Py_DECREF(__pyx_v_x);
+  __pyx_v_x = __pyx_1;
+  __pyx_1 = 0;
+
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1489 */
+  __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; goto __pyx_L1;}
+  __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_add); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; goto __pyx_L1;}
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  __pyx_6 = PyTuple_New(3); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; goto __pyx_L1;}
   Py_INCREF(__pyx_v_mean);
-  PyTuple_SET_ITEM(__pyx_5, 0, __pyx_v_mean);
+  PyTuple_SET_ITEM(__pyx_6, 0, __pyx_v_mean);
   Py_INCREF(__pyx_v_x);
-  PyTuple_SET_ITEM(__pyx_5, 1, __pyx_v_x);
+  PyTuple_SET_ITEM(__pyx_6, 1, __pyx_v_x);
   Py_INCREF(__pyx_v_x);
-  PyTuple_SET_ITEM(__pyx_5, 2, __pyx_v_x);
-  __pyx_2 = PyObject_CallObject(__pyx_1, __pyx_5); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_6, 2, __pyx_v_x);
+  __pyx_1 = PyObject_CallObject(__pyx_3, __pyx_6); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; goto __pyx_L1;}
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
   Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1490 */
-  __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_tuple); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; goto __pyx_L1;}
-  __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1490 */
+  __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_tuple); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; goto __pyx_L1;}
+  __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; goto __pyx_L1;}
   Py_INCREF(__pyx_v_final_shape);
-  PyTuple_SET_ITEM(__pyx_1, 0, __pyx_v_final_shape);
-  __pyx_5 = PyObject_CallObject(__pyx_3, __pyx_1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_3, 0, __pyx_v_final_shape);
+  __pyx_6 = PyObject_CallObject(__pyx_2, __pyx_3); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; goto __pyx_L1;}
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
   Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  if (PyObject_SetAttr(__pyx_v_x, __pyx_n_shape, __pyx_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; goto __pyx_L1;}
-  Py_DECREF(__pyx_5); __pyx_5 = 0;
+  if (PyObject_SetAttr(__pyx_v_x, __pyx_n_shape, __pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; goto __pyx_L1;}
+  Py_DECREF(__pyx_6); __pyx_6 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1491 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1491 */
   Py_INCREF(__pyx_v_x);
   __pyx_r = __pyx_v_x;
   goto __pyx_L0;
@@ -8736,7 +8426,7 @@
   Py_XDECREF(__pyx_1);
   Py_XDECREF(__pyx_2);
   Py_XDECREF(__pyx_3);
-  Py_XDECREF(__pyx_5);
+  Py_XDECREF(__pyx_6);
   __Pyx_AddTraceback("mtrand.RandomState.multivariate_normal");
   __pyx_r = 0;
   __pyx_L0:;
@@ -8758,7 +8448,7 @@
 
 static PyObject *__pyx_k170p;
 
-static char (__pyx_k170[]) = "sum(pvals[:-1]) > 1.0";
+static char __pyx_k170[] = "sum(pvals[:-1]) > 1.0";
 
 static PyObject *__pyx_f_6mtrand_11RandomState_multinomial(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static char __pyx_doc_6mtrand_11RandomState_multinomial[] = "Multinomial distribution.\n        \n        multinomial(n, pvals, size=None) -> random values\n\n        pvals is a sequence of probabilities that should sum to 1 (however, the\n        last element is always assumed to account for the remaining probability\n        as long as sum(pvals[:-1]) <= 1).\n        ";
@@ -8769,8 +8459,8 @@
   long __pyx_v_d;
   PyArrayObject *arrayObject_parr;
   PyArrayObject *arrayObject_mnarr;
-  double (*__pyx_v_pix);
-  long (*__pyx_v_mnix);
+  double *__pyx_v_pix;
+  long *__pyx_v_mnix;
   long __pyx_v_i;
   long __pyx_v_j;
   long __pyx_v_dn;
@@ -8778,11 +8468,12 @@
   PyObject *__pyx_v_shape;
   PyObject *__pyx_v_multin;
   PyObject *__pyx_r;
-  PyObject *__pyx_1 = 0;
+  Py_ssize_t __pyx_1;
   PyObject *__pyx_2 = 0;
-  PyObject *__pyx_3 = 0;
-  long __pyx_4;
-  int __pyx_5;
+  int __pyx_3;
+  PyObject *__pyx_4 = 0;
+  PyObject *__pyx_5 = 0;
+  long __pyx_6;
   static char *__pyx_argnames[] = {"n","pvals","size",0};
   __pyx_v_size = __pyx_k59;
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "lO|O", __pyx_argnames, &__pyx_v_n, &__pyx_v_pvals, &__pyx_v_size)) return 0;
@@ -8794,180 +8485,160 @@
   __pyx_v_shape = Py_None; Py_INCREF(Py_None);
   __pyx_v_multin = Py_None; Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1509 */
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1509; goto __pyx_L1;}
-  __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1509; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_pvals);
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_pvals);
-  __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1509; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_4 = PyInt_AsLong(__pyx_3); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1509; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_v_d = __pyx_4;
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1509 */
+  __pyx_1 = PyObject_Length(__pyx_v_pvals); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1509; goto __pyx_L1;}
+  __pyx_v_d = __pyx_1;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1510 */
-  __pyx_1 = PyArray_ContiguousFromObject(__pyx_v_pvals,NPY_DOUBLE,1,1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1510; goto __pyx_L1;}
-  Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_1)));
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1510 */
+  __pyx_2 = PyArray_ContiguousFromObject(__pyx_v_pvals,NPY_DOUBLE,1,1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1510; goto __pyx_L1;}
+  Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
   Py_DECREF(((PyObject *)arrayObject_parr));
-  arrayObject_parr = ((PyArrayObject *)__pyx_1);
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  arrayObject_parr = ((PyArrayObject *)__pyx_2);
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1511 */
-  __pyx_v_pix = ((double (*))arrayObject_parr->data);
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1511 */
+  __pyx_v_pix = ((double *)arrayObject_parr->data);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1513 */
-  __pyx_5 = (__pyx_f_6mtrand_kahan_sum(__pyx_v_pix,(__pyx_v_d - 1)) > (1.0 + 1e-12));
-  if (__pyx_5) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1514 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1513 */
+  __pyx_3 = (__pyx_f_6mtrand_kahan_sum(__pyx_v_pix,(__pyx_v_d - 1)) > (1.0 + 1e-12));
+  if (__pyx_3) {
     __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_ValueError); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; goto __pyx_L1;}
-    __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; goto __pyx_L1;}
+    __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; goto __pyx_L1;}
     Py_INCREF(__pyx_k170p);
-    PyTuple_SET_ITEM(__pyx_3, 0, __pyx_k170p);
-    __pyx_1 = PyObject_CallObject(__pyx_2, __pyx_3); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; goto __pyx_L1;}
+    PyTuple_SET_ITEM(__pyx_4, 0, __pyx_k170p);
+    __pyx_5 = PyObject_CallObject(__pyx_2, __pyx_4); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
-    Py_DECREF(__pyx_3); __pyx_3 = 0;
-    __Pyx_Raise(__pyx_1, 0, 0);
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
+    Py_DECREF(__pyx_4); __pyx_4 = 0;
+    __Pyx_Raise(__pyx_5, 0, 0);
+    Py_DECREF(__pyx_5); __pyx_5 = 0;
     {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; goto __pyx_L1;}
     goto __pyx_L2;
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1516 */
-  __pyx_5 = __pyx_v_size == Py_None;
-  if (__pyx_5) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1517 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1516 */
+  __pyx_3 = __pyx_v_size == Py_None;
+  if (__pyx_3) {
     __pyx_2 = PyInt_FromLong(__pyx_v_d); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1517; goto __pyx_L1;}
-    __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1517; goto __pyx_L1;}
-    PyTuple_SET_ITEM(__pyx_3, 0, __pyx_2);
+    __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1517; goto __pyx_L1;}
+    PyTuple_SET_ITEM(__pyx_4, 0, __pyx_2);
     __pyx_2 = 0;
     Py_DECREF(__pyx_v_shape);
-    __pyx_v_shape = __pyx_3;
-    __pyx_3 = 0;
+    __pyx_v_shape = __pyx_4;
+    __pyx_4 = 0;
     goto __pyx_L3;
   }
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_type); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; goto __pyx_L1;}
+  __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_type); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; goto __pyx_L1;}
   __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; goto __pyx_L1;}
   Py_INCREF(__pyx_v_size);
   PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_size);
-  __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_4 = PyObject_CallObject(__pyx_5, __pyx_2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; goto __pyx_L1;}
+  Py_DECREF(__pyx_5); __pyx_5 = 0;
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; goto __pyx_L1;}
-  __pyx_5 = __pyx_3 == __pyx_1;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  if (__pyx_5) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1519 */
+  __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; goto __pyx_L1;}
+  __pyx_3 = __pyx_4 == __pyx_5;
+  Py_DECREF(__pyx_4); __pyx_4 = 0;
+  Py_DECREF(__pyx_5); __pyx_5 = 0;
+  if (__pyx_3) {
     __pyx_2 = PyInt_FromLong(__pyx_v_d); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; goto __pyx_L1;}
-    __pyx_3 = PyTuple_New(2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; goto __pyx_L1;}
+    __pyx_4 = PyTuple_New(2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; goto __pyx_L1;}
     Py_INCREF(__pyx_v_size);
-    PyTuple_SET_ITEM(__pyx_3, 0, __pyx_v_size);
-    PyTuple_SET_ITEM(__pyx_3, 1, __pyx_2);
+    PyTuple_SET_ITEM(__pyx_4, 0, __pyx_v_size);
+    PyTuple_SET_ITEM(__pyx_4, 1, __pyx_2);
     __pyx_2 = 0;
     Py_DECREF(__pyx_v_shape);
-    __pyx_v_shape = __pyx_3;
-    __pyx_3 = 0;
+    __pyx_v_shape = __pyx_4;
+    __pyx_4 = 0;
     goto __pyx_L3;
   }
   /*else*/ {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1521 */
-    __pyx_1 = PyInt_FromLong(__pyx_v_d); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1521; goto __pyx_L1;}
+    __pyx_5 = PyInt_FromLong(__pyx_v_d); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1521; goto __pyx_L1;}
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1521; goto __pyx_L1;}
-    PyTuple_SET_ITEM(__pyx_2, 0, __pyx_1);
-    __pyx_1 = 0;
-    __pyx_3 = PyNumber_Add(__pyx_v_size, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1521; goto __pyx_L1;}
+    PyTuple_SET_ITEM(__pyx_2, 0, __pyx_5);
+    __pyx_5 = 0;
+    __pyx_4 = PyNumber_Add(__pyx_v_size, __pyx_2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1521; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
     Py_DECREF(__pyx_v_shape);
-    __pyx_v_shape = __pyx_3;
-    __pyx_3 = 0;
+    __pyx_v_shape = __pyx_4;
+    __pyx_4 = 0;
   }
   __pyx_L3:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1523 */
-  __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
-  __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_zeros); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
-  __pyx_1 = PyTuple_New(2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1523 */
+  __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
+  __pyx_2 = PyObject_GetAttr(__pyx_5, __pyx_n_zeros); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
+  Py_DECREF(__pyx_5); __pyx_5 = 0;
+  __pyx_4 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
+  __pyx_5 = PyTuple_New(2); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
   Py_INCREF(__pyx_v_shape);
-  PyTuple_SET_ITEM(__pyx_1, 0, __pyx_v_shape);
-  PyTuple_SET_ITEM(__pyx_1, 1, __pyx_3);
-  __pyx_3 = 0;
-  __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_5, 0, __pyx_v_shape);
+  PyTuple_SET_ITEM(__pyx_5, 1, __pyx_4);
+  __pyx_4 = 0;
+  __pyx_4 = PyObject_CallObject(__pyx_2, __pyx_5); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  Py_DECREF(__pyx_5); __pyx_5 = 0;
   Py_DECREF(__pyx_v_multin);
-  __pyx_v_multin = __pyx_3;
-  __pyx_3 = 0;
+  __pyx_v_multin = __pyx_4;
+  __pyx_4 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1524 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1524 */
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_v_multin)));
   Py_DECREF(((PyObject *)arrayObject_mnarr));
   arrayObject_mnarr = ((PyArrayObject *)__pyx_v_multin);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1525 */
-  __pyx_v_mnix = ((long (*))arrayObject_mnarr->data);
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1525 */
+  __pyx_v_mnix = ((long *)arrayObject_mnarr->data);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1526 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1526 */
   __pyx_v_i = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1527 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1527 */
   while (1) {
-    __pyx_5 = (__pyx_v_i < PyArray_SIZE(arrayObject_mnarr));
-    if (!__pyx_5) break;
+    __pyx_3 = (__pyx_v_i < PyArray_SIZE(arrayObject_mnarr));
+    if (!__pyx_3) break;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1528 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1528 */
     __pyx_v_Sum = 1.0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1529 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1529 */
     __pyx_v_dn = __pyx_v_n;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1530 */
-    __pyx_4 = (__pyx_v_d - 1);
-    for (__pyx_v_j = 0; __pyx_v_j < __pyx_4; ++__pyx_v_j) {
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1530 */
+    __pyx_6 = (__pyx_v_d - 1);
+    for (__pyx_v_j = 0; __pyx_v_j < __pyx_6; ++__pyx_v_j) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1531 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1531 */
       (__pyx_v_mnix[(__pyx_v_i + __pyx_v_j)]) = rk_binomial(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,__pyx_v_dn,((__pyx_v_pix[__pyx_v_j]) / __pyx_v_Sum));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1532 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1532 */
       __pyx_v_dn = (__pyx_v_dn - (__pyx_v_mnix[(__pyx_v_i + __pyx_v_j)]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1533 */
-      __pyx_5 = (__pyx_v_dn <= 0);
-      if (__pyx_5) {
-
-        /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1534 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1533 */
+      __pyx_3 = (__pyx_v_dn <= 0);
+      if (__pyx_3) {
         goto __pyx_L7;
         goto __pyx_L8;
       }
       __pyx_L8:;
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1535 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1535 */
       __pyx_v_Sum = (__pyx_v_Sum - (__pyx_v_pix[__pyx_v_j]));
     }
     __pyx_L7:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1536 */
-    __pyx_5 = (__pyx_v_dn > 0);
-    if (__pyx_5) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1537 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1536 */
+    __pyx_3 = (__pyx_v_dn > 0);
+    if (__pyx_3) {
       (__pyx_v_mnix[((__pyx_v_i + __pyx_v_d) - 1)]) = __pyx_v_dn;
       goto __pyx_L9;
     }
     __pyx_L9:;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1539 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1539 */
     __pyx_v_i = (__pyx_v_i + __pyx_v_d);
   }
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1541 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1541 */
   Py_INCREF(__pyx_v_multin);
   __pyx_r = __pyx_v_multin;
   goto __pyx_L0;
@@ -8975,9 +8646,9 @@
   __pyx_r = Py_None; Py_INCREF(Py_None);
   goto __pyx_L0;
   __pyx_L1:;
-  Py_XDECREF(__pyx_1);
   Py_XDECREF(__pyx_2);
-  Py_XDECREF(__pyx_3);
+  Py_XDECREF(__pyx_4);
+  Py_XDECREF(__pyx_5);
   __Pyx_AddTraceback("mtrand.RandomState.multinomial");
   __pyx_r = 0;
   __pyx_L0:;
@@ -9000,8 +8671,8 @@
   long __pyx_v_totsize;
   PyArrayObject *__pyx_v_alpha_arr;
   PyArrayObject *__pyx_v_val_arr;
-  double (*__pyx_v_alpha_data);
-  double (*__pyx_v_val_data);
+  double *__pyx_v_alpha_data;
+  double *__pyx_v_val_data;
   long __pyx_v_i;
   long __pyx_v_j;
   double __pyx_v_acc;
@@ -9009,11 +8680,11 @@
   PyObject *__pyx_v_shape;
   PyObject *__pyx_v_diric;
   PyObject *__pyx_r;
-  PyObject *__pyx_1 = 0;
+  Py_ssize_t __pyx_1;
   PyObject *__pyx_2 = 0;
-  PyObject *__pyx_3 = 0;
-  long __pyx_4;
-  int __pyx_5;
+  int __pyx_3;
+  PyObject *__pyx_4 = 0;
+  PyObject *__pyx_5 = 0;
   static char *__pyx_argnames[] = {"alpha","size",0};
   __pyx_v_size = __pyx_k60;
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O|O", __pyx_argnames, &__pyx_v_alpha, &__pyx_v_size)) return 0;
@@ -9025,148 +8696,132 @@
   __pyx_v_shape = Py_None; Py_INCREF(Py_None);
   __pyx_v_diric = Py_None; Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1598 */
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1598; goto __pyx_L1;}
-  __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1598; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_alpha);
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_alpha);
-  __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1598; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_4 = PyInt_AsLong(__pyx_3); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1598; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_v_k = __pyx_4;
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1598 */
+  __pyx_1 = PyObject_Length(__pyx_v_alpha); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1598; goto __pyx_L1;}
+  __pyx_v_k = __pyx_1;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1599 */
-  __pyx_1 = PyArray_ContiguousFromObject(__pyx_v_alpha,NPY_DOUBLE,1,1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1599; goto __pyx_L1;}
-  Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_1)));
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1599 */
+  __pyx_2 = PyArray_ContiguousFromObject(__pyx_v_alpha,NPY_DOUBLE,1,1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1599; goto __pyx_L1;}
+  Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_2)));
   Py_DECREF(((PyObject *)__pyx_v_alpha_arr));
-  __pyx_v_alpha_arr = ((PyArrayObject *)__pyx_1);
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_v_alpha_arr = ((PyArrayObject *)__pyx_2);
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1600 */
-  __pyx_v_alpha_data = ((double (*))__pyx_v_alpha_arr->data);
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1600 */
+  __pyx_v_alpha_data = ((double *)__pyx_v_alpha_arr->data);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1602 */
-  __pyx_5 = __pyx_v_size == Py_None;
-  if (__pyx_5) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1603 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1602 */
+  __pyx_3 = __pyx_v_size == Py_None;
+  if (__pyx_3) {
     __pyx_2 = PyInt_FromLong(__pyx_v_k); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1603; goto __pyx_L1;}
-    __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1603; goto __pyx_L1;}
-    PyTuple_SET_ITEM(__pyx_3, 0, __pyx_2);
+    __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1603; goto __pyx_L1;}
+    PyTuple_SET_ITEM(__pyx_4, 0, __pyx_2);
     __pyx_2 = 0;
     Py_DECREF(__pyx_v_shape);
-    __pyx_v_shape = __pyx_3;
-    __pyx_3 = 0;
+    __pyx_v_shape = __pyx_4;
+    __pyx_4 = 0;
     goto __pyx_L2;
   }
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_type); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1604; goto __pyx_L1;}
-  __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1604; goto __pyx_L1;}
+  __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_type); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1604; goto __pyx_L1;}
+  __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1604; goto __pyx_L1;}
   Py_INCREF(__pyx_v_size);
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_size);
-  __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1604; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  PyTuple_SET_ITEM(__pyx_4, 0, __pyx_v_size);
+  __pyx_5 = PyObject_CallObject(__pyx_2, __pyx_4); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1604; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1604; goto __pyx_L1;}
-  __pyx_5 = __pyx_3 == __pyx_1;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  if (__pyx_5) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1605 */
-    __pyx_2 = PyInt_FromLong(__pyx_v_k); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1605; goto __pyx_L1;}
-    __pyx_3 = PyTuple_New(2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1605; goto __pyx_L1;}
+  Py_DECREF(__pyx_4); __pyx_4 = 0;
+  __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1604; goto __pyx_L1;}
+  __pyx_3 = __pyx_5 == __pyx_2;
+  Py_DECREF(__pyx_5); __pyx_5 = 0;
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  if (__pyx_3) {
+    __pyx_4 = PyInt_FromLong(__pyx_v_k); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1605; goto __pyx_L1;}
+    __pyx_5 = PyTuple_New(2); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1605; goto __pyx_L1;}
     Py_INCREF(__pyx_v_size);
-    PyTuple_SET_ITEM(__pyx_3, 0, __pyx_v_size);
-    PyTuple_SET_ITEM(__pyx_3, 1, __pyx_2);
-    __pyx_2 = 0;
+    PyTuple_SET_ITEM(__pyx_5, 0, __pyx_v_size);
+    PyTuple_SET_ITEM(__pyx_5, 1, __pyx_4);
+    __pyx_4 = 0;
     Py_DECREF(__pyx_v_shape);
-    __pyx_v_shape = __pyx_3;
-    __pyx_3 = 0;
+    __pyx_v_shape = __pyx_5;
+    __pyx_5 = 0;
     goto __pyx_L2;
   }
   /*else*/ {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1607 */
-    __pyx_1 = PyInt_FromLong(__pyx_v_k); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1607; goto __pyx_L1;}
-    __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1607; goto __pyx_L1;}
-    PyTuple_SET_ITEM(__pyx_2, 0, __pyx_1);
-    __pyx_1 = 0;
-    __pyx_3 = PyNumber_Add(__pyx_v_size, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1607; goto __pyx_L1;}
-    Py_DECREF(__pyx_2); __pyx_2 = 0;
+    __pyx_2 = PyInt_FromLong(__pyx_v_k); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1607; goto __pyx_L1;}
+    __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1607; goto __pyx_L1;}
+    PyTuple_SET_ITEM(__pyx_4, 0, __pyx_2);
+    __pyx_2 = 0;
+    __pyx_5 = PyNumber_Add(__pyx_v_size, __pyx_4); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1607; goto __pyx_L1;}
+    Py_DECREF(__pyx_4); __pyx_4 = 0;
     Py_DECREF(__pyx_v_shape);
-    __pyx_v_shape = __pyx_3;
-    __pyx_3 = 0;
+    __pyx_v_shape = __pyx_5;
+    __pyx_5 = 0;
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1609 */
-  __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
-  __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_zeros); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
-  __pyx_1 = PyObject_GetAttr(__pyx_3, __pyx_n_float64); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_3 = PyTuple_New(2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_shape);
-  PyTuple_SET_ITEM(__pyx_3, 0, __pyx_v_shape);
-  PyTuple_SET_ITEM(__pyx_3, 1, __pyx_1);
-  __pyx_1 = 0;
-  __pyx_1 = PyObject_CallObject(__pyx_2, __pyx_3); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1609 */
+  __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
+  __pyx_4 = PyObject_GetAttr(__pyx_2, __pyx_n_zeros); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  __pyx_5 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
+  __pyx_2 = PyObject_GetAttr(__pyx_5, __pyx_n_float64); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
+  Py_DECREF(__pyx_5); __pyx_5 = 0;
+  __pyx_5 = PyTuple_New(2); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
+  Py_INCREF(__pyx_v_shape);
+  PyTuple_SET_ITEM(__pyx_5, 0, __pyx_v_shape);
+  PyTuple_SET_ITEM(__pyx_5, 1, __pyx_2);
+  __pyx_2 = 0;
+  __pyx_2 = PyObject_CallObject(__pyx_4, __pyx_5); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1609; goto __pyx_L1;}
+  Py_DECREF(__pyx_4); __pyx_4 = 0;
+  Py_DECREF(__pyx_5); __pyx_5 = 0;
   Py_DECREF(__pyx_v_diric);
-  __pyx_v_diric = __pyx_1;
-  __pyx_1 = 0;
+  __pyx_v_diric = __pyx_2;
+  __pyx_2 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1610 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1610 */
   Py_INCREF(((PyObject *)((PyArrayObject *)__pyx_v_diric)));
   Py_DECREF(((PyObject *)__pyx_v_val_arr));
   __pyx_v_val_arr = ((PyArrayObject *)__pyx_v_diric);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1611 */
-  __pyx_v_val_data = ((double (*))__pyx_v_val_arr->data);
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1611 */
+  __pyx_v_val_data = ((double *)__pyx_v_val_arr->data);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1613 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1613 */
   __pyx_v_i = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1614 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1614 */
   __pyx_v_totsize = PyArray_SIZE(__pyx_v_val_arr);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1615 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1615 */
   while (1) {
-    __pyx_5 = (__pyx_v_i < __pyx_v_totsize);
-    if (!__pyx_5) break;
+    __pyx_3 = (__pyx_v_i < __pyx_v_totsize);
+    if (!__pyx_3) break;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1616 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1616 */
     __pyx_v_acc = 0.0;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1617 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1617 */
     for (__pyx_v_j = 0; __pyx_v_j < __pyx_v_k; ++__pyx_v_j) {
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1618 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1618 */
       (__pyx_v_val_data[(__pyx_v_i + __pyx_v_j)]) = rk_standard_gamma(((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state,(__pyx_v_alpha_data[__pyx_v_j]));
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1619 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1619 */
       __pyx_v_acc = (__pyx_v_acc + (__pyx_v_val_data[(__pyx_v_i + __pyx_v_j)]));
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1620 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1620 */
     __pyx_v_invacc = (1 / __pyx_v_acc);
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1621 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1621 */
     for (__pyx_v_j = 0; __pyx_v_j < __pyx_v_k; ++__pyx_v_j) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1622 */
       (__pyx_v_val_data[(__pyx_v_i + __pyx_v_j)]) = ((__pyx_v_val_data[(__pyx_v_i + __pyx_v_j)]) * __pyx_v_invacc);
     }
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1623 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1623 */
     __pyx_v_i = (__pyx_v_i + __pyx_v_k);
   }
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1625 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1625 */
   Py_INCREF(__pyx_v_diric);
   __pyx_r = __pyx_v_diric;
   goto __pyx_L0;
@@ -9174,9 +8829,9 @@
   __pyx_r = Py_None; Py_INCREF(Py_None);
   goto __pyx_L0;
   __pyx_L1:;
-  Py_XDECREF(__pyx_1);
   Py_XDECREF(__pyx_2);
-  Py_XDECREF(__pyx_3);
+  Py_XDECREF(__pyx_4);
+  Py_XDECREF(__pyx_5);
   __Pyx_AddTraceback("mtrand.RandomState.dirichlet");
   __pyx_r = 0;
   __pyx_L0:;
@@ -9190,7 +8845,6 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_n_hasattr;
 static PyObject *__pyx_n_copy;
 
 
@@ -9202,192 +8856,155 @@
   long __pyx_v_j;
   int __pyx_v_copy;
   PyObject *__pyx_r;
-  PyObject *__pyx_1 = 0;
+  Py_ssize_t __pyx_1;
   PyObject *__pyx_2 = 0;
   PyObject *__pyx_3 = 0;
-  long __pyx_4;
+  PyObject *__pyx_4 = 0;
   int __pyx_5;
   static char *__pyx_argnames[] = {"x",0};
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O", __pyx_argnames, &__pyx_v_x)) return 0;
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_x);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1636 */
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; goto __pyx_L1;}
-  __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_x);
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_x);
-  __pyx_3 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_1 = PyInt_FromLong(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; goto __pyx_L1;}
-  __pyx_2 = PyNumber_Subtract(__pyx_3, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
-  __pyx_4 = PyInt_AsLong(__pyx_2); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; goto __pyx_L1;}
-  Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_v_i = __pyx_4;
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1636 */
+  __pyx_1 = PyObject_Length(__pyx_v_x); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; goto __pyx_L1;}
+  __pyx_v_i = (__pyx_1 - 1);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1637 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1637 */
   /*try:*/ {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1638 */
-    __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_len); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
-    __pyx_1 = PyInt_FromLong(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
-    __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
-    __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
-    PyTuple_SET_ITEM(__pyx_1, 0, __pyx_2);
-    __pyx_2 = 0;
-    __pyx_2 = PyObject_CallObject(__pyx_3, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
-    Py_DECREF(__pyx_3); __pyx_3 = 0;
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
-    __pyx_4 = PyInt_AsLong(__pyx_2); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
+    __pyx_2 = PyInt_FromLong(0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
+    __pyx_3 = PyObject_GetItem(__pyx_v_x, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
-    __pyx_v_j = __pyx_4;
+    __pyx_1 = PyObject_Length(__pyx_3); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1638; goto __pyx_L2;}
+    Py_DECREF(__pyx_3); __pyx_3 = 0;
+    __pyx_v_j = __pyx_1;
   }
   goto __pyx_L3;
   __pyx_L2:;
-  Py_XDECREF(__pyx_3); __pyx_3 = 0;
-  Py_XDECREF(__pyx_1); __pyx_1 = 0;
   Py_XDECREF(__pyx_2); __pyx_2 = 0;
+  Py_XDECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1639 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1639 */
   /*except:*/ {
     __Pyx_AddTraceback("mtrand.shuffle");
-    __pyx_3 = __Pyx_GetExcValue(); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1639; goto __pyx_L1;}
-    Py_DECREF(__pyx_3); __pyx_3 = 0;
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1640 */
+    if (__Pyx_GetException(&__pyx_2, &__pyx_3, &__pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1639; goto __pyx_L1;}
     __pyx_v_j = 0;
+    Py_DECREF(__pyx_2); __pyx_2 = 0;
+    Py_DECREF(__pyx_3); __pyx_3 = 0;
+    Py_DECREF(__pyx_4); __pyx_4 = 0;
     goto __pyx_L3;
   }
   __pyx_L3:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1642 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1642 */
   __pyx_5 = (__pyx_v_j == 0);
   if (__pyx_5) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1644 */
     while (1) {
       __pyx_5 = (__pyx_v_i > 0);
       if (!__pyx_5) break;
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1645 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1645 */
       __pyx_v_j = rk_interval(__pyx_v_i,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state);
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1646 */
-      __pyx_1 = PyInt_FromLong(__pyx_v_j); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
-      __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
-      Py_DECREF(__pyx_1); __pyx_1 = 0;
-      __pyx_3 = PyInt_FromLong(__pyx_v_i); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
-      __pyx_1 = PyObject_GetItem(__pyx_v_x, __pyx_3); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1646 */
+      __pyx_2 = PyInt_FromLong(__pyx_v_j); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
+      __pyx_3 = PyObject_GetItem(__pyx_v_x, __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
+      Py_DECREF(__pyx_2); __pyx_2 = 0;
+      __pyx_4 = PyInt_FromLong(__pyx_v_i); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
+      __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_4); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
+      Py_DECREF(__pyx_4); __pyx_4 = 0;
+      __pyx_4 = PyInt_FromLong(__pyx_v_i); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
+      if (PyObject_SetItem(__pyx_v_x, __pyx_4, __pyx_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
+      Py_DECREF(__pyx_4); __pyx_4 = 0;
       Py_DECREF(__pyx_3); __pyx_3 = 0;
-      __pyx_3 = PyInt_FromLong(__pyx_v_i); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
+      __pyx_3 = PyInt_FromLong(__pyx_v_j); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
       if (PyObject_SetItem(__pyx_v_x, __pyx_3, __pyx_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
       Py_DECREF(__pyx_3); __pyx_3 = 0;
       Py_DECREF(__pyx_2); __pyx_2 = 0;
-      __pyx_2 = PyInt_FromLong(__pyx_v_j); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
-      if (PyObject_SetItem(__pyx_v_x, __pyx_2, __pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1646; goto __pyx_L1;}
-      Py_DECREF(__pyx_2); __pyx_2 = 0;
-      Py_DECREF(__pyx_1); __pyx_1 = 0;
 
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1647 */
+      /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1647 */
       __pyx_v_i = (__pyx_v_i - 1);
     }
     goto __pyx_L4;
   }
   /*else*/ {
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1650 */
-    __pyx_3 = __Pyx_GetName(__pyx_b, __pyx_n_hasattr); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
-    __pyx_1 = PyInt_FromLong(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
-    __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
-    __pyx_1 = PyTuple_New(2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
-    PyTuple_SET_ITEM(__pyx_1, 0, __pyx_2);
-    Py_INCREF(__pyx_n_copy);
-    PyTuple_SET_ITEM(__pyx_1, 1, __pyx_n_copy);
-    __pyx_2 = 0;
-    __pyx_2 = PyObject_CallObject(__pyx_3, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
-    Py_DECREF(__pyx_3); __pyx_3 = 0;
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
-    __pyx_5 = PyInt_AsLong(__pyx_2); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1650 */
+    __pyx_4 = PyInt_FromLong(0); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
+    __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_4); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
+    Py_DECREF(__pyx_4); __pyx_4 = 0;
+    __pyx_5 = PyObject_HasAttr(__pyx_2,__pyx_n_copy); if (__pyx_5 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
     __pyx_v_copy = __pyx_5;
 
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1651 */
+    /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1651 */
     __pyx_5 = __pyx_v_copy;
     if (__pyx_5) {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1652 */
       while (1) {
         __pyx_5 = (__pyx_v_i > 0);
         if (!__pyx_5) break;
 
-        /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1653 */
+        /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1653 */
         __pyx_v_j = rk_interval(__pyx_v_i,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state);
 
-        /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1654 */
+        /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1654 */
         __pyx_3 = PyInt_FromLong(__pyx_v_j); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
-        __pyx_1 = PyObject_GetItem(__pyx_v_x, __pyx_3); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
+        __pyx_4 = PyObject_GetItem(__pyx_v_x, __pyx_3); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
         Py_DECREF(__pyx_3); __pyx_3 = 0;
-        __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_copy); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
-        Py_DECREF(__pyx_1); __pyx_1 = 0;
+        __pyx_2 = PyObject_GetAttr(__pyx_4, __pyx_n_copy); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
+        Py_DECREF(__pyx_4); __pyx_4 = 0;
         __pyx_3 = PyObject_CallObject(__pyx_2, 0); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
         Py_DECREF(__pyx_2); __pyx_2 = 0;
-        __pyx_1 = PyInt_FromLong(__pyx_v_i); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
-        __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
-        Py_DECREF(__pyx_1); __pyx_1 = 0;
-        __pyx_1 = PyObject_GetAttr(__pyx_2, __pyx_n_copy); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
+        __pyx_4 = PyInt_FromLong(__pyx_v_i); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
+        __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_4); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
+        Py_DECREF(__pyx_4); __pyx_4 = 0;
+        __pyx_4 = PyObject_GetAttr(__pyx_2, __pyx_n_copy); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
         Py_DECREF(__pyx_2); __pyx_2 = 0;
-        __pyx_2 = PyObject_CallObject(__pyx_1, 0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
-        Py_DECREF(__pyx_1); __pyx_1 = 0;
-        __pyx_1 = PyInt_FromLong(__pyx_v_i); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
-        if (PyObject_SetItem(__pyx_v_x, __pyx_1, __pyx_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
-        Py_DECREF(__pyx_1); __pyx_1 = 0;
+        __pyx_2 = PyObject_CallObject(__pyx_4, 0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
+        Py_DECREF(__pyx_4); __pyx_4 = 0;
+        __pyx_4 = PyInt_FromLong(__pyx_v_i); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
+        if (PyObject_SetItem(__pyx_v_x, __pyx_4, __pyx_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
+        Py_DECREF(__pyx_4); __pyx_4 = 0;
         Py_DECREF(__pyx_3); __pyx_3 = 0;
         __pyx_3 = PyInt_FromLong(__pyx_v_j); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
         if (PyObject_SetItem(__pyx_v_x, __pyx_3, __pyx_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1654; goto __pyx_L1;}
         Py_DECREF(__pyx_3); __pyx_3 = 0;
         Py_DECREF(__pyx_2); __pyx_2 = 0;
 
-        /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1655 */
+        /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1655 */
         __pyx_v_i = (__pyx_v_i - 1);
       }
       goto __pyx_L7;
     }
     /*else*/ {
-
-      /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1657 */
       while (1) {
         __pyx_5 = (__pyx_v_i > 0);
         if (!__pyx_5) break;
 
-        /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1658 */
+        /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1658 */
         __pyx_v_j = rk_interval(__pyx_v_i,((struct __pyx_obj_6mtrand_RandomState *)__pyx_v_self)->internal_state);
 
-        /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1659 */
-        __pyx_1 = PyInt_FromLong(__pyx_v_j); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
-        __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
-        Py_DECREF(__pyx_1); __pyx_1 = 0;
-        __pyx_3 = PySequence_GetSlice(__pyx_2, 0, 0x7fffffff); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
+        /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1659 */
+        __pyx_4 = PyInt_FromLong(__pyx_v_j); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
+        __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_4); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
+        Py_DECREF(__pyx_4); __pyx_4 = 0;
+        __pyx_3 = PySequence_GetSlice(__pyx_2, 0, PY_SSIZE_T_MAX); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
         Py_DECREF(__pyx_2); __pyx_2 = 0;
-        __pyx_1 = PyInt_FromLong(__pyx_v_i); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
-        __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
-        Py_DECREF(__pyx_1); __pyx_1 = 0;
-        __pyx_1 = PySequence_GetSlice(__pyx_2, 0, 0x7fffffff); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
+        __pyx_4 = PyInt_FromLong(__pyx_v_i); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
+        __pyx_2 = PyObject_GetItem(__pyx_v_x, __pyx_4); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
+        Py_DECREF(__pyx_4); __pyx_4 = 0;
+        __pyx_4 = PySequence_GetSlice(__pyx_2, 0, PY_SSIZE_T_MAX); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
         Py_DECREF(__pyx_2); __pyx_2 = 0;
         __pyx_2 = PyInt_FromLong(__pyx_v_i); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
         if (PyObject_SetItem(__pyx_v_x, __pyx_2, __pyx_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
         Py_DECREF(__pyx_2); __pyx_2 = 0;
         Py_DECREF(__pyx_3); __pyx_3 = 0;
         __pyx_3 = PyInt_FromLong(__pyx_v_j); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
-        if (PyObject_SetItem(__pyx_v_x, __pyx_3, __pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
+        if (PyObject_SetItem(__pyx_v_x, __pyx_3, __pyx_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; goto __pyx_L1;}
         Py_DECREF(__pyx_3); __pyx_3 = 0;
-        Py_DECREF(__pyx_1); __pyx_1 = 0;
+        Py_DECREF(__pyx_4); __pyx_4 = 0;
 
-        /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1660 */
+        /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1660 */
         __pyx_v_i = (__pyx_v_i - 1);
       }
     }
@@ -9398,9 +9015,9 @@
   __pyx_r = Py_None; Py_INCREF(Py_None);
   goto __pyx_L0;
   __pyx_L1:;
-  Py_XDECREF(__pyx_1);
   Py_XDECREF(__pyx_2);
   Py_XDECREF(__pyx_3);
+  Py_XDECREF(__pyx_4);
   __Pyx_AddTraceback("mtrand.RandomState.shuffle");
   __pyx_r = 0;
   __pyx_L0:;
@@ -9421,81 +9038,67 @@
   PyObject *__pyx_1 = 0;
   PyObject *__pyx_2 = 0;
   PyObject *__pyx_3 = 0;
-  PyObject *__pyx_4 = 0;
-  int __pyx_5;
+  int __pyx_4;
   static char *__pyx_argnames[] = {"x",0};
   if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O", __pyx_argnames, &__pyx_v_x)) return 0;
   Py_INCREF(__pyx_v_self);
   Py_INCREF(__pyx_v_x);
   __pyx_v_arr = Py_None; Py_INCREF(Py_None);
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1668 */
-  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_isinstance); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
-  __pyx_2 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
-  __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
-  __pyx_4 = PyObject_GetAttr(__pyx_3, __pyx_n_integer); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  __pyx_3 = PyTuple_New(2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
-  PyTuple_SET_ITEM(__pyx_3, 0, __pyx_2);
-  PyTuple_SET_ITEM(__pyx_3, 1, __pyx_4);
-  __pyx_2 = 0;
-  __pyx_4 = 0;
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1668 */
+  __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_int); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
+  __pyx_2 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
+  __pyx_3 = PyObject_GetAttr(__pyx_2, __pyx_n_integer); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
   __pyx_2 = PyTuple_New(2); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
-  Py_INCREF(__pyx_v_x);
-  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_x);
+  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_1);
   PyTuple_SET_ITEM(__pyx_2, 1, __pyx_3);
+  __pyx_1 = 0;
   __pyx_3 = 0;
-  __pyx_4 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_4 = PyObject_IsInstance(__pyx_v_x,__pyx_2); if (__pyx_4 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
-  __pyx_5 = PyObject_IsTrue(__pyx_4); if (__pyx_5 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; goto __pyx_L1;}
-  Py_DECREF(__pyx_4); __pyx_4 = 0;
-  if (__pyx_5) {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1669 */
-    __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1669; goto __pyx_L1;}
-    __pyx_1 = PyObject_GetAttr(__pyx_3, __pyx_n_arange); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1669; goto __pyx_L1;}
-    Py_DECREF(__pyx_3); __pyx_3 = 0;
+  if (__pyx_4) {
+    __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1669; goto __pyx_L1;}
+    __pyx_3 = PyObject_GetAttr(__pyx_1, __pyx_n_arange); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1669; goto __pyx_L1;}
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
     __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1669; goto __pyx_L1;}
     Py_INCREF(__pyx_v_x);
     PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_x);
-    __pyx_4 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1669; goto __pyx_L1;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
+    __pyx_1 = PyObject_CallObject(__pyx_3, __pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1669; goto __pyx_L1;}
+    Py_DECREF(__pyx_3); __pyx_3 = 0;
     Py_DECREF(__pyx_2); __pyx_2 = 0;
     Py_DECREF(__pyx_v_arr);
-    __pyx_v_arr = __pyx_4;
-    __pyx_4 = 0;
+    __pyx_v_arr = __pyx_1;
+    __pyx_1 = 0;
     goto __pyx_L2;
   }
   /*else*/ {
-
-    /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1671 */
     __pyx_3 = __Pyx_GetName(__pyx_m, __pyx_n__sp); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1671; goto __pyx_L1;}
-    __pyx_1 = PyObject_GetAttr(__pyx_3, __pyx_n_array); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1671; goto __pyx_L1;}
+    __pyx_2 = PyObject_GetAttr(__pyx_3, __pyx_n_array); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1671; goto __pyx_L1;}
     Py_DECREF(__pyx_3); __pyx_3 = 0;
-    __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1671; goto __pyx_L1;}
+    __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1671; goto __pyx_L1;}
     Py_INCREF(__pyx_v_x);
-    PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_x);
-    __pyx_4 = PyObject_CallObject(__pyx_1, __pyx_2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1671; goto __pyx_L1;}
-    Py_DECREF(__pyx_1); __pyx_1 = 0;
+    PyTuple_SET_ITEM(__pyx_1, 0, __pyx_v_x);
+    __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1671; goto __pyx_L1;}
     Py_DECREF(__pyx_2); __pyx_2 = 0;
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
     Py_DECREF(__pyx_v_arr);
-    __pyx_v_arr = __pyx_4;
-    __pyx_4 = 0;
+    __pyx_v_arr = __pyx_3;
+    __pyx_3 = 0;
   }
   __pyx_L2:;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1672 */
-  __pyx_3 = PyObject_GetAttr(__pyx_v_self, __pyx_n_shuffle); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1672; goto __pyx_L1;}
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1672 */
+  __pyx_2 = PyObject_GetAttr(__pyx_v_self, __pyx_n_shuffle); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1672; goto __pyx_L1;}
   __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1672; goto __pyx_L1;}
   Py_INCREF(__pyx_v_arr);
   PyTuple_SET_ITEM(__pyx_1, 0, __pyx_v_arr);
-  __pyx_2 = PyObject_CallObject(__pyx_3, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1672; goto __pyx_L1;}
-  Py_DECREF(__pyx_3); __pyx_3 = 0;
-  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1672; goto __pyx_L1;}
   Py_DECREF(__pyx_2); __pyx_2 = 0;
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1673 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1673 */
   Py_INCREF(__pyx_v_arr);
   __pyx_r = __pyx_v_arr;
   goto __pyx_L0;
@@ -9506,7 +9109,6 @@
   Py_XDECREF(__pyx_1);
   Py_XDECREF(__pyx_2);
   Py_XDECREF(__pyx_3);
-  Py_XDECREF(__pyx_4);
   __Pyx_AddTraceback("mtrand.RandomState.permutation");
   __pyx_r = 0;
   __pyx_L0:;
@@ -9546,13 +9148,10 @@
   {&__pyx_n_get_state, "get_state"},
   {&__pyx_n_greater, "greater"},
   {&__pyx_n_gumbel, "gumbel"},
-  {&__pyx_n_hasattr, "hasattr"},
   {&__pyx_n_hypergeometric, "hypergeometric"},
   {&__pyx_n_int, "int"},
   {&__pyx_n_integer, "integer"},
-  {&__pyx_n_isinstance, "isinstance"},
   {&__pyx_n_laplace, "laplace"},
-  {&__pyx_n_len, "len"},
   {&__pyx_n_less, "less"},
   {&__pyx_n_less_equal, "less_equal"},
   {&__pyx_n_list, "list"},
@@ -9718,6 +9317,7 @@
 
 static PyObject *__pyx_tp_new_6mtrand_RandomState(PyTypeObject *t, PyObject *a, PyObject *k) {
   PyObject *o = (*t->tp_alloc)(t, 0);
+  if (!o) return 0;
   return o;
 }
 
@@ -9835,6 +9435,9 @@
   0, /*nb_true_divide*/
   0, /*nb_inplace_floor_divide*/
   0, /*nb_inplace_true_divide*/
+  #if Py_TPFLAGS_DEFAULT & Py_TPFLAGS_HAVE_INDEX
+  0, /*nb_index*/
+  #endif
 };
 
 static PySequenceMethods __pyx_tp_as_sequence_RandomState = {
@@ -9941,6 +9544,7 @@
   __pyx_init_filenames();
   __pyx_m = Py_InitModule4("mtrand", __pyx_methods, 0, 0, PYTHON_API_VERSION);
   if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 25; goto __pyx_L1;};
+  Py_INCREF(__pyx_m);
   __pyx_b = PyImport_AddModule("__builtin__");
   if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 25; goto __pyx_L1;};
   if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 25; goto __pyx_L1;};
@@ -9954,37 +9558,37 @@
   if (PyObject_SetAttrString(__pyx_m, "RandomState", (PyObject *)&__pyx_type_6mtrand_RandomState) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 468; goto __pyx_L1;}
   __pyx_ptype_6mtrand_RandomState = &__pyx_type_6mtrand_RandomState;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":119 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":119 */
   import_array();
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":121 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":121 */
   __pyx_1 = __Pyx_Import(__pyx_n_numpy, 0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 121; goto __pyx_L1;}
   if (PyObject_SetAttr(__pyx_m, __pyx_n__sp, __pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 121; goto __pyx_L1;}
   Py_DECREF(__pyx_1); __pyx_1 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":488 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":488 */
   Py_INCREF(Py_None);
   __pyx_k2 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":498 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":498 */
   Py_INCREF(Py_None);
   __pyx_k3 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":564 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":564 */
   Py_INCREF(Py_None);
   __pyx_k4 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":571 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":571 */
   Py_INCREF(Py_None);
   __pyx_k5 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":578 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":578 */
   Py_INCREF(Py_None);
   __pyx_k6 = Py_None;
   Py_INCREF(Py_None);
   __pyx_k7 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":623 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":623 */
   __pyx_1 = PyFloat_FromDouble(0.0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; goto __pyx_L1;}
   __pyx_k8 = __pyx_1;
   __pyx_1 = 0;
@@ -9994,17 +9598,17 @@
   Py_INCREF(Py_None);
   __pyx_k10 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":676 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":676 */
   Py_INCREF(Py_None);
   __pyx_k11 = Py_None;
   Py_INCREF(Py_None);
   __pyx_k12 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":689 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":689 */
   Py_INCREF(Py_None);
   __pyx_k13 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":696 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":696 */
   __pyx_3 = PyFloat_FromDouble(0.0); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; goto __pyx_L1;}
   __pyx_k14 = __pyx_3;
   __pyx_3 = 0;
@@ -10014,73 +9618,73 @@
   Py_INCREF(Py_None);
   __pyx_k16 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":719 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":719 */
   Py_INCREF(Py_None);
   __pyx_k17 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":746 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":746 */
   __pyx_5 = PyFloat_FromDouble(1.0); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; goto __pyx_L1;}
   __pyx_k18 = __pyx_5;
   __pyx_5 = 0;
   Py_INCREF(Py_None);
   __pyx_k19 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":767 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":767 */
   Py_INCREF(Py_None);
   __pyx_k20 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":774 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":774 */
   Py_INCREF(Py_None);
   __pyx_k21 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":794 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":794 */
   __pyx_6 = PyFloat_FromDouble(1.0); if (!__pyx_6) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 794; goto __pyx_L1;}
   __pyx_k22 = __pyx_6;
   __pyx_6 = 0;
   Py_INCREF(Py_None);
   __pyx_k23 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":820 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":820 */
   Py_INCREF(Py_None);
   __pyx_k24 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":847 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":847 */
   Py_INCREF(Py_None);
   __pyx_k25 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":883 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":883 */
   Py_INCREF(Py_None);
   __pyx_k26 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":904 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":904 */
   Py_INCREF(Py_None);
   __pyx_k27 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":932 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":932 */
   Py_INCREF(Py_None);
   __pyx_k28 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":939 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":939 */
   Py_INCREF(Py_None);
   __pyx_k29 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":960 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":960 */
   Py_INCREF(Py_None);
   __pyx_k30 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":984 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":984 */
   Py_INCREF(Py_None);
   __pyx_k31 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1005 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1005 */
   Py_INCREF(Py_None);
   __pyx_k32 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1026 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1026 */
   Py_INCREF(Py_None);
   __pyx_k33 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1047 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1047 */
   __pyx_7 = PyFloat_FromDouble(0.0); if (!__pyx_7) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1047; goto __pyx_L1;}
   __pyx_k34 = __pyx_7;
   __pyx_7 = 0;
@@ -10090,7 +9694,7 @@
   Py_INCREF(Py_None);
   __pyx_k36 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1069 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1069 */
   __pyx_9 = PyFloat_FromDouble(0.0); if (!__pyx_9) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1069; goto __pyx_L1;}
   __pyx_k37 = __pyx_9;
   __pyx_9 = 0;
@@ -10100,7 +9704,7 @@
   Py_INCREF(Py_None);
   __pyx_k39 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1091 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1091 */
   __pyx_11 = PyFloat_FromDouble(0.0); if (!__pyx_11) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1091; goto __pyx_L1;}
   __pyx_k40 = __pyx_11;
   __pyx_11 = 0;
@@ -10110,7 +9714,7 @@
   Py_INCREF(Py_None);
   __pyx_k42 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1113 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1113 */
   __pyx_13 = PyFloat_FromDouble(0.0); if (!__pyx_13) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; goto __pyx_L1;}
   __pyx_k43 = __pyx_13;
   __pyx_13 = 0;
@@ -10120,385 +9724,385 @@
   Py_INCREF(Py_None);
   __pyx_k45 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1142 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1142 */
   __pyx_15 = PyFloat_FromDouble(1.0); if (!__pyx_15) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1142; goto __pyx_L1;}
   __pyx_k46 = __pyx_15;
   __pyx_15 = 0;
   Py_INCREF(Py_None);
   __pyx_k47 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1164 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1164 */
   Py_INCREF(Py_None);
   __pyx_k48 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1192 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1192 */
   Py_INCREF(Py_None);
   __pyx_k49 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1229 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1229 */
   Py_INCREF(Py_None);
   __pyx_k50 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1261 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1261 */
   Py_INCREF(Py_None);
   __pyx_k51 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1296 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1296 */
   __pyx_16 = PyFloat_FromDouble(1.0); if (!__pyx_16) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1296; goto __pyx_L1;}
   __pyx_k52 = __pyx_16;
   __pyx_16 = 0;
   Py_INCREF(Py_None);
   __pyx_k53 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1316 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1316 */
   Py_INCREF(Py_None);
   __pyx_k54 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1337 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1337 */
   Py_INCREF(Py_None);
   __pyx_k55 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1364 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1364 */
   Py_INCREF(Py_None);
   __pyx_k56 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1409 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1409 */
   Py_INCREF(Py_None);
   __pyx_k57 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1435 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1435 */
   Py_INCREF(Py_None);
   __pyx_k58 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1493 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1493 */
   Py_INCREF(Py_None);
   __pyx_k59 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1543 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1543 */
   Py_INCREF(Py_None);
   __pyx_k60 = Py_None;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1675 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1675 */
   __pyx_17 = PyObject_CallObject(((PyObject*)__pyx_ptype_6mtrand_RandomState), 0); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1675; goto __pyx_L1;}
   if (PyObject_SetAttr(__pyx_m, __pyx_n__rand, __pyx_17) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1675; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1676 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1676 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1676; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_seed); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1676; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_seed, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1676; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1677 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1677 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1677; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_get_state); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1677; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_get_state, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1677; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1678 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1678 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1678; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_set_state); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1678; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_set_state, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1678; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1679 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1679 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1679; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_random_sample); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1679; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_random_sample, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1679; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1680 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1680 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1680; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_randint); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1680; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_randint, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1680; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1681 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1681 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1681; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_bytes); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1681; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_bytes, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1681; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1682 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1682 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1682; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_uniform); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1682; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_uniform, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1682; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1683 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1683 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1683; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_rand); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1683; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_rand, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1683; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1684 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1684 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1684; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_randn); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1684; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_randn, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1684; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1685 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1685 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1685; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_random_integers); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1685; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_random_integers, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1685; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1686 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1686 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1686; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_standard_normal); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1686; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_standard_normal, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1686; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1687 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1687 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1687; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_normal); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1687; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_normal, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1687; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1688 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1688 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1688; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_beta); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1688; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_beta, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1688; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1689 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1689 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1689; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_exponential); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1689; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_exponential, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1689; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1690 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1690 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1690; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_standard_exponential); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1690; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_standard_exponential, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1690; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1691 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1691 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1691; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_standard_gamma); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1691; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_standard_gamma, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1691; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1692 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1692 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1692; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_gamma); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1692; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_gamma, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1692; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1693 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1693 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_f); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_f, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1694 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1694 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1694; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_noncentral_f); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1694; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_noncentral_f, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1694; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1695 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1695 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1695; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_chisquare); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1695; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_chisquare, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1695; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1696 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1696 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1696; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_noncentral_chisquare); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1696; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_noncentral_chisquare, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1696; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1697 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1697 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1697; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_standard_cauchy); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1697; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_standard_cauchy, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1697; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1698 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1698 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1698; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_standard_t); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1698; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_standard_t, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1698; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1699 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1699 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1699; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_vonmises); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1699; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_vonmises, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1699; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1700 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1700 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1700; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_pareto); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1700; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_pareto, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1700; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1701 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1701 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1701; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_weibull); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1701; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_weibull, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1701; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1702 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1702 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1702; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_power); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1702; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_power, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1702; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1703 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1703 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1703; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_laplace); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1703; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_laplace, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1703; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1704 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1704 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1704; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_gumbel); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1704; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_gumbel, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1704; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1705 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1705 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1705; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_logistic); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1705; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_logistic, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1705; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1706 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1706 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1706; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_lognormal); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1706; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_lognormal, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1706; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1707 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1707 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1707; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_rayleigh); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1707; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_rayleigh, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1707; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1708 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1708 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1708; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_wald); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1708; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_wald, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1708; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1709 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1709 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1709; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_triangular); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1709; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_triangular, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1709; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1711 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1711 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1711; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_binomial); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1711; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_binomial, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1711; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1712 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1712 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1712; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_negative_binomial); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1712; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_negative_binomial, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1712; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1713 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1713 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1713; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_poisson); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1713; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_poisson, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1713; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1714 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1714 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1714; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_zipf); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1714; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_zipf, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1714; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1715 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1715 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1715; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_geometric); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1715; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_geometric, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1715; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1716 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1716 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1716; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_hypergeometric); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1716; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_hypergeometric, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1716; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1717 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1717 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1717; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_logseries); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1717; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_logseries, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1717; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1719 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1719 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1719; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_multivariate_normal); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1719; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_multivariate_normal, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1719; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1720 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1720 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1720; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_multinomial); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1720; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_multinomial, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1720; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1721 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1721 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1721; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_dirichlet); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1721; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_dirichlet, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1721; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1723 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1723 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1723; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_shuffle); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1723; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
   if (PyObject_SetAttr(__pyx_m, __pyx_n_shuffle, __pyx_18) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1723; goto __pyx_L1;}
   Py_DECREF(__pyx_18); __pyx_18 = 0;
 
-  /* "/home/stefan/work/scipy/numpy.patch/numpy/random/mtrand/mtrand.pyx":1724 */
+  /* "/Users/rkern/svn/numpy/numpy/random/mtrand/mtrand.pyx":1724 */
   __pyx_17 = __Pyx_GetName(__pyx_m, __pyx_n__rand); if (!__pyx_17) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1724; goto __pyx_L1;}
   __pyx_18 = PyObject_GetAttr(__pyx_17, __pyx_n_permutation); if (!__pyx_18) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1724; goto __pyx_L1;}
   Py_DECREF(__pyx_17); __pyx_17 = 0;
@@ -10542,11 +10146,14 @@
     PyObject **args, 
     PyObject **kwds,
     char *kwd_list[], 
-    int nargs,
+    Py_ssize_t nargs,
     PyObject **args2, 
-    PyObject **kwds2)
+    PyObject **kwds2,
+    char rqd_kwds[])
 {
     PyObject *x = 0, *args1 = 0, *kwds1 = 0;
+    int i;
+    char **p;
     
     if (args2)
         *args2 = 0;
@@ -10557,25 +10164,37 @@
         args1 = PyTuple_GetSlice(*args, 0, nargs);
         if (!args1)
             goto bad;
-        *args2 = PyTuple_GetSlice(*args, nargs, PyTuple_Size(*args));
+        *args2 = PyTuple_GetSlice(*args, nargs, PyTuple_GET_SIZE(*args));
         if (!*args2)
             goto bad;
     }
+    else if (PyTuple_GET_SIZE(*args) > nargs) {
+        int m = nargs;
+        int n = PyTuple_GET_SIZE(*args);
+        PyErr_Format(PyExc_TypeError,
+            "function takes at most %d positional arguments (%d given)",
+                m, n);
+        goto bad;
+    }
     else {
         args1 = *args;
         Py_INCREF(args1);
     }
     
+    if (rqd_kwds && !*kwds)
+            for (i = 0, p = kwd_list; *p; i++, p++)
+                if (rqd_kwds[i])
+                    goto missing_kwarg;
+    
     if (kwds2) {
         if (*kwds) {
-            char **p;
             kwds1 = PyDict_New();
-            if (!kwds)
+            if (!kwds1)
                 goto bad;
             *kwds2 = PyDict_Copy(*kwds);
             if (!*kwds2)
                 goto bad;
-            for (p = kwd_list; *p; p++) {
+            for (i = 0, p = kwd_list; *p; i++, p++) {
                 x = PyDict_GetItemString(*kwds, *p);
                 if (x) {
                     if (PyDict_SetItemString(kwds1, *p, x) < 0)
@@ -10583,6 +10202,8 @@
                     if (PyDict_DelItemString(*kwds2, *p) < 0)
                         goto bad;
                 }
+                else if (rqd_kwds && rqd_kwds[i])
+                    goto missing_kwarg;
             }
         }
         else {
@@ -10594,18 +10215,25 @@
     else {
         kwds1 = *kwds;
         Py_XINCREF(kwds1);
+        if (rqd_kwds && *kwds)
+            for (i = 0, p = kwd_list; *p; i++, p++)
+                if (rqd_kwds[i] && !PyDict_GetItemString(*kwds, *p))
+                        goto missing_kwarg;
     }
     
     *args = args1;
     *kwds = kwds1;
     return 0;
+missing_kwarg:
+    PyErr_Format(PyExc_TypeError,
+        "required keyword argument '%s' is missing", *p);
 bad:
     Py_XDECREF(args1);
     Py_XDECREF(kwds1);
-    if (*args2) {
+    if (args2) {
         Py_XDECREF(*args2);
     }
-    if (*kwds2) {
+    if (kwds2) {
         Py_XDECREF(*kwds2);
     }
     return -1;
@@ -10671,21 +10299,12 @@
         value = Py_None;
         Py_INCREF(value);
     }
-    /* Next, repeatedly, replace a tuple exception with its first item */
-    while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
-        PyObject *tmp = type;
-        type = PyTuple_GET_ITEM(type, 0);
-        Py_INCREF(type);
-        Py_DECREF(tmp);
-    }
-    if (PyString_Check(type)) {
-        if (PyErr_Warn(PyExc_DeprecationWarning,
-                "raising a string exception is deprecated"))
-            goto raise_error;
-    }
-    else if (PyType_Check(type) || PyClass_Check(type))
-        ; /*PyErr_NormalizeException(&type, &value, &tb);*/
-    else {
+    #if PY_VERSION_HEX < 0x02050000
+    if (!PyClass_Check(type))
+    #else
+    if (!PyType_Check(type))
+    #endif
+    {
         /* Raising an instance.  The value should be a dummy. */
         if (value != Py_None) {
             PyErr_SetString(PyExc_TypeError,
@@ -10695,11 +10314,25 @@
         /* Normalize to raise <class>, <instance> */
         Py_DECREF(value);
         value = type;
-        if (PyInstance_Check(type))
-            type = (PyObject*) ((PyInstanceObject*)type)->in_class;
-        else
+        #if PY_VERSION_HEX < 0x02050000
+            if (PyInstance_Check(type)) {
+                type = (PyObject*) ((PyInstanceObject*)type)->in_class;
+                Py_INCREF(type);
+            }
+            else {
+                PyErr_SetString(PyExc_TypeError,
+                    "raise: exception must be an old-style class or instance");
+                goto raise_error;
+            }
+        #else
             type = (PyObject*) type->ob_type;
-        Py_INCREF(type);
+            Py_INCREF(type);
+            if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+                PyErr_SetString(PyExc_TypeError,
+                    "raise: exception class must be a subclass of BaseException");
+                goto raise_error;
+            }
+        #endif
     }
     PyErr_Restore(type, value, tb);
     return;
@@ -10736,34 +10369,27 @@
         return -1;
 }
 
-static PyObject *__Pyx_GetExcValue(void) {
-    PyObject *type = 0, *value = 0, *tb = 0;
-    PyObject *result = 0;
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
     PyThreadState *tstate = PyThreadState_Get();
-    PyErr_Fetch(&type, &value, &tb);
-    PyErr_NormalizeException(&type, &value, &tb);
+    PyErr_Fetch(type, value, tb);
+    PyErr_NormalizeException(type, value, tb);
     if (PyErr_Occurred())
         goto bad;
-    if (!value) {
-        value = Py_None;
-        Py_INCREF(value);
-    }
+    Py_INCREF(*type);
+    Py_INCREF(*value);
+    Py_INCREF(*tb);
     Py_XDECREF(tstate->exc_type);
     Py_XDECREF(tstate->exc_value);
     Py_XDECREF(tstate->exc_traceback);
-    tstate->exc_type = type;
-    tstate->exc_value = value;
-    tstate->exc_traceback = tb;
-    result = value;
-    Py_XINCREF(result);
-    type = 0;
-    value = 0;
-    tb = 0;
+    tstate->exc_type = *type;
+    tstate->exc_value = *value;
+    tstate->exc_traceback = *tb;
+    return 0;
 bad:
-    Py_XDECREF(type);
-    Py_XDECREF(value);
-    Py_XDECREF(tb);
-    return result;
+    Py_XDECREF(*type);
+    Py_XDECREF(*value);
+    Py_XDECREF(*tb);
+    return -1;
 }
 
 static int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
@@ -10798,31 +10424,18 @@
     return 0;
 }
 
+#ifndef __PYX_HAVE_RT_ImportType
+#define __PYX_HAVE_RT_ImportType
 static PyTypeObject *__Pyx_ImportType(char *module_name, char *class_name, 
     long size) 
 {
-    PyObject *py_module_name = 0;
-    PyObject *py_class_name = 0;
-    PyObject *py_name_list = 0;
     PyObject *py_module = 0;
     PyObject *result = 0;
     
-    py_module_name = PyString_FromString(module_name);
-    if (!py_module_name)
-        goto bad;
-    py_class_name = PyString_FromString(class_name);
-    if (!py_class_name)
-        goto bad;
-    py_name_list = PyList_New(1);
-    if (!py_name_list)
-        goto bad;
-    Py_INCREF(py_class_name);
-    if (PyList_SetItem(py_name_list, 0, py_class_name) < 0)
-        goto bad;
-    py_module = __Pyx_Import(py_module_name, py_name_list);
+    py_module = __Pyx_ImportModule(module_name);
     if (!py_module)
         goto bad;
-    result = PyObject_GetAttr(py_module, py_class_name);
+    result = PyObject_GetAttrString(py_module, class_name);
     if (!result)
         goto bad;
     if (!PyType_Check(result)) {
@@ -10837,17 +10450,28 @@
             module_name, class_name);
         goto bad;
     }
-    goto done;
+    return (PyTypeObject *)result;
 bad:
     Py_XDECREF(result);
-    result = 0;
-done:
-    Py_XDECREF(py_module_name);
-    Py_XDECREF(py_class_name);
-    Py_XDECREF(py_name_list);
-    return (PyTypeObject *)result;
+    return 0;
 }
+#endif
 
+#ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(char *name) {
+    PyObject *py_name = 0;
+    
+    py_name = PyString_FromString(name);
+    if (!py_name)
+        goto bad;
+    return PyImport_Import(py_name);
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"

Modified: trunk/numpy/random/mtrand/mtrand.pyx
===================================================================
--- trunk/numpy/random/mtrand/mtrand.pyx	2008-02-12 18:19:37 UTC (rev 4789)
+++ trunk/numpy/random/mtrand/mtrand.pyx	2008-02-12 21:31:58 UTC (rev 4790)
@@ -1470,7 +1470,7 @@
         # Create a matrix of independent standard normally distributed random
         # numbers. The matrix has rows with the same length as mean and as
         # many rows are necessary to form a matrix of shape final_shape.
-        x = standard_normal(_sp.multiply.reduce(final_shape))
+        x = self.standard_normal(_sp.multiply.reduce(final_shape))
         x.shape = (_sp.multiply.reduce(final_shape[0:len(final_shape)-1]),
                    mean.shape[0])
         # Transform matrix of standard normals into matrix where each row



From numpy-svn at scipy.org  Tue Feb 12 17:13:08 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 16:13:08 -0600 (CST)
Subject: [Numpy-svn] r4791 - trunk/numpy/lib/tests
Message-ID: <20080212221308.0AA5139C126@new.scipy.org>

Author: chris.burns
Date: 2008-02-12 16:13:00 -0600 (Tue, 12 Feb 2008)
New Revision: 4791

Added:
   trunk/numpy/lib/tests/test__datasource.py
Log:
Add datasource test file that didn't make it in the move from scipy.io to numpy.lib.

Added: trunk/numpy/lib/tests/test__datasource.py
===================================================================
--- trunk/numpy/lib/tests/test__datasource.py	2008-02-12 21:31:58 UTC (rev 4790)
+++ trunk/numpy/lib/tests/test__datasource.py	2008-02-12 22:13:00 UTC (rev 4791)
@@ -0,0 +1,248 @@
+
+import bz2
+import gzip
+import os
+import sys
+import struct
+from tempfile import mkdtemp, mkstemp, NamedTemporaryFile
+from shutil import rmtree
+from urlparse import urlparse
+
+from numpy.testing import *
+
+import numpy.lib._datasource as datasource
+
+def urlopen_stub(url, data=None):
+    '''Stub to replace urlopen for testing.'''
+    if url == valid_httpurl():
+        tmpfile = NamedTemporaryFile(prefix='urltmp_')
+        return tmpfile
+    else:
+        raise datasource.URLError('Name or service not known')
+
+# Rebind urlopen during testing.  For a 'real' test, uncomment the rebinding
+# below.
+datasource.urlopen = urlopen_stub
+
+# A valid website for more robust testing
+http_path = 'http://www.google.com/'
+http_file = 'index.html'
+
+http_fakepath = 'http://fake.abc.web/site/'
+http_fakefile = 'fake.txt'
+
+magic_line = 'three is the magic number'
+
+
+# Utility functions used by many TestCases
+def valid_textfile(filedir):
+    # Generate and return a valid temporary file.
+    fd, path = mkstemp(suffix='.txt', prefix='dstmp_', dir=filedir, text=True)
+    os.close(fd)
+    return path
+
+def invalid_textfile(filedir):
+    # Generate and return an invalid filename.
+    fd, path = mkstemp(suffix='.txt', prefix='dstmp_',  dir=filedir)
+    os.close(fd)
+    os.remove(path)
+    return path
+
+def valid_httpurl():
+    return http_path+http_file
+
+def invalid_httpurl():
+    return http_fakepath+http_fakefile
+
+def valid_baseurl():
+    return http_path
+
+def invalid_baseurl():
+    return http_fakepath
+
+def valid_httpfile():
+    return http_file
+
+def invalid_httpfile():
+    return http_fakefile
+
+class TestDataSourceOpen(NumpyTestCase):
+    def setUp(self):
+        self.tmpdir = mkdtemp()
+        self.ds = datasource.DataSource(self.tmpdir)
+
+    def tearDown(self):
+        rmtree(self.tmpdir)
+        del self.ds
+
+    def test_ValidHTTP(self):
+        assert self.ds.open(valid_httpurl())
+
+    def test_InvalidHTTP(self):
+        self.assertRaises(IOError, self.ds.open, invalid_httpurl())
+
+    def test_ValidFile(self):
+        local_file = valid_textfile(self.tmpdir)
+        assert self.ds.open(local_file)
+
+    def test_InvalidFile(self):
+        invalid_file = invalid_textfile(self.tmpdir)
+        self.assertRaises(IOError, self.ds.open, invalid_file)
+
+    def test_ValidGzipFile(self):
+        # Test datasource's internal file_opener for Gzip files.
+        filepath = os.path.join(self.tmpdir, 'foobar.txt.gz')
+        fp = gzip.open(filepath, 'w')
+        fp.write(magic_line)
+        fp.close()
+        fp = self.ds.open(filepath)
+        result = fp.readline()
+        fp.close()
+        self.assertEqual(magic_line, result)
+
+    def test_ValidBz2File(self):
+        # Test datasource's internal file_opener for BZip2 files.
+        filepath = os.path.join(self.tmpdir, 'foobar.txt.bz2')
+        fp = bz2.BZ2File(filepath, 'w')
+        fp.write(magic_line)
+        fp.close()
+        fp = self.ds.open(filepath)
+        result = fp.readline()
+        fp.close()
+        self.assertEqual(magic_line, result)
+
+
+class TestDataSourceExists(NumpyTestCase):
+    def setUp(self):
+        self.tmpdir = mkdtemp()
+        self.ds = datasource.DataSource(self.tmpdir)
+
+    def tearDown(self):
+        rmtree(self.tmpdir)
+        del self.ds
+
+    def test_ValidHTTP(self):
+        assert self.ds.exists(valid_httpurl())
+
+    def test_InvalidHTTP(self):
+        self.assertEqual(self.ds.exists(invalid_httpurl()), False)
+
+    def test_ValidFile(self):
+        # Test valid file in destpath
+        tmpfile = valid_textfile(self.tmpdir)
+        assert self.ds.exists(tmpfile)
+        # Test valid local file not in destpath
+        localdir = mkdtemp()
+        tmpfile = valid_textfile(localdir)
+        assert self.ds.exists(tmpfile)
+        rmtree(localdir)
+
+    def test_InvalidFile(self):
+        tmpfile = invalid_textfile(self.tmpdir)
+        self.assertEqual(self.ds.exists(tmpfile), False)
+
+
+class TestDataSourceAbspath(NumpyTestCase):
+    def setUp(self):
+        self.tmpdir = mkdtemp()
+        self.ds = datasource.DataSource(self.tmpdir)
+
+    def tearDown(self):
+        rmtree(self.tmpdir)
+        del self.ds
+
+    def test_ValidHTTP(self):
+        scheme, netloc, upath, pms, qry, frg = urlparse(valid_httpurl())
+        local_path = os.path.join(self.tmpdir, netloc, upath.strip(os.sep))
+        self.assertEqual(local_path, self.ds.abspath(valid_httpurl()))
+
+    def test_ValidFile(self):
+        tmpfile = valid_textfile(self.tmpdir)
+        tmpfilename = os.path.split(tmpfile)[-1]
+        # Test with filename only
+        self.assertEqual(tmpfile, self.ds.abspath(os.path.split(tmpfile)[-1]))
+        # Test filename with complete path
+        self.assertEqual(tmpfile, self.ds.abspath(tmpfile))
+
+    def test_InvalidHTTP(self):
+        scheme, netloc, upath, pms, qry, frg = urlparse(invalid_httpurl())
+        invalidhttp = os.path.join(self.tmpdir, netloc, upath.strip(os.sep))
+        self.assertNotEqual(invalidhttp, self.ds.abspath(valid_httpurl()))
+
+    def test_InvalidFile(self):
+        invalidfile = valid_textfile(self.tmpdir)
+        tmpfile = valid_textfile(self.tmpdir)
+        tmpfilename = os.path.split(tmpfile)[-1]
+        # Test with filename only
+        self.assertNotEqual(invalidfile, self.ds.abspath(tmpfilename))
+        # Test filename with complete path
+        self.assertNotEqual(invalidfile, self.ds.abspath(tmpfile))
+
+
+class TestRespositoryAbspath(NumpyTestCase):
+    def setUp(self):
+        self.tmpdir = mkdtemp()
+        self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
+
+    def tearDown(self):
+        rmtree(self.tmpdir)
+        del self.repos
+
+    def test_ValidHTTP(self):
+        scheme, netloc, upath, pms, qry, frg = urlparse(valid_httpurl())
+        local_path = os.path.join(self.repos._destpath, netloc, \
+                                  upath.strip(os.sep))
+        filepath = self.repos.abspath(valid_httpfile())
+        self.assertEqual(local_path, filepath)
+
+
+class TestRepositoryExists(NumpyTestCase):
+    def setUp(self):
+        self.tmpdir = mkdtemp()
+        self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
+
+    def tearDown(self):
+        rmtree(self.tmpdir)
+        del self.repos
+
+    def test_ValidFile(self):
+        # Create local temp file
+        tmpfile = valid_textfile(self.tmpdir)
+        assert self.repos.exists(tmpfile)
+
+    def test_InvalidFile(self):
+        tmpfile = invalid_textfile(self.tmpdir)
+        self.assertEqual(self.repos.exists(tmpfile), False)
+
+    def test_RemoveHTTPFile(self):
+        assert self.repos.exists(valid_httpurl())
+
+    def test_CachedHTTPFile(self):
+        localfile = valid_httpurl()
+        # Create a locally cached temp file with an URL based
+        # directory structure.  This is similar to what Repository.open
+        # would do.
+        scheme, netloc, upath, pms, qry, frg = urlparse(localfile)
+        local_path = os.path.join(self.repos._destpath, netloc)
+        os.mkdir(local_path, 0700)
+        tmpfile = valid_textfile(local_path)
+        assert self.repos.exists(tmpfile)
+
+
+class TestOpenFunc(NumpyTestCase):
+    def setUp(self):
+        self.tmpdir = mkdtemp()
+
+    def tearDown(self):
+        rmtree(self.tmpdir)
+
+    def test_DataSourceOpen(self):
+        local_file = valid_textfile(self.tmpdir)
+        # Test case where destpath is passed in
+        assert datasource.open(local_file, destpath=self.tmpdir)
+        # Test case where default destpath is used
+        assert datasource.open(local_file)
+
+
+if __name__ == "__main__":
+    NumpyTest().run()



From numpy-svn at scipy.org  Tue Feb 12 21:16:08 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 20:16:08 -0600 (CST)
Subject: [Numpy-svn] r4792 - trunk/numpy/lib
Message-ID: <20080213021608.D8EE939C247@new.scipy.org>

Author: matthew.brett at gmail.com
Date: 2008-02-12 20:16:05 -0600 (Tue, 12 Feb 2008)
New Revision: 4792

Modified:
   trunk/numpy/lib/function_base.py
Log:
New implementation of median allowing axis, out keywords

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-12 22:13:00 UTC (rev 4791)
+++ trunk/numpy/lib/function_base.py	2008-02-13 02:16:05 UTC (rev 4792)
@@ -1197,15 +1197,97 @@
     b.sort(0)
     return b
 
-def median(m):
-    """median(m) returns a median of m along the first dimension of m.
+def median(a, axis=0, out=None, overwrite_input=False):
+    """Compute the median along the specified axis.
+
+    Returns the median of the array elements.  The median is taken
+    over the first axis of the array by default, otherwise over
+    the specified axis.
+
+    Parameters
+    ----------
+    axis : {int, None}, optional
+        Axis along which the medians are computed. The default is to
+        compute the median along the first dimension.  axis=None
+        returns the median of the flattened array
+
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary.
+
+    overwrite_input : {False, True}, optional
+       If True, then allow use of memory of input array (a) for
+       calculations. The input array will be modified by the call to
+       median. This will save memory when you do not need to preserve
+       the contents of the input array. Treat the input as undefined,
+       but it will probably be fully or partially sorted. Default is
+       False
+
+    Returns
+    -------
+    median : ndarray.
+        A new array holding the result is returned unless out is
+        specified, in which case a reference to out is returned.
+        Return datatype is float64 for ints and floats smaller than
+        float64, or the input datatype otherwise.
+
+    SeeAlso
+    -------
+    mean
+
+    Notes
+    -----
+    Given a vector V length N, the median of V is the middle value of
+    a sorted copy of V (Vs) - i.e. Vs[(N-1)/2], when N is odd. It is
+    the mean of the two middle values of Vs, when N is even.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # import numpy median as median
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> median(a)
+    array([ 6.5,  4.5,  2.5])
+    >>> median(a, axis=None)
+    3.5
+    >>> median(a, axis=1)
+    array([ 7.,  2.])
+    >>> m = median(a)
+    >>> out = np.zeros_like(m)
+    >>> median(a, out=m)
+    array([ 6.5,  4.5,  2.5])
+    >>> m
+    array([ 6.5,  4.5,  2.5])
+    >>> median(a, axis=1, overwrite_input=True)
+    array([ 7.,  2.])
+    >>> a # modified, undefined, sorted in this case
+    array([[ 4,  7, 10],
+           [ 1,  2,  3]])
     """
-    sorted = msort(m)
-    index = int(sorted.shape[0]/2)
-    if sorted.shape[0] % 2 == 1:
-        return sorted[index]
+    if overwrite_input:
+        if axis is None:
+            a.ravel.sort()
+        else:
+            a.sort(axis=axis)
+        sorted = a
     else:
-        return (sorted[index-1]+sorted[index])/2.0
+        sorted = sort(a, axis=axis)
+    if axis is None:
+        axis = 0
+    indexer = [slice(None)] * sorted.ndim
+    index = int(sorted.shape[axis]/2)
+    if sorted.shape[axis] % 2 == 1:
+        # index with slice to allow mean (below) to work
+        indexer[axis] = slice(index, index+1)
+    else:
+        indexer[axis] = slice(index-1, index+1)
+    # Use mean in odd and even case to coerce data type
+    # and check, use out array.
+    return mean(sorted[indexer], axis=axis, out=out)
 
 def trapz(y, x=None, dx=1.0, axis=-1):
     """Integrate y(x) using samples along the given axis and the composite



From numpy-svn at scipy.org  Tue Feb 12 21:27:01 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 20:27:01 -0600 (CST)
Subject: [Numpy-svn] r4793 - trunk/numpy/lib
Message-ID: <20080213022701.4A31939C247@new.scipy.org>

Author: matthew.brett at gmail.com
Date: 2008-02-12 20:26:58 -0600 (Tue, 12 Feb 2008)
New Revision: 4793

Modified:
   trunk/numpy/lib/function_base.py
Log:
Fix, uncomment import in median doctest

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-13 02:16:05 UTC (rev 4792)
+++ trunk/numpy/lib/function_base.py	2008-02-13 02:26:58 UTC (rev 4793)
@@ -1245,7 +1245,7 @@
     Examples
     --------
     >>> import numpy as np
-    >>> # import numpy median as median
+    >>> from numpy import median
     >>> a = np.array([[10, 7, 4], [3, 2, 1]])
     >>> a
     array([[10,  7,  4],



From numpy-svn at scipy.org  Tue Feb 12 21:44:47 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 20:44:47 -0600 (CST)
Subject: [Numpy-svn] r4794 - in trunk/numpy: core lib
Message-ID: <20080213024447.B85CA39C07A@new.scipy.org>

Author: matthew.brett at gmail.com
Date: 2008-02-12 20:44:43 -0600 (Tue, 12 Feb 2008)
New Revision: 4794

Modified:
   trunk/numpy/core/defmatrix.py
   trunk/numpy/lib/function_base.py
Log:
Fix missing mean for median calculation, missing dtype from defmatrix mean signature

Modified: trunk/numpy/core/defmatrix.py
===================================================================
--- trunk/numpy/core/defmatrix.py	2008-02-13 02:26:58 UTC (rev 4793)
+++ trunk/numpy/core/defmatrix.py	2008-02-13 02:44:43 UTC (rev 4794)
@@ -266,7 +266,7 @@
         """
         return N.ndarray.sum(self, axis, dtype, out)._align(axis)
 
-    def mean(self, axis=None, out=None):
+    def mean(self, axis=None, dtype=None, out=None):
         """Compute the mean along the specified axis.
 
         Returns the average of the array elements.  The average is taken over
@@ -304,7 +304,7 @@
         The mean is the sum of the elements along the axis divided by the
         number of elements.
         """
-        return N.ndarray.mean(self, axis, out)._align(axis)
+        return N.ndarray.mean(self, axis, dtype, out)._align(axis)
 
     def std(self, axis=None, dtype=None, out=None):
         """Compute the standard deviation along the specified axis.

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-13 02:26:58 UTC (rev 4793)
+++ trunk/numpy/lib/function_base.py	2008-02-13 02:44:43 UTC (rev 4794)
@@ -20,7 +20,7 @@
      integer, isscalar
 from numpy.core.umath import pi, multiply, add, arctan2,  \
      frompyfunc, isnan, cos, less_equal, sqrt, sin, mod, exp, log10
-from numpy.core.fromnumeric import ravel, nonzero, choose, sort
+from numpy.core.fromnumeric import ravel, nonzero, choose, sort, mean
 from numpy.core.numerictypes import typecodes
 from numpy.lib.shape_base import atleast_1d, atleast_2d
 from numpy.lib.twodim_base import diag



From numpy-svn at scipy.org  Tue Feb 12 21:54:51 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 20:54:51 -0600 (CST)
Subject: [Numpy-svn] r4795 - trunk/numpy/core/src
Message-ID: <20080213025451.08F7939C07A@new.scipy.org>

Author: charris
Date: 2008-02-12 20:54:50 -0600 (Tue, 12 Feb 2008)
New Revision: 4795

Modified:
   trunk/numpy/core/src/multiarraymodule.c
Log:
Fix some indentation.


Modified: trunk/numpy/core/src/multiarraymodule.c
===================================================================
--- trunk/numpy/core/src/multiarraymodule.c	2008-02-13 02:44:43 UTC (rev 4794)
+++ trunk/numpy/core/src/multiarraymodule.c	2008-02-13 02:54:50 UTC (rev 4795)
@@ -2388,13 +2388,13 @@
     PyArray_SortFunc *sort;
     BEGIN_THREADS_DEF
 
-        it = (PyArrayIterObject *)PyArray_IterAllButAxis((PyObject *)op, &axis);
+    it = (PyArrayIterObject *)PyArray_IterAllButAxis((PyObject *)op, &axis);
     swap = !PyArray_ISNOTSWAPPED(op);
     if (it == NULL) return -1;
 
     NPY_BEGIN_THREADS_DESCR(op->descr)
 
-        sort = op->descr->f->sort[which];
+    sort = op->descr->f->sort[which];
     size = it->size;
     N = op->dimensions[axis];
     elsize = op->descr->elsize;
@@ -2454,7 +2454,7 @@
     PyArray_ArgSortFunc *argsort;
     BEGIN_THREADS_DEF
 
-        ret = PyArray_New(op->ob_type, op->nd,
+    ret = PyArray_New(op->ob_type, op->nd,
                           op->dimensions, PyArray_INTP,
                           NULL, NULL, 0, 0, (PyObject *)op);
     if (ret == NULL) return NULL;
@@ -2467,7 +2467,7 @@
 
     NPY_BEGIN_THREADS_DESCR(op->descr)
 
-        argsort = op->descr->f->argsort[which];
+    argsort = op->descr->f->argsort[which];
     size = it->size;
     N = op->dimensions[axis];
     elsize = op->descr->elsize;



From numpy-svn at scipy.org  Tue Feb 12 21:56:52 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 20:56:52 -0600 (CST)
Subject: [Numpy-svn] r4796 - trunk/numpy/core/src
Message-ID: <20080213025652.3292639C07A@new.scipy.org>

Author: charris
Date: 2008-02-12 20:56:50 -0600 (Tue, 12 Feb 2008)
New Revision: 4796

Modified:
   trunk/numpy/core/src/_sortmodule.c.src
Log:
Add type specific quicksort for strings and unicode in sort and argsort methods.


Modified: trunk/numpy/core/src/_sortmodule.c.src
===================================================================
--- trunk/numpy/core/src/_sortmodule.c.src	2008-02-13 02:54:50 UTC (rev 4795)
+++ trunk/numpy/core/src/_sortmodule.c.src	2008-02-13 02:56:50 UTC (rev 4796)
@@ -41,43 +41,11 @@
 #define STRING_LT(pa, pb, len) (compare_string(pa, pb, len) < 0)
 #define STRING_LE(pa, pb, len) (compare_string(pa, pb, len) <= 0)
 #define STRING_EQ(pa, pb, len) (compare_string(pa, pb, len) == 0)
-#define STRING_SWAP(pa, pb, n) {int i; for(i = 0; i < n; ++i) SWAP(pa[i], pb[i]);}
-#define STRING_COPY(pa, pb, n) {int i; for(i = 0; i < n; ++i) pa[i] = pb[i];}
 #define UNICODE_LT(pa, pb, len) (compare_ucs4(pa, pb, len) < 0)
 #define UNICODE_LE(pa, pb, len) (compare_ucs4(pa, pb, len) <= 0)
 #define UNICODE_EQ(pa, pb, len) (compare_ucs4(pa, pb, len) == 0)
 
-#include <stdio.h>
 
-static int inline
-compare_string(char *s1, char *s2, size_t len)
-{
-    const unsigned char *c1 = (unsigned char *)s1;
-    const unsigned char *c2 = (unsigned char *)s2;
-    size_t i;
-
-    for(i = 0; i < len; ++i) {
-        if (c1[i] != c2[i]) {
-            return (c1[i] > c2[i]) ? 1 : -1;
-        }
-    }
-    return 0;
-}
-
-
-static int inline
-compare_ucs4(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)
-{
-    size_t i;
-
-    for(i = 0; i < len; ++i) {
-        if (s1[i] != s2[i]) {
-            return (s1[i] > s2[i]) ? 1 : -1;
-        }
-    }
-    return 0;
-}
-
 /**begin repeat
    #TYPE=BOOL,BYTE,UBYTE,SHORT,USHORT,INT,UINT,LONG,ULONG,LONGLONG,ULONGLONG,FLOAT,DOUBLE,LONGDOUBLE,CFLOAT,CDOUBLE,CLONGDOUBLE#
    #type=Bool,byte,ubyte,short,ushort,int,uint,long,ulong,longlong,ulonglong,float,double,longdouble,cfloat,cdouble,clongdouble#
@@ -407,12 +375,212 @@
 }
 /**end repeat**/
 
+/*
+ * Subroutines that will hopefully be inlined when the code
+ * for strings and unicode is compiled with proper flags.
+ */
+
+static int
+compare_string(char *s1, char *s2, size_t len)
+{
+    const unsigned char *c1 = (unsigned char *)s1;
+    const unsigned char *c2 = (unsigned char *)s2;
+    size_t i;
+
+    for(i = 0; i < len; ++i) {
+        if (c1[i] != c2[i]) {
+            return (c1[i] > c2[i]) ? 1 : -1;
+        }
+    }
+    return 0;
+}
+
+static void
+copy_string(char *s1, char *s2, size_t len)
+{
+    while(len--) {
+        *s1++ = *s2++;
+    }
+}
+
+static void
+swap_string(char *s1, char *s2, size_t len)
+{
+    while(len--) {
+        const char t = *s1;
+        *s1++ = *s2;
+        *s2++ = t;
+    }
+}
+
+
+static int
+compare_ucs4(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)
+{
+    size_t i;
+
+    for(i = 0; i < len; ++i) {
+        if (s1[i] != s2[i]) {
+            return (s1[i] > s2[i]) ? 1 : -1;
+        }
+    }
+    return 0;
+}
+
+
+static void
+copy_ucs4(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)
+{
+    while(len--) {
+        *s1++ = *s2++;
+    }
+}
+
+
+static void
+swap_ucs4(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)
+{
+    while(len--) {
+        const npy_ucs4 t = *s1;
+        *s1++ = *s2;
+        *s2++ = t;
+    }
+}
+
 /**begin repeat
    #TYPE=STRING, UNICODE#
    #type=char, PyArray_UCS4#
    #lessthan=STRING_LT, UNICODE_LT#
    #lessequal=STRING_LE, UNICODE_LE#
+   #swap=swap_string, swap_ucs4#
+   #copy=copy_string, copy_ucs4#
 **/
+
+static int
+ at TYPE@_quicksort(@type@ *start, intp num, PyArrayObject *arr)
+{
+    const size_t len = arr->descr->elsize/sizeof(@type@);
+    @type@ *vp = malloc(arr->descr->elsize);
+    @type@ *pl = start;
+    @type@ *pr = start + (num - 1)*len;
+    @type@ *stack[PYA_QS_STACK], **sptr = stack, *pm, *pi, *pj, *pk;
+
+    for(;;) {
+        while ((pr - pl) > 5*len) {
+            /* quicksort partition */
+            pm = pl + (((pr - pl)/len) >> 1)*len;
+            if (@lessthan@(pm, pl, len)) @swap@(pm, pl, len);
+            if (@lessthan@(pr, pm, len)) @swap@(pr, pm, len);
+            if (@lessthan@(pm, pl, len)) @swap@(pm, pl, len);
+            @copy@(vp, pm, len);
+            pi = pl;
+            pj = pr - len;
+            @swap@(pm, pj, len);
+            for(;;) {
+                do pi += len; while (@lessthan@(pi, vp, len));
+                do pj -= len; while (@lessthan@(vp, pj, len));
+                if (pi >= pj)  break;
+                @swap@(pi, pj, len);
+            }
+            pk = pr - len;
+            @swap@(pi, pk, len);
+            /* push largest partition on stack */
+            if (pi - pl < pr - pi) {
+                *sptr++ = pi + len;
+                *sptr++ = pr;
+                pr = pi - len;
+            }
+            else {
+                *sptr++ = pl;
+                *sptr++ = pi - len;
+                pl = pi + len;
+            }
+        }
+
+        /* insertion sort */
+        for(pi = pl + len; pi <= pr; pi += len) {
+            @copy@(vp, pi, len);
+            pj = pi;
+            pk = pi - len;
+            while(pj > pl && @lessthan@(vp, pk, len)) {
+                @copy@(pj, pk, len);
+                pj -= len;
+                pk -= len;
+            }
+            @copy@(pj, vp, len);
+        }
+        if (sptr == stack) break;
+        pr = *(--sptr);
+        pl = *(--sptr);
+    }
+
+    free(vp);
+    return 0;
+}
+
+
+static int
+ at TYPE@_aquicksort(@type@ *v, intp* tosort, intp num, PyArrayObject *arr)
+{
+    @type@ *vp;
+    intp *pl = tosort;
+    intp *pr = tosort + num - 1;
+    intp *stack[PYA_QS_STACK];
+    intp **sptr=stack;
+    intp *pm, *pi, *pj, *pk, vi, SWAP_temp;
+    size_t len = arr->descr->elsize/sizeof(@type@);
+
+    for(;;) {
+        while ((pr - pl) > SMALL_QUICKSORT) {
+            /* quicksort partition */
+            pm = pl + ((pr - pl) >> 1);
+            if (@lessthan@(v + (*pm)*len, v + (*pl)*len, len)) SWAP(*pm, *pl);
+            if (@lessthan@(v + (*pr)*len, v + (*pm)*len, len)) SWAP(*pr, *pm);
+            if (@lessthan@(v + (*pm)*len, v + (*pl)*len, len)) SWAP(*pm, *pl);
+            vp = v + (*pm)*len;
+            pi = pl;
+            pj = pr - 1;
+            SWAP(*pm,*pj);
+            for(;;) {
+                do ++pi; while (@lessthan@(v + (*pi)*len, vp, len));
+                do --pj; while (@lessthan@(vp, v + (*pj)*len, len));
+                if (pi >= pj)  break;
+                SWAP(*pi,*pj);
+            }
+            SWAP(*pi,*(pr-1));
+            /* push largest partition on stack */
+            if (pi - pl < pr - pi) {
+                *sptr++ = pi + 1;
+                *sptr++ = pr;
+                pr = pi - 1;
+            }
+            else {
+                *sptr++ = pl;
+                *sptr++ = pi - 1;
+                pl = pi + 1;
+            }
+        }
+
+        /* insertion sort */
+        for(pi = pl + 1; pi <= pr; ++pi) {
+            vi = *pi;
+            vp = v + vi*len;
+            pj = pi;
+            pk = pi -1;
+            while(pj > pl && @lessthan@(vp, v + (*pk)*len, len)) {
+                *pj-- = *pk--;
+            }
+            *pj = vi;
+        }
+        if (sptr == stack) break;
+        pr = *(--sptr);
+        pl = *(--sptr);
+    }
+
+    return 0;
+}
+
+
 static void
 @TYPE at _amergesort0(intp *pl, intp *pr, @type@ *v, intp *pw, int len)
 {
@@ -444,7 +612,7 @@
             vp = v + vi*len;
             pj = pi;
             pk = pi -1;
-            for(; pj > pl && @lessthan@(vp, v + (*pk)*len, len);) {
+            while(pj > pl && @lessthan@(vp, v + (*pk)*len, len)) {
                 *pj-- = *pk--;
             }
             *pj = vi;
@@ -452,6 +620,7 @@
     }
 }
 
+
 static int
 @TYPE at _amergesort(@type@ *v, intp *tosort, intp num, PyArrayObject *arr)
 {
@@ -503,9 +672,18 @@
     descr = PyArray_DescrFromType(PyArray_STRING);
     descr->f->argsort[PyArray_MERGESORT] = \
         (PyArray_ArgSortFunc *)STRING_amergesort;
+    descr->f->argsort[PyArray_QUICKSORT] = \
+        (PyArray_ArgSortFunc *)STRING_aquicksort;
+    descr->f->sort[PyArray_QUICKSORT] = \
+        (PyArray_SortFunc *)STRING_quicksort;
+
     descr = PyArray_DescrFromType(PyArray_UNICODE);
     descr->f->argsort[PyArray_MERGESORT] = \
         (PyArray_ArgSortFunc *)UNICODE_amergesort;
+    descr->f->argsort[PyArray_QUICKSORT] = \
+        (PyArray_ArgSortFunc *)UNICODE_aquicksort;
+    descr->f->sort[PyArray_QUICKSORT] = \
+        (PyArray_SortFunc *)UNICODE_quicksort;
 }
 
 static struct PyMethodDef methods[] = {



From numpy-svn at scipy.org  Wed Feb 13 00:54:54 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 12 Feb 2008 23:54:54 -0600 (CST)
Subject: [Numpy-svn] r4797 - in trunk: . numpy/core/src
Message-ID: <20080213055454.CC2D039C048@new.scipy.org>

Author: oliphant
Date: 2008-02-12 23:54:52 -0600 (Tue, 12 Feb 2008)
New Revision: 4797

Modified:
   trunk/THANKS.txt
   trunk/numpy/core/src/arrayobject.c
Log:
Fix swap error for indexing flat attribute.  The data-type of the returned object keeps the byte-swap information so there is no need to swap.

Modified: trunk/THANKS.txt
===================================================================
--- trunk/THANKS.txt	2008-02-13 02:56:50 UTC (rev 4796)
+++ trunk/THANKS.txt	2008-02-13 05:54:52 UTC (rev 4797)
@@ -3,7 +3,7 @@
     Numeric on which the code is based.
 Perry Greenfield, J Todd Miller, Rick White, Paul Barrett for Numarray
     which gave much inspiration and showed the way forward.
-Paul Dubois for Masked Arrays
+Paul Dubois for original Masked Arrays
 Pearu Peterson for f2py and numpy.distutils and help with code organization
 Robert Kern for mtrand, bug fixes, help with distutils, code organization, 
     and much more. 
@@ -34,5 +34,5 @@
     Valgrind expertise.
 Stefan van der Walt for documentation, bug-fixes and regression-tests.
 Andrew Straw for help with http://www.scipy.org, documentation, and testing. 
-David Cournapeau for documentation, bug-fixes, and code contributions including fast_clipping.
+David Cournapeau for scons build support, doc-and-bug fixes, and code contributions including fast_clipping.
 Pierre Gerard-Marchant for his rewrite of the masked array functionality.

Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2008-02-13 02:56:50 UTC (rev 4796)
+++ trunk/numpy/core/src/arrayobject.c	2008-02-13 05:54:52 UTC (rev 4797)
@@ -9283,10 +9283,9 @@
                                  0, (PyObject *)self->ao);
         if (r==NULL) goto fail;
         dptr = PyArray_DATA(r);
-        swap = !PyArray_ISNOTSWAPPED(self->ao);
         copyswap = PyArray_DESCR(r)->f->copyswap;
         while(n_steps--) {
-            copyswap(dptr, self->dataptr, swap, r);
+            copyswap(dptr, self->dataptr, 0, r);
             start += step_size;
             PyArray_ITER_GOTO1D(self, start)
                 dptr += size;



From numpy-svn at scipy.org  Wed Feb 13 01:11:20 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 13 Feb 2008 00:11:20 -0600 (CST)
Subject: [Numpy-svn] r4798 - trunk/numpy/core/src
Message-ID: <20080213061120.7166839C048@new.scipy.org>

Author: oliphant
Date: 2008-02-13 00:11:19 -0600 (Wed, 13 Feb 2008)
New Revision: 4798

Modified:
   trunk/numpy/core/src/multiarraymodule.c
Log:
Fix ticket #658 which is a segfault on a corner case for copy detection.

Modified: trunk/numpy/core/src/multiarraymodule.c
===================================================================
--- trunk/numpy/core/src/multiarraymodule.c	2008-02-13 05:54:52 UTC (rev 4797)
+++ trunk/numpy/core/src/multiarraymodule.c	2008-02-13 06:11:19 UTC (rev 4798)
@@ -499,8 +499,8 @@
     for (oi=0; oi<oldnd; oi++) op*=olddims[oi];
 
     if (np != op) return 0; /* different total sizes; no hope */
+    if (np == 0) return 1;
 
-
     oi = 0;
     oj = 1;
     ni = 0;



From numpy-svn at scipy.org  Wed Feb 13 04:53:36 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 13 Feb 2008 03:53:36 -0600 (CST)
Subject: [Numpy-svn] r4799 - trunk/numpy/core
Message-ID: <20080213095336.E3B1939C1B4@new.scipy.org>

Author: cdavid
Date: 2008-02-13 03:53:32 -0600 (Wed, 13 Feb 2008)
New Revision: 4799

Modified:
   trunk/numpy/core/SConstruct
Log:
scons build: fail as soon as possible if Python.h is not found. This is particularly useful on windows if the platform sdk is not available

Modified: trunk/numpy/core/SConstruct
===================================================================
--- trunk/numpy/core/SConstruct	2008-02-13 06:11:19 UTC (rev 4798)
+++ trunk/numpy/core/SConstruct	2008-02-13 09:53:32 UTC (rev 4799)
@@ -20,6 +20,7 @@
     # simple code using only typedef and so on, so we need it for configuration
     # checks
     env.AppendUnique(LIBPATH = [get_pythonlib_dir()])
+print env["CPPPATH"]
 
 #=======================
 # Starting Configuration
@@ -39,6 +40,11 @@
 #---------------
 # Checking Types
 #---------------
+if not config.CheckHeader("Python.h"):
+    raise RuntimeError("Error: Python.h header is not found (or cannot be "
+"compiled). On linux, check that you have python-dev/python-devel packages. On"
+" windows, check \ that you have the platform SDK.")
+
 def check_type(type, include = None):
     st = config.CheckTypeSize(type, includes = include)
     type = type.replace(' ', '_')



From numpy-svn at scipy.org  Wed Feb 13 15:37:51 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 13 Feb 2008 14:37:51 -0600 (CST)
Subject: [Numpy-svn] r4800 - trunk/numpy/core/tests
Message-ID: <20080213203751.7863439C327@new.scipy.org>

Author: stefan
Date: 2008-02-13 14:37:28 -0600 (Wed, 13 Feb 2008)
New Revision: 4800

Modified:
   trunk/numpy/core/tests/test_regression.py
Log:
Add regression tests for tickets #657 and #658.


Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2008-02-13 09:53:32 UTC (rev 4799)
+++ trunk/numpy/core/tests/test_regression.py	2008-02-13 20:37:28 UTC (rev 4800)
@@ -792,5 +792,15 @@
         y = np.fromstring("\x00\x01\x00\x02", dtype="|S2")
         assert_array_equal(np.sort(x, kind="q"), y)
 
+    def check_copy_detection_zero_dim(self, level=rlevel):
+        """Ticket #658"""
+        np.indices((0,3,4)).T.reshape(-1,3)
+
+    def check_flat_byteorder(self, level=rlevel):
+       """Ticket #657"""
+       x = np.arange(10)
+       assert_array_equal(x.astype('>i4'),x.astype('<i4').flat[:])
+       assert_array_equal(x.astype('>i4').flat[:],x.astype('<i4'))
+
 if __name__ == "__main__":
     NumpyTest().run()



From numpy-svn at scipy.org  Wed Feb 13 16:41:57 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 13 Feb 2008 15:41:57 -0600 (CST)
Subject: [Numpy-svn] r4801 - in trunk/numpy/core: src tests
Message-ID: <20080213214157.76AA139C097@new.scipy.org>

Author: charris
Date: 2008-02-13 15:41:47 -0600 (Wed, 13 Feb 2008)
New Revision: 4801

Modified:
   trunk/numpy/core/src/_sortmodule.c.src
   trunk/numpy/core/tests/test_multiarray.py
Log:
Add type specific heapsort to argsort kind options for strings and unicode. 


Modified: trunk/numpy/core/src/_sortmodule.c.src
===================================================================
--- trunk/numpy/core/src/_sortmodule.c.src	2008-02-13 20:37:28 UTC (rev 4800)
+++ trunk/numpy/core/src/_sortmodule.c.src	2008-02-13 21:41:47 UTC (rev 4801)
@@ -520,6 +520,53 @@
 
 
 static int
+ at TYPE@_aheapsort(@type@ *v, intp *tosort, intp n, PyArrayObject *arr)
+{
+    intp *a, i,j,l, tmp;
+    size_t len = arr->descr->elsize/sizeof(@type@);
+
+    /* The array needs to be offset by one for heapsort indexing */
+    a = tosort - 1;
+
+    for (l = n>>1; l > 0; --l) {
+        tmp = a[l];
+        for (i = l, j = l<<1; j <= n;) {
+            if (j < n && @lessthan@(v + a[j]*len, v + a[j+1]*len, len))
+                j += 1;
+            if (@lessthan@(v + tmp*len, v + a[j]*len, len)) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else
+                break;
+        }
+        a[i] = tmp;
+    }
+
+    for (; n > 1;) {
+        tmp = a[n];
+        a[n] = a[1];
+        n -= 1;
+        for (i = 1, j = 2; j <= n;) {
+            if (j < n && @lessthan@(v + a[j]*len, v + a[j+1]*len, len))
+                j++;
+            if (@lessthan@(v + tmp*len, v + a[j]*len, len)) {
+                a[i] = a[j];
+                i = j;
+                j += j;
+            }
+            else
+                break;
+        }
+        a[i] = tmp;
+    }
+
+    return 0;
+}
+
+
+static int
 @TYPE at _aquicksort(@type@ *v, intp* tosort, intp num, PyArrayObject *arr)
 {
     @type@ *vp;
@@ -674,6 +721,8 @@
         (PyArray_ArgSortFunc *)STRING_amergesort;
     descr->f->argsort[PyArray_QUICKSORT] = \
         (PyArray_ArgSortFunc *)STRING_aquicksort;
+    descr->f->argsort[PyArray_HEAPSORT] = \
+        (PyArray_ArgSortFunc *)STRING_aheapsort;
     descr->f->sort[PyArray_QUICKSORT] = \
         (PyArray_SortFunc *)STRING_quicksort;
 
@@ -682,6 +731,8 @@
         (PyArray_ArgSortFunc *)UNICODE_amergesort;
     descr->f->argsort[PyArray_QUICKSORT] = \
         (PyArray_ArgSortFunc *)UNICODE_aquicksort;
+    descr->f->argsort[PyArray_HEAPSORT] = \
+        (PyArray_ArgSortFunc *)UNICODE_aheapsort;
     descr->f->sort[PyArray_QUICKSORT] = \
         (PyArray_SortFunc *)UNICODE_quicksort;
 }

Modified: trunk/numpy/core/tests/test_multiarray.py
===================================================================
--- trunk/numpy/core/tests/test_multiarray.py	2008-02-13 20:37:28 UTC (rev 4800)
+++ trunk/numpy/core/tests/test_multiarray.py	2008-02-13 21:41:47 UTC (rev 4801)
@@ -365,26 +365,24 @@
             assert_equal(ai.copy().argsort(kind=kind), a, msg)
             assert_equal(bi.copy().argsort(kind=kind), b, msg)
 
-        # test string argsorts. Only quick and merge sort are
-        # available at this time.
+        # test string argsorts.
         s = 'aaaaaaaa'
         a = np.array([s + chr(i) for i in range(100)])
         b = a[::-1].copy()
         r = arange(100)
         rr = r[::-1].copy()
-        for kind in ['q', 'm'] :
+        for kind in ['q', 'm', 'h'] :
             msg = "string argsort, kind=%s" % kind
             assert_equal(a.copy().argsort(kind=kind), r, msg)
             assert_equal(b.copy().argsort(kind=kind), rr, msg)
 
-        # test unicode argsorts. Only quick and merge sort are
-        # available at this time.
+        # test unicode argsorts.
         s = 'aaaaaaaa'
         a = np.array([s + chr(i) for i in range(100)], dtype=np.unicode)
         b = a[::-1].copy()
         r = arange(100)
         rr = r[::-1].copy()
-        for kind in ['q', 'm'] :
+        for kind in ['q', 'm', 'h'] :
             msg = "unicode argsort, kind=%s" % kind
             assert_equal(a.copy().argsort(kind=kind), r, msg)
             assert_equal(b.copy().argsort(kind=kind), rr, msg)



From numpy-svn at scipy.org  Wed Feb 13 18:10:48 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 13 Feb 2008 17:10:48 -0600 (CST)
Subject: [Numpy-svn] r4802 - in trunk/numpy/core: src tests
Message-ID: <20080213231048.91DE039C166@new.scipy.org>

Author: charris
Date: 2008-02-13 17:10:44 -0600 (Wed, 13 Feb 2008)
New Revision: 4802

Modified:
   trunk/numpy/core/src/_sortmodule.c.src
   trunk/numpy/core/tests/test_multiarray.py
Log:
Add type specific heapsort for strings and unicode.


Modified: trunk/numpy/core/src/_sortmodule.c.src
===================================================================
--- trunk/numpy/core/src/_sortmodule.c.src	2008-02-13 21:41:47 UTC (rev 4801)
+++ trunk/numpy/core/src/_sortmodule.c.src	2008-02-13 23:10:44 UTC (rev 4802)
@@ -520,10 +520,57 @@
 
 
 static int
+ at TYPE@_heapsort(@type@ *start, intp n, PyArrayObject *arr)
+{
+    size_t len = arr->descr->elsize/sizeof(@type@);
+    @type@ *tmp = malloc(arr->descr->elsize);
+    @type@ *a = start - len;
+    intp i,j,l;
+
+    for (l = n>>1; l > 0; --l) {
+        @copy@(tmp, a + l*len, len);
+        for (i = l, j = l<<1; j <= n;) {
+            if (j < n && @lessthan@(a + j*len, a + (j+1)*len, len))
+                j += 1;
+            if (@lessthan@(tmp, a + j*len, len)) {
+                @copy@(a + i*len, a + j*len, len);
+                i = j;
+                j += j;
+            }
+            else
+                break;
+        }
+        @copy@(a + i*len, tmp, len);
+    }
+
+    for (; n > 1;) {
+        @copy@(tmp, a + n*len, len);
+        @copy@(a + n*len, a + len, len);
+        n -= 1;
+        for (i = 1, j = 2; j <= n;) {
+            if (j < n && @lessthan@(a + j*len, a + (j+1)*len, len))
+                j++;
+            if (@lessthan@(tmp, a + j*len, len)) {
+                @copy@(a + i*len, a + j*len, len);
+                i = j;
+                j += j;
+            }
+            else
+                break;
+        }
+        @copy@(a + i*len, tmp, len);
+    }
+
+    free(tmp);
+    return 0;
+}
+
+
+static int
 @TYPE at _aheapsort(@type@ *v, intp *tosort, intp n, PyArrayObject *arr)
 {
+    size_t len = arr->descr->elsize/sizeof(@type@);
     intp *a, i,j,l, tmp;
-    size_t len = arr->descr->elsize/sizeof(@type@);
 
     /* The array needs to be offset by one for heapsort indexing */
     a = tosort - 1;
@@ -569,13 +616,13 @@
 static int
 @TYPE at _aquicksort(@type@ *v, intp* tosort, intp num, PyArrayObject *arr)
 {
+    size_t len = arr->descr->elsize/sizeof(@type@);
     @type@ *vp;
     intp *pl = tosort;
     intp *pr = tosort + num - 1;
     intp *stack[PYA_QS_STACK];
     intp **sptr=stack;
     intp *pm, *pi, *pj, *pk, vi, SWAP_temp;
-    size_t len = arr->descr->elsize/sizeof(@type@);
 
     for(;;) {
         while ((pr - pl) > SMALL_QUICKSORT) {
@@ -725,6 +772,8 @@
         (PyArray_ArgSortFunc *)STRING_aheapsort;
     descr->f->sort[PyArray_QUICKSORT] = \
         (PyArray_SortFunc *)STRING_quicksort;
+    descr->f->sort[PyArray_HEAPSORT] = \
+        (PyArray_SortFunc *)STRING_heapsort;
 
     descr = PyArray_DescrFromType(PyArray_UNICODE);
     descr->f->argsort[PyArray_MERGESORT] = \
@@ -735,6 +784,8 @@
         (PyArray_ArgSortFunc *)UNICODE_aheapsort;
     descr->f->sort[PyArray_QUICKSORT] = \
         (PyArray_SortFunc *)UNICODE_quicksort;
+    descr->f->sort[PyArray_HEAPSORT] = \
+        (PyArray_SortFunc *)UNICODE_heapsort;
 }
 
 static struct PyMethodDef methods[] = {

Modified: trunk/numpy/core/tests/test_multiarray.py
===================================================================
--- trunk/numpy/core/tests/test_multiarray.py	2008-02-13 21:41:47 UTC (rev 4801)
+++ trunk/numpy/core/tests/test_multiarray.py	2008-02-13 23:10:44 UTC (rev 4802)
@@ -290,11 +290,11 @@
             c.sort(kind=kind)
             assert_equal(c, ai, msg)
 
-        # test string sorts. Only quicksort is available at this time.
+        # test string sorts. Only quick and heap sort are available.
         s = 'aaaaaaaa'
         a = np.array([s + chr(i) for i in range(100)])
         b = a[::-1].copy()
-        for kind in ['q'] :
+        for kind in ['q', 'h'] :
             msg = "string sort, kind=%s" % kind
             c = a.copy();
             c.sort(kind=kind)
@@ -303,11 +303,11 @@
             c.sort(kind=kind)
             assert_equal(c, a, msg)
 
-        # test unicode sort. Only quicksort is available at this time.
+        # test unicode sort. Only quick and heap sort are available.
         s = 'aaaaaaaa'
         a = np.array([s + chr(i) for i in range(100)], dtype=np.unicode)
         b = a[::-1].copy()
-        for kind in ['q'] :
+        for kind in ['q', 'h'] :
             msg = "unicode sort, kind=%s" % kind
             c = a.copy();
             c.sort(kind=kind)



From numpy-svn at scipy.org  Wed Feb 13 20:32:25 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 13 Feb 2008 19:32:25 -0600 (CST)
Subject: [Numpy-svn] r4803 - trunk/numpy/lib
Message-ID: <20080214013225.1EF9639C030@new.scipy.org>

Author: matthew.brett at gmail.com
Date: 2008-02-13 19:32:20 -0600 (Wed, 13 Feb 2008)
New Revision: 4803

Modified:
   trunk/numpy/lib/function_base.py
Log:
Fixed median axis=None raveling in case of copy

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-13 23:10:44 UTC (rev 4802)
+++ trunk/numpy/lib/function_base.py	2008-02-14 01:32:20 UTC (rev 4803)
@@ -1262,18 +1262,22 @@
     array([ 6.5,  4.5,  2.5])
     >>> m
     array([ 6.5,  4.5,  2.5])
-    >>> median(a, axis=1, overwrite_input=True)
+    >>> b = a.copy()
+    >>> median(b, axis=1, overwrite_input=True)
     array([ 7.,  2.])
-    >>> a # modified, undefined, sorted in this case
-    array([[ 4,  7, 10],
-           [ 1,  2,  3]])
+    >>> assert not np.all(a==b)
+    >>> b = a.copy()
+    >>> median(b, axis=None, overwrite_input=True)
+    3.5
+    >>> assert not np.all(a==b)
     """
     if overwrite_input:
         if axis is None:
-            a.ravel.sort()
+            sorted = a.ravel()
+            sorted.sort()
         else:
             a.sort(axis=axis)
-        sorted = a
+            sorted = a
     else:
         sorted = sort(a, axis=axis)
     if axis is None:



From numpy-svn at scipy.org  Wed Feb 13 20:32:38 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 13 Feb 2008 19:32:38 -0600 (CST)
Subject: [Numpy-svn] r4804 - branches/maskedarray/numpy/ma
Message-ID: <20080214013238.CBC4739C0D2@new.scipy.org>

Author: pierregm
Date: 2008-02-13 19:32:35 -0600 (Wed, 13 Feb 2008)
New Revision: 4804

Modified:
   branches/maskedarray/numpy/ma/API_CHANGES.txt
   branches/maskedarray/numpy/ma/extras.py
   branches/maskedarray/numpy/ma/morestats.py
   branches/maskedarray/numpy/ma/mstats.py
Log:
numpy.ma : docs + API_CHANGES.txt updates

Modified: branches/maskedarray/numpy/ma/API_CHANGES.txt
===================================================================
--- branches/maskedarray/numpy/ma/API_CHANGES.txt	2008-02-14 01:32:20 UTC (rev 4803)
+++ branches/maskedarray/numpy/ma/API_CHANGES.txt	2008-02-14 01:32:35 UTC (rev 4804)
@@ -4,6 +4,52 @@
 API changes in the new masked array implementation
 ==================================================
 
+Masked arrays are subclasses of ndarray
+---------------------------------------
+
+Contrary to the original implementation, masked arrays are now regular ndarrays::
+
+  >>> x = masked_array([1,2,3],mask=[0,0,1])
+  >>> print isinstance(x, numpy.ndarray)
+  True
+
+
+``_data`` returns a view of the masked array
+--------------------------------------------
+
+Masked arrays are composed of a ``_data`` part and a ``_mask``. Accessing the
+``_data`` part will return a regular ndarray or any of its subclass, depending
+on the initial data::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> print x._data
+  [[1 2]
+   [3 4]]
+  >>> print type(x._data)
+  <class 'numpy.core.defmatrix.matrix'>
+
+
+In practice, ``_data`` is implemented as a property, not as an attribute.
+Therefore, you cannot access it directly, and some simple tests such as the
+following one will fail::
+
+  >>>x._data is x._data
+  False
+
+
+``filled(x)`` can return a subclass of ndarray
+-------------
+The function ``filled(a)`` returns an array of the same type as ``a._data``::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> y = filled(x)
+  >>> print type(y)
+  <class 'numpy.core.defmatrix.matrix'>
+  >>> print y
+  matrix([[     1,      2],
+          [     3, 999999]])
+
+
 ``put``, ``putmask`` behave like their ndarray counterparts
 -----------------------------------------------------------
 
@@ -66,3 +112,27 @@
     File "<stdin>", line 1, in <module>
   ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
 
+
+==================================
+New features (non exhaustive list)
+==================================
+
+``mr_``
+-------
+
+``mr_`` mimics the behavior of ``r_`` for masked arrays::
+
+``anom``
+--------
+
+The ``anom`` method returns the deviations from the average (anomalies).
+
+``varu`` and ``stdu``
+---------------------
+
+These methods return unbiased estimates of the variance and standard deviation
+respectively. An unbiased estimate is obtained by dividing the sum of the
+squared anomalies by ``n-1`` instead of ``n`` for the biased estimates, where
+``n`` is the number of unmasked elements along the given axis.
+
+

Modified: branches/maskedarray/numpy/ma/extras.py
===================================================================
--- branches/maskedarray/numpy/ma/extras.py	2008-02-14 01:32:20 UTC (rev 4803)
+++ branches/maskedarray/numpy/ma/extras.py	2008-02-14 01:32:35 UTC (rev 4804)
@@ -219,6 +219,20 @@
     """Execute func1d(arr[i],*args) where func1d takes 1-D arrays and
     arr is an N-d array.  i varies so as to apply the function along
     the given axis for each 1-d subarray in arr.
+    
+    Parameters
+    ----------
+        func1d : function
+            The 1D function to apply on the given axis.
+        axis : int
+            Axis along which to apply the function.
+        arr : ndarray
+            Array on which the function is applied.
+        args : list
+            Additional input parameters to func1d.
+        kwargs : dictionary
+            Additional optional parameters to func1d.
+    
     """
     arr = core.array(arr, copy=False, subok=True)
     nd = arr.ndim
@@ -542,6 +556,7 @@
     Notes
     -----
         The first argument is not conjugated.
+        The function works only with 2D arrays at most.
 
     """
     #TODO: Works only with 2D arrays. There should be a way to get it to run with higher dimension

Modified: branches/maskedarray/numpy/ma/morestats.py
===================================================================
--- branches/maskedarray/numpy/ma/morestats.py	2008-02-14 01:32:20 UTC (rev 4803)
+++ branches/maskedarray/numpy/ma/morestats.py	2008-02-14 01:32:35 UTC (rev 4804)
@@ -40,22 +40,26 @@
     """Computes quantile estimates with the Harrell-Davis method, where the estimates
 are calculated as a weighted linear combination of order statistics.
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+----------
+    data: ndarray
         Data array.
-    prob: {sequence}
+    prob: sequence
         Sequence of quantiles to compute.
-    axis : {integer}
+    axis : int
         Axis along which to compute the quantiles. If None, use a flattened array.
-    var : {boolean}
+    var : boolean
         Whether to return the variance of the estimate.
 
-*Returns*
+Returns
+-------
     A (p,) array of quantiles (if ``var`` is False), or a (2,p) array of quantiles
     and variances (if ``var`` is True), where ``p`` is the number of quantiles.
 
-:Note:
+Notes
+-----
     The function is restricted to 2D arrays.
+    
     """
     def _hd_1D(data,prob,var):
         "Computes the HD quantiles for a 1D array. Returns nan for invalid data."
@@ -102,13 +106,15 @@
 def hdmedian(data, axis=-1, var=False):
     """Returns the Harrell-Davis estimate of the median along the given axis.
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+----------
+    data: ndarray
         Data array.
-    axis : {integer}
+    axis : int
         Axis along which to compute the quantiles. If None, use a flattened array.
-    var : {boolean}
+    var : boolean
         Whether to return the variance of the estimate.
+        
     """
     result = hdquantiles(data,[0.5], axis=axis, var=var)
     return result.squeeze()
@@ -119,16 +125,19 @@
     """Computes the standard error of the Harrell-Davis quantile estimates by jackknife.
 
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+----------
+    data: ndarray
         Data array.
-    prob: {sequence}
+    prob: sequence
         Sequence of quantiles to compute.
-    axis : {integer}
+    axis : int
         Axis along which to compute the quantiles. If None, use a flattened array.
 
-*Note*:
+Notes
+-----
     The function is restricted to 2D arrays.
+    
     """
     def _hdsd_1D(data,prob):
         "Computes the std error for 1D arrays."
@@ -172,16 +181,18 @@
     """Returns the selected confidence interval of the trimmed mean along the
 given axis.
 
-*Parameters* :
-    data : {sequence}
+Parameters
+----------
+    data : sequence
         Input data. The data is transformed to a masked array
-    proportiontocut : {float}
+    proportiontocut : float
         Proportion of the data to cut from each side of the data .
         As a result, (2*proportiontocut*n) values are actually trimmed.
-    alpha : {float}
+    alpha : float
         Confidence level of the intervals.
-    axis : {integer}
+    axis : int
         Axis along which to cut. If None, uses a flattened version of the input.
+    
     """
     data = masked_array(data, copy=False)
     trimmed = trim_both(data, proportiontocut=proportiontocut, axis=axis)
@@ -196,13 +207,15 @@
     """Returns the Maritz-Jarrett estimators of the standard error of selected
 experimental quantiles of the data.
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+-----------
+    data: ndarray
         Data array.
-    prob: {sequence}
+    prob: sequence
         Sequence of quantiles to compute.
-    axis : {integer}
+    axis : int
         Axis along which to compute the quantiles. If None, use a flattened array.
+    
     """
     def _mjci_1D(data, p):
         data = data.compressed()
@@ -236,14 +249,15 @@
     """Computes the alpha confidence interval for the selected quantiles of the
 data, with Maritz-Jarrett estimators.
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+----------
+    data: ndarray
         Data array.
-    prob: {sequence}
+    prob: sequence
         Sequence of quantiles to compute.
-    alpha : {float}
+    alpha : float
         Confidence level of the intervals.
-    axis : {integer}
+    axis : integer
         Axis along which to compute the quantiles. If None, use a flattened array.
     """
     alpha = min(alpha, 1-alpha)
@@ -258,13 +272,14 @@
     """Computes the alpha-level confidence interval for the median of the data,
 following the Hettmasperger-Sheather method.
 
-*Parameters* :
-    data : {sequence}
+Parameters
+----------
+    data : sequence
         Input data. Masked values are discarded. The input should be 1D only, or
         axis should be set to None.
-    alpha : {float}
+    alpha : float
         Confidence level of the intervals.
-    axis : {integer}
+    axis : integer
         Axis along which to compute the quantiles. If None, use a flattened array.
     """
     def _cihs_1D(data, alpha):
@@ -299,7 +314,8 @@
 The comparison is performed using the McKean-Schrader estimate of the standard
 error of the medians.
 
-*Parameters* :
+Parameters
+----------
     group_1 : {sequence}
         First dataset.
     group_2 : {sequence}
@@ -307,7 +323,8 @@
     axis : {integer}
         Axis along which the medians are estimated. If None, the arrays are flattened.
 
-*Returns* :
+Returns
+-------
     A (p,) array of comparison values.
 
     """
@@ -325,22 +342,23 @@
 #..............................................................................
 def rank_data(data, axis=None, use_missing=False):
     """Returns the rank (also known as order statistics) of each data point
-along the given axis.
+    along the given axis.
 
-If some values are tied, their rank is averaged.
-If some values are masked, their rank is set to 0 if use_missing is False, or
-set to the average rank of the unmasked values if use_missing is True.
+    If some values are tied, their rank is averaged.
+    If some values are masked, their rank is set to 0 if use_missing is False, 
+    or set to the average rank of the unmasked values if use_missing is True.
 
-*Parameters* :
-    data : {sequence}
-        Input data. The data is transformed to a masked array
-    axis : {integer}
-        Axis along which to perform the ranking. If None, the array is first
-        flattened. An exception is raised if the axis is specified for arrays
-        with a dimension larger than 2
-    use_missing : {boolean}
-        Whether the masked values have a rank of 0 (False) or equal to the
-        average rank of the unmasked values (True).
+    Parameters
+    ----------
+        data : sequence
+            Input data. The data is transformed to a masked array
+        axis : integer
+            Axis along which to perform the ranking. 
+            If None, the array is first flattened. An exception is raised if 
+            the axis is specified for arrays with a dimension larger than 2
+        use_missing : boolean
+            Whether the masked values have a rank of 0 (False) or equal to the
+            average rank of the unmasked values (True).
     """
     #
     def _rank1d(data, use_missing=False):

Modified: branches/maskedarray/numpy/ma/mstats.py
===================================================================
--- branches/maskedarray/numpy/ma/mstats.py	2008-02-14 01:32:20 UTC (rev 4803)
+++ branches/maskedarray/numpy/ma/mstats.py	2008-02-14 01:32:35 UTC (rev 4804)
@@ -33,16 +33,20 @@
 
 def winsorize(data, alpha=0.2):
     """Returns a Winsorized version of the input array.
+    
+    The (alpha/2.) lowest values are set to the (alpha/2.)th percentile, 
+    and the (alpha/2.) highest values are set to the (1-alpha/2.)th 
+    percentile.
+    Masked values are skipped.
 
-The (alpha/2.) lowest values are set to the (alpha/2.)th percentile, and
-the (alpha/2.) highest values are set to the (1-alpha/2.)th percentile
-Masked values are skipped.
+    Parameters
+    ----------
+        data : ndarray
+            Input data to Winsorize. The data is first flattened.
+        alpha : float
+            Percentage of total Winsorization: alpha/2. on the left, 
+            alpha/2. on the right
 
-*Parameters*:
-    data : {ndarray}
-        Input data to Winsorize. The data is first flattened.
-    alpha : {float}, optional
-        Percentage of total Winsorization : alpha/2. on the left, alpha/2. on the right
     """
     data = masked_array(data, copy=False).ravel()
     idxsort = data.argsort()
@@ -53,18 +57,26 @@
 
 #..............................................................................
 def trim_both(data, proportiontocut=0.2, axis=None):
-    """Trims the data by masking the int(trim*n) smallest and int(trim*n) largest
-values of data along the given axis, where n is the number of unmasked values.
+    """Trims the data by masking the int(trim*n) smallest and int(trim*n) 
+    largest values of data along the given axis, where n is the number 
+    of unmasked values.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    proportiontocut : {float}
-        Percentage of trimming. If n is the number of unmasked values before trimming,
-        the number of values after trimming is (1-2*trim)*n.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        proportiontocut : float
+            Percentage of trimming. If n is the number of unmasked values 
+            before trimming, the number of values after trimming is:
+                (1-2*trim)*n.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
+
+    Notes
+    -----
+        The function works only for arrays up to 2D.
+
     """
     #...................
     def _trim_1D(data, trim):
@@ -87,22 +99,30 @@
 
 #..............................................................................
 def trim_tail(data, proportiontocut=0.2, tail='left', axis=None):
-    """Trims the data by masking int(trim*n) values from ONE tail of the data
-along the given axis, where n is the number of unmasked values.
+    """Trims the data by masking int(trim*n) values from ONE tail of the 
+    data along the given axis, where n is the number of unmasked values.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    proportiontocut : {float}
-        Percentage of trimming. If n is the number of unmasked values before trimming,
-        the number of values after trimming is (1-trim)*n.
-    tail : {string}
-        Trimming direction, in ('left', 'right'). If left, the proportiontocut
-        lowest values are set to the corresponding percentile. If right, the
-        proportiontocut highest values are used instead.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        proportiontocut : float
+            Percentage of trimming. If n is the number of unmasked values 
+            before trimming, the number of values after trimming is 
+            (1-trim)*n.
+        tail : string
+            Trimming direction, in ('left', 'right'). 
+            If left, the ``proportiontocut`` lowest values are set to the 
+            corresponding percentile. If right, the ``proportiontocut`` 
+            highest values are used instead.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
+
+    Notes
+    -----
+        The function works only for arrays up to 2D.
+
     """
     #...................
     def _trim_1D(data, trim, left):
@@ -138,35 +158,43 @@
 
 #..............................................................................
 def trimmed_mean(data, proportiontocut=0.2, axis=None):
-    """Returns the trimmed mean of the data along the given axis. Trimming is
-performed on both ends of the distribution.
+    """Returns the trimmed mean of the data along the given axis. 
+    Trimming is performed on both ends of the distribution.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    proportiontocut : {float}
-        Proportion of the data to cut from each side of the data .
-        As a result, (2*proportiontocut*n) values are actually trimmed.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        proportiontocut : float
+            Proportion of the data to cut from each side of the data .
+            As a result, (2*proportiontocut*n) values are actually trimmed.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
+
     """
     return trim_both(data, proportiontocut=proportiontocut, axis=axis).mean(axis=axis)
 
 #..............................................................................
 def trimmed_stde(data, proportiontocut=0.2, axis=None):
     """Returns the standard error of the trimmed mean for the input data,
-along the given axis. Trimming is performed on both ends of the distribution.
+    along the given axis. Trimming is performed on both ends of the distribution.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    proportiontocut : {float}
-        Proportion of the data to cut from each side of the data .
-        As a result, (2*proportiontocut*n) values are actually trimmed.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        proportiontocut : float
+            Proportion of the data to cut from each side of the data .
+            As a result, (2*proportiontocut*n) values are actually trimmed.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
+
+    Notes
+    -----
+        The function worrks with arrays up to 2D.
+
     """
     #........................
     def _trimmed_stde_1D(data, trim=0.2):
@@ -189,13 +217,14 @@
     """Returns the McKean-Schrader estimate of the standard error of the sample
 median along the given axis.
 
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
     """
     def _stdemed_1D(data):
         sorted = numpy.sort(data.compressed())
@@ -240,16 +269,17 @@
     - (.4,.4)  : approximately quantile unbiased (Cunnane)
     - (.35,.35): APL, used with PWM
 
-*Parameters*:
-    x : {sequence}
+Parameters
+----------
+    x : sequence
         Input data, as a sequence or array of dimension at most 2.
-    prob : {sequence}
+    prob : sequence
         List of quantiles to compute.
-    alpha : {float}
+    alpha : float
         Plotting positions parameter.
-    beta : {float}
+    beta : float
         Plotting positions parameter.
-    axis : {integer}
+    axis : int
         Axis along which to perform the trimming. If None, the input array is first
         flattened.
     """
@@ -299,6 +329,18 @@
           if x is normally distributed (R type 9)
         - (.4,.4)  : approximately quantile unbiased (Cunnane)
         - (.35,.35): APL, used with PWM
+
+Parameters
+----------
+    x : sequence
+        Input data, as a sequence or array of dimension at most 2.
+    prob : sequence
+        List of quantiles to compute.
+    alpha : float
+        Plotting positions parameter.
+    beta : float
+        Plotting positions parameter.
+
     """
     data = masked_array(data, copy=False).reshape(1,-1)
     n = data.count()
@@ -311,7 +353,11 @@
 
 
 def mmedian(data, axis=None):
-    """Returns the median of data along the given axis. Missing data are discarded."""
+    """Returns the median of data along the given axis. 
+
+    Missing data are discarded.
+
+    """
     def _median1D(data):
         x = numpy.sort(data.compressed())
         if x.size == 0:
@@ -331,17 +377,18 @@
 Normalization is by (N-1) where N is the number of observations (unbiased
 estimate).  If bias is True then normalization is by N.
 
-*Parameters*:
-    x : {ndarray}
+Parameters
+----------
+    x : ndarray
         Input data. If x is a 1D array, returns the variance. If x is a 2D array,
         returns the covariance matrix.
-    y : {ndarray}, optional
+    y : ndarray
         Optional set of variables.
-    rowvar : {boolean}
+    rowvar : boolean
         If rowvar is true, then each row is a variable with obersvations in columns.
         If rowvar is False, each column is a variable and the observations are in
         the rows.
-    bias : {boolean}
+    bias : boolean
         Whether to use a biased or unbiased estimate of the covariance.
         If bias is True, then the normalization is by N, the number of observations.
         Otherwise, the normalization is by (N-1)
@@ -400,10 +447,10 @@
     """Evalutates Rosenblatt's shifted histogram estimators for each point
 on the dataset 'data'.
 
-*Parameters* :
-    data : {sequence}
+Parameters
+    data : sequence
         Input data. Masked values are ignored.
-    points : {sequence}
+    points : sequence
         Sequence of points where to evaluate Rosenblatt shifted histogram.
         If None, use the data.
     """



From numpy-svn at scipy.org  Thu Feb 14 02:24:23 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 14 Feb 2008 01:24:23 -0600 (CST)
Subject: [Numpy-svn] r4805 - in trunk/numpy/core: src tests
Message-ID: <20080214072423.E70CE39C018@new.scipy.org>

Author: charris
Date: 2008-02-14 01:24:13 -0600 (Thu, 14 Feb 2008)
New Revision: 4805

Modified:
   trunk/numpy/core/src/_sortmodule.c.src
   trunk/numpy/core/tests/test_multiarray.py
Log:
Add type specific mergesort for strings and unicode.
Use adaptive string_copy function suggested by Francesc.
Make the sorting code more consistent across types.


Modified: trunk/numpy/core/src/_sortmodule.c.src
===================================================================
--- trunk/numpy/core/src/_sortmodule.c.src	2008-02-14 01:32:35 UTC (rev 4804)
+++ trunk/numpy/core/src/_sortmodule.c.src	2008-02-14 07:24:13 UTC (rev 4805)
@@ -31,6 +31,7 @@
 #define PYA_QS_STACK 100
 #define SMALL_QUICKSORT 15
 #define SMALL_MERGESORT 20
+#define SMALL_STRING 16
 #define SWAP(a,b) {SWAP_temp = (b); (b)=(a); (a) = SWAP_temp;}
 #define STDC_LT(a,b) ((a) < (b))
 #define STDC_LE(a,b) ((a) <= (b))
@@ -58,26 +59,27 @@
     @type@ *pl = start;
     @type@ *pr = start + num - 1;
     @type@ vp, SWAP_temp;
-    @type@ *stack[PYA_QS_STACK], **sptr = stack, *pm, *pi, *pj, *pt;
+    @type@ *stack[PYA_QS_STACK], **sptr = stack, *pm, *pi, *pj, *pk;
 
     for(;;) {
         while ((pr - pl) > SMALL_QUICKSORT) {
             /* quicksort partition */
             pm = pl + ((pr - pl) >> 1);
-            if (@lessthan@(*pm,*pl)) SWAP(*pm,*pl);
-            if (@lessthan@(*pr,*pm)) SWAP(*pr,*pm);
-            if (@lessthan@(*pm,*pl)) SWAP(*pm,*pl);
+            if (@lessthan@(*pm, *pl)) SWAP(*pm, *pl);
+            if (@lessthan@(*pr, *pm)) SWAP(*pr, *pm);
+            if (@lessthan@(*pm, *pl)) SWAP(*pm, *pl);
             vp = *pm;
             pi = pl;
             pj = pr - 1;
-            SWAP(*pm,*pj);
+            SWAP(*pm, *pj);
             for(;;) {
-                do ++pi; while (@lessthan@(*pi,vp));
-                do --pj; while (@lessthan@(vp,*pj));
+                do ++pi; while (@lessthan@(*pi, vp));
+                do --pj; while (@lessthan@(vp, *pj));
                 if (pi >= pj)  break;
                 SWAP(*pi,*pj);
             }
-            SWAP(*pi,*(pr-1));
+            pk = pr - 1;
+            SWAP(*pi, *pk);
             /* push largest partition on stack */
             if (pi - pl < pr - pi) {
                 *sptr++ = pi + 1;
@@ -94,8 +96,10 @@
         /* insertion sort */
         for(pi = pl + 1; pi <= pr; ++pi) {
             vp = *pi;
-            for(pj = pi, pt = pi - 1; pj > pl && @lessthan@(vp, *pt);) {
-                *pj-- = *pt--;
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && @lessthan@(vp, *pk)) {
+                *pj-- = *pk--;
             }
             *pj = vp;
         }
@@ -112,7 +116,7 @@
 {
     @type@ vp;
     intp *pl, *pr, SWAP_temp;
-    intp *stack[PYA_QS_STACK], **sptr=stack, *pm, *pi, *pj, *pt, vi;
+    intp *stack[PYA_QS_STACK], **sptr=stack, *pm, *pi, *pj, *pk, vi;
 
     pl = tosort;
     pr = tosort + num - 1;
@@ -134,7 +138,8 @@
                 if (pi >= pj)  break;
                 SWAP(*pi,*pj);
             }
-            SWAP(*pi,*(pr-1));
+            pk = pr - 1; 
+            SWAP(*pi,*pk);
             /* push largest partition on stack */
             if (pi - pl < pr - pi) {
                 *sptr++ = pi + 1;
@@ -152,8 +157,10 @@
         for(pi = pl + 1; pi <= pr; ++pi) {
             vi = *pi;
             vp = v[vi];
-            for(pj = pi, pt = pi - 1; pj > pl && @lessthan@(vp, v[*pt]);) {
-                *pj-- = *pt--;
+            pj = pi;
+            pk = pi - 1;
+            while (pj > pl && @lessthan@(vp, v[*pk])) {
+                *pj-- = *pk--;
             }
             *pj = vi;
         }
@@ -263,32 +270,35 @@
 
     if (pr - pl > SMALL_MERGESORT) {
         /* merge sort */
-        pm = pl + ((pr - pl + 1)>>1);
-        @TYPE at _mergesort0(pl,pm-1,pw);
-        @TYPE at _mergesort0(pm,pr,pw);
-        for(pi = pw, pj = pl; pj < pm; ++pi, ++pj) {
-            *pi = *pj;
+        pm = pl + ((pr - pl) >> 1);
+        @TYPE at _mergesort0(pl, pm, pw);
+        @TYPE at _mergesort0(pm, pr, pw);
+        for(pi = pw, pj = pl; pj < pm;) {
+            *pi++ = *pj++;
         }
-        for(pk = pw, pm = pl; pk < pi && pj <= pr; ++pm) {
-            if (@lessequal@(*pk,*pj)) {
-                *pm = *pk;
-                ++pk;
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (@lessequal@(*pj,*pm)) {
+                *pk = *pj++;
             }
             else {
-                *pm = *pj;
-                ++pj;
+                *pk = *pm++;
             }
+            pk++;
         }
-        for(; pk < pi; ++pm, ++pk) {
-            *pm = *pk;
+        while(pj < pi) {
+            *pk++ = *pj++;
         }
     }
     else {
         /* insertion sort */
-        for(pi = pl + 1; pi <= pr; ++pi) {
+        for(pi = pl + 1; pi < pr; ++pi) {
             vp = *pi;
-            for(pj = pi, pk = pi - 1; pj > pl && @lessthan@(vp, *pk); --pj, --pk) {
-                *pj = *pk;
+            pj = pi;
+            pk = pi -1;
+            while (pj > pl && @lessthan@(vp, *pk)) {
+                *pj-- = *pk--;
             }
             *pj = vp;
         }
@@ -300,17 +310,16 @@
 {
     @type@ *pl, *pr, *pw;
 
-    pl = start; pr = pl + num - 1;
-    pw = (@type@ *) PyDataMem_NEW(((1+num/2))*sizeof(@type@));
-
+    pl = start;
+    pr = pl + num;
+    pw = (@type@ *) PyDataMem_NEW((num/2)*sizeof(@type@));
     if (!pw) {
         PyErr_NoMemory();
         return -1;
     }
+    @TYPE at _mergesort0(pl, pr, pw);
 
-    @TYPE at _mergesort0(pl, pr, pw);
     PyDataMem_FREE(pw);
-
     return 0;
 }
 
@@ -398,9 +407,14 @@
 static void
 copy_string(char *s1, char *s2, size_t len)
 {
-    while(len--) {
-        *s1++ = *s2++;
+    if (len < SMALL_STRING) {
+        while(len--) {
+            *s1++ = *s2++;
+        }
     }
+    else {
+        memcpy(s1, s2, len);
+    }
 }
 
 static void
@@ -456,7 +470,81 @@
    #copy=copy_string, copy_ucs4#
 **/
 
+static void
+ at TYPE@_mergesort0(@type@ *pl, @type@ *pr, @type@ *pw, @type@ *vp, size_t len)
+{
+    @type@ *pi, *pj, *pk, *pm;
+
+    if (pr - pl > SMALL_MERGESORT*len) {
+        /* merge sort */
+        pm = pl + (((pr - pl)/len) >> 1)*len;
+        @TYPE at _mergesort0(pl, pm, pw, vp, len);
+        @TYPE at _mergesort0(pm, pr, pw, vp, len);
+        @copy@(pw, pl, pm - pl);
+        pi = pw + (pm - pl);
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (@lessequal@(pj, pm, len)) {
+                @copy@(pk, pj, len);
+                pj += len;
+            }
+            else {
+                @copy@(pk, pm, len);
+                pm += len;
+            }
+            pk += len;
+        }
+        @copy@(pk, pj, pi - pj);
+    }
+    else {
+        /* insertion sort */
+        for(pi = pl + len; pi < pr; pi += len) {
+            @copy@(vp, pi, len);
+            pj = pi;
+            pk = pi - len;
+            while (pj > pl && @lessthan@(vp, pk, len)) {
+                @copy@(pj, pk, len);
+                pj -= len;
+                pk -= len;
+            }
+            @copy@(pj, vp, len);
+        }
+    }
+}
+
 static int
+ at TYPE@_mergesort(@type@ *start, intp num, PyArrayObject *arr)
+{
+    const size_t elsize = arr->descr->elsize;
+    const size_t len = elsize / sizeof(@type@);
+    @type@ *pl, *pr, *pw, *vp;
+    int err = 0;
+
+    pl = start;
+    pr = pl + num*len;
+    pw = (@type@ *) PyDataMem_NEW((num/2)*elsize);
+    if (!pw) {
+        PyErr_NoMemory();
+        err = -1;
+        goto fail_0;
+    }
+    vp = (@type@ *) PyDataMem_NEW(elsize);
+    if (!vp) {
+        PyErr_NoMemory();
+        err = -1;
+        goto fail_1;
+    }
+    @TYPE at _mergesort0(pl, pr, pw, vp, len);
+
+    PyDataMem_FREE(vp);
+fail_1:
+    PyDataMem_FREE(pw);
+fail_0:
+    return err;
+}
+
+static int
 @TYPE at _quicksort(@type@ *start, intp num, PyArrayObject *arr)
 {
     const size_t len = arr->descr->elsize/sizeof(@type@);
@@ -466,7 +554,7 @@
     @type@ *stack[PYA_QS_STACK], **sptr = stack, *pm, *pi, *pj, *pk;
 
     for(;;) {
-        while ((pr - pl) > 5*len) {
+        while ((pr - pl) > SMALL_QUICKSORT*len) {
             /* quicksort partition */
             pm = pl + (((pr - pl)/len) >> 1)*len;
             if (@lessthan@(pm, pl, len)) @swap@(pm, pl, len);
@@ -502,7 +590,7 @@
             @copy@(vp, pi, len);
             pj = pi;
             pk = pi - len;
-            while(pj > pl && @lessthan@(vp, pk, len)) {
+            while (pj > pl && @lessthan@(vp, pk, len)) {
                 @copy@(pj, pk, len);
                 pj -= len;
                 pk -= len;
@@ -641,7 +729,8 @@
                 if (pi >= pj)  break;
                 SWAP(*pi,*pj);
             }
-            SWAP(*pi,*(pr-1));
+            pk = pr - 1;
+            SWAP(*pi,*pk);
             /* push largest partition on stack */
             if (pi - pl < pr - pi) {
                 *sptr++ = pi + 1;
@@ -660,8 +749,8 @@
             vi = *pi;
             vp = v + vi*len;
             pj = pi;
-            pk = pi -1;
-            while(pj > pl && @lessthan@(vp, v + (*pk)*len, len)) {
+            pk = pi - 1;
+            while (pj > pl && @lessthan@(vp, v + (*pk)*len, len)) {
                 *pj-- = *pk--;
             }
             *pj = vi;
@@ -683,30 +772,33 @@
 
     if (pr - pl > SMALL_MERGESORT) {
         /* merge sort */
-        pm = pl + ((pr - pl + 1)>>1);
-        @TYPE at _amergesort0(pl,pm-1,v,pw,len);
+        pm = pl + ((pr - pl) >> 1);
+        @TYPE at _amergesort0(pl,pm,v,pw,len);
         @TYPE at _amergesort0(pm,pr,v,pw,len);
         for(pi = pw, pj = pl; pj < pm;) {
             *pi++ = *pj++;
         }
-        for(pk = pw, pm = pl; pk < pi && pj <= pr;) {
-            if (@lessequal@(v + (*pk)*len, v + (*pj)*len, len)) {
-                *pm++ = *pk++;
+        pj = pw;
+        pk = pl;
+        while (pj < pi && pm < pr) {
+            if (@lessequal@(v + (*pj)*len, v + (*pm)*len, len)) {
+                *pk = *pj++;
             } else {
-                *pm++ = *pj++;
+                *pk = *pm++;
             }
+            pk++;
         }
-        while(pk < pi) {
-            *pm++ = *pk++;
+        while (pj < pi) {
+            *pk++ = *pj++;
         }
     } else {
         /* insertion sort */
-        for(pi = pl + 1; pi <= pr; ++pi) {
+        for(pi = pl + 1; pi < pr; ++pi) {
             vi = *pi;
             vp = v + vi*len;
             pj = pi;
             pk = pi -1;
-            while(pj > pl && @lessthan@(vp, v + (*pk)*len, len)) {
+            while (pj > pl && @lessthan@(vp, v + (*pk)*len, len)) {
                 *pj-- = *pk--;
             }
             *pj = vi;
@@ -718,24 +810,20 @@
 static int
 @TYPE at _amergesort(@type@ *v, intp *tosort, intp num, PyArrayObject *arr)
 {
+    const size_t elsize = arr->descr->elsize;
+    const size_t len = elsize / sizeof(@type@);
     intp *pl, *pr, *pw;
-    int elsize, chars;
 
-    elsize = arr->descr->elsize;
-
-    chars = elsize / sizeof(@type@);
-
-    pl = tosort; pr = pl + num - 1;
-    pw = PyDimMem_NEW((1+num/2));
-
+    pl = tosort;
+    pr = pl + num;
+    pw = PyDimMem_NEW(num/2);
     if (!pw) {
         PyErr_NoMemory();
         return -1;
     }
+    @TYPE at _amergesort0(pl, pr, v, pw, len);
 
-    @TYPE at _amergesort0(pl, pr, v, pw, chars);
     PyDimMem_FREE(pw);
-
     return 0;
 }
 /**end repeat**/
@@ -746,7 +834,7 @@
     PyArray_Descr *descr;
 
     /**begin repeat
-       #TYPE=BOOL,BYTE,UBYTE,SHORT,USHORT,INT,UINT,LONG,ULONG,LONGLONG,ULONGLONG,FLOAT,DOUBLE,LONGDOUBLE,CFLOAT,CDOUBLE,CLONGDOUBLE#
+       #TYPE=BOOL,BYTE,UBYTE,SHORT,USHORT,INT,UINT,LONG,ULONG,LONGLONG,ULONGLONG,FLOAT,DOUBLE,LONGDOUBLE,CFLOAT,CDOUBLE,CLONGDOUBLE,STRING,UNICODE#
     **/
     descr = PyArray_DescrFromType(PyArray_ at TYPE@);
     descr->f->sort[PyArray_QUICKSORT] = \
@@ -763,29 +851,6 @@
         (PyArray_ArgSortFunc *)@TYPE at _amergesort;
     /**end repeat**/
 
-    descr = PyArray_DescrFromType(PyArray_STRING);
-    descr->f->argsort[PyArray_MERGESORT] = \
-        (PyArray_ArgSortFunc *)STRING_amergesort;
-    descr->f->argsort[PyArray_QUICKSORT] = \
-        (PyArray_ArgSortFunc *)STRING_aquicksort;
-    descr->f->argsort[PyArray_HEAPSORT] = \
-        (PyArray_ArgSortFunc *)STRING_aheapsort;
-    descr->f->sort[PyArray_QUICKSORT] = \
-        (PyArray_SortFunc *)STRING_quicksort;
-    descr->f->sort[PyArray_HEAPSORT] = \
-        (PyArray_SortFunc *)STRING_heapsort;
-
-    descr = PyArray_DescrFromType(PyArray_UNICODE);
-    descr->f->argsort[PyArray_MERGESORT] = \
-        (PyArray_ArgSortFunc *)UNICODE_amergesort;
-    descr->f->argsort[PyArray_QUICKSORT] = \
-        (PyArray_ArgSortFunc *)UNICODE_aquicksort;
-    descr->f->argsort[PyArray_HEAPSORT] = \
-        (PyArray_ArgSortFunc *)UNICODE_aheapsort;
-    descr->f->sort[PyArray_QUICKSORT] = \
-        (PyArray_SortFunc *)UNICODE_quicksort;
-    descr->f->sort[PyArray_HEAPSORT] = \
-        (PyArray_SortFunc *)UNICODE_heapsort;
 }
 
 static struct PyMethodDef methods[] = {

Modified: trunk/numpy/core/tests/test_multiarray.py
===================================================================
--- trunk/numpy/core/tests/test_multiarray.py	2008-02-14 01:32:35 UTC (rev 4804)
+++ trunk/numpy/core/tests/test_multiarray.py	2008-02-14 07:24:13 UTC (rev 4805)
@@ -290,11 +290,11 @@
             c.sort(kind=kind)
             assert_equal(c, ai, msg)
 
-        # test string sorts. Only quick and heap sort are available.
+        # test string sorts.
         s = 'aaaaaaaa'
         a = np.array([s + chr(i) for i in range(100)])
         b = a[::-1].copy()
-        for kind in ['q', 'h'] :
+        for kind in ['q', 'm', 'h'] :
             msg = "string sort, kind=%s" % kind
             c = a.copy();
             c.sort(kind=kind)
@@ -303,11 +303,11 @@
             c.sort(kind=kind)
             assert_equal(c, a, msg)
 
-        # test unicode sort. Only quick and heap sort are available.
+        # test unicode sort.
         s = 'aaaaaaaa'
         a = np.array([s + chr(i) for i in range(100)], dtype=np.unicode)
         b = a[::-1].copy()
-        for kind in ['q', 'h'] :
+        for kind in ['q', 'm', 'h'] :
             msg = "unicode sort, kind=%s" % kind
             c = a.copy();
             c.sort(kind=kind)



From numpy-svn at scipy.org  Fri Feb 15 11:20:17 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 15 Feb 2008 10:20:17 -0600 (CST)
Subject: [Numpy-svn] r4806 - trunk/numpy/lib
Message-ID: <20080215162017.2662039C3EE@new.scipy.org>

Author: dhuard
Date: 2008-02-15 10:20:15 -0600 (Fri, 15 Feb 2008)
New Revision: 4806

Modified:
   trunk/numpy/lib/function_base.py
Log:
For 4D samples, histogramdd returned badly shaped histograms once in a while. This should be fixed now.

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-14 07:24:13 UTC (rev 4805)
+++ trunk/numpy/lib/function_base.py	2008-02-15 16:20:15 UTC (rev 4806)
@@ -303,7 +303,7 @@
     # Shape into a proper matrix
     hist = hist.reshape(sort(nbin))
     for i in arange(nbin.size):
-        j = ni[i]
+        j = ni.argsort()[i]
         hist = hist.swapaxes(i,j)
         ni[i],ni[j] = ni[j],ni[i]
 
@@ -320,6 +320,8 @@
             hist = hist / dedges[i].reshape(shape)
         hist /= s
 
+    if (hist.shape != nbin-2).any():
+        raise 'Internal Shape Error'
     return hist, edges
 
 



From numpy-svn at scipy.org  Fri Feb 15 14:40:29 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 15 Feb 2008 13:40:29 -0600 (CST)
Subject: [Numpy-svn] r4807 - in trunk/numpy/ma: . tests
Message-ID: <20080215194029.82EDD39C0FB@new.scipy.org>

Author: pierregm
Date: 2008-02-15 13:39:10 -0600 (Fri, 15 Feb 2008)
New Revision: 4807

Modified:
   trunk/numpy/ma/API_CHANGES.txt
   trunk/numpy/ma/core.py
   trunk/numpy/ma/morestats.py
   trunk/numpy/ma/mstats.py
   trunk/numpy/ma/tests/test_core.py
Log:
updated API_CHANGES.txt
mstats : updated docstrings
morestats : updated docstrings
core : fixed __setitem__ for records

Modified: trunk/numpy/ma/API_CHANGES.txt
===================================================================
--- trunk/numpy/ma/API_CHANGES.txt	2008-02-15 16:20:15 UTC (rev 4806)
+++ trunk/numpy/ma/API_CHANGES.txt	2008-02-15 19:39:10 UTC (rev 4807)
@@ -4,6 +4,52 @@
 API changes in the new masked array implementation
 ==================================================
 
+Masked arrays are subclasses of ndarray
+---------------------------------------
+
+Contrary to the original implementation, masked arrays are now regular ndarrays::
+
+  >>> x = masked_array([1,2,3],mask=[0,0,1])
+  >>> print isinstance(x, numpy.ndarray)
+  True
+
+
+``_data`` returns a view of the masked array
+--------------------------------------------
+
+Masked arrays are composed of a ``_data`` part and a ``_mask``. Accessing the
+``_data`` part will return a regular ndarray or any of its subclass, depending
+on the initial data::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> print x._data
+  [[1 2]
+   [3 4]]
+  >>> print type(x._data)
+  <class 'numpy.core.defmatrix.matrix'>
+
+
+In practice, ``_data`` is implemented as a property, not as an attribute.
+Therefore, you cannot access it directly, and some simple tests such as the
+following one will fail::
+
+  >>>x._data is x._data
+  False
+
+
+``filled(x)`` can return a subclass of ndarray
+-------------
+The function ``filled(a)`` returns an array of the same type as ``a._data``::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> y = filled(x)
+  >>> print type(y)
+  <class 'numpy.core.defmatrix.matrix'>
+  >>> print y
+  matrix([[     1,      2],
+          [     3, 999999]])
+
+
 ``put``, ``putmask`` behave like their ndarray counterparts
 -----------------------------------------------------------
 
@@ -66,3 +112,27 @@
     File "<stdin>", line 1, in <module>
   ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
 
+
+==================================
+New features (non exhaustive list)
+==================================
+
+``mr_``
+-------
+
+``mr_`` mimics the behavior of ``r_`` for masked arrays::
+
+``anom``
+--------
+
+The ``anom`` method returns the deviations from the average (anomalies).
+
+``varu`` and ``stdu``
+---------------------
+
+These methods return unbiased estimates of the variance and standard deviation
+respectively. An unbiased estimate is obtained by dividing the sum of the
+squared anomalies by ``n-1`` instead of ``n`` for the biased estimates, where
+``n`` is the number of unmasked elements along the given axis.
+
+

Modified: trunk/numpy/ma/core.py
===================================================================
--- trunk/numpy/ma/core.py	2008-02-15 16:20:15 UTC (rev 4806)
+++ trunk/numpy/ma/core.py	2008-02-15 19:39:10 UTC (rev 4807)
@@ -1358,7 +1358,7 @@
             self._sharedmask = False
             return
         #....
-        dval = getdata(value).astype(self.dtype)
+        dval = narray(value, copy=False, dtype=self.dtype)
         valmask = getmask(value)
         if self._mask is nomask:
             if valmask is not nomask:
@@ -3305,3 +3305,15 @@
     return cPickle.loads(strg)
 
 ################################################################################
+
+if 1:
+    from testutils import assert_equal
+    if 1:
+        mtype = [('f',float_),('s','|S3')]
+        x = array([(1,'a'),(2,'b'),(numpy.pi,'pi')], dtype=mtype)
+        x[0] = (10,'A')
+        (xf, xs) = (x['f'], x['s'])
+        assert_equal(xf.data, [10,2,numpy.pi])
+        assert_equal(xf.dtype, float_)
+        assert_equal(xs.data, ['A', 'b', 'pi'])
+        assert_equal(xs.dtype, '|S3')

Modified: trunk/numpy/ma/morestats.py
===================================================================
--- trunk/numpy/ma/morestats.py	2008-02-15 16:20:15 UTC (rev 4806)
+++ trunk/numpy/ma/morestats.py	2008-02-15 19:39:10 UTC (rev 4807)
@@ -40,22 +40,26 @@
     """Computes quantile estimates with the Harrell-Davis method, where the estimates
 are calculated as a weighted linear combination of order statistics.
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+----------
+    data: ndarray
         Data array.
-    prob: {sequence}
+    prob: sequence
         Sequence of quantiles to compute.
-    axis : {integer}
+    axis : int
         Axis along which to compute the quantiles. If None, use a flattened array.
-    var : {boolean}
+    var : boolean
         Whether to return the variance of the estimate.
 
-*Returns*
+Returns
+-------
     A (p,) array of quantiles (if ``var`` is False), or a (2,p) array of quantiles
     and variances (if ``var`` is True), where ``p`` is the number of quantiles.
 
-:Note:
+Notes
+-----
     The function is restricted to 2D arrays.
+    
     """
     def _hd_1D(data,prob,var):
         "Computes the HD quantiles for a 1D array. Returns nan for invalid data."
@@ -102,13 +106,15 @@
 def hdmedian(data, axis=-1, var=False):
     """Returns the Harrell-Davis estimate of the median along the given axis.
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+----------
+    data: ndarray
         Data array.
-    axis : {integer}
+    axis : int
         Axis along which to compute the quantiles. If None, use a flattened array.
-    var : {boolean}
+    var : boolean
         Whether to return the variance of the estimate.
+        
     """
     result = hdquantiles(data,[0.5], axis=axis, var=var)
     return result.squeeze()
@@ -119,16 +125,19 @@
     """Computes the standard error of the Harrell-Davis quantile estimates by jackknife.
 
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+----------
+    data: ndarray
         Data array.
-    prob: {sequence}
+    prob: sequence
         Sequence of quantiles to compute.
-    axis : {integer}
+    axis : int
         Axis along which to compute the quantiles. If None, use a flattened array.
 
-*Note*:
+Notes
+-----
     The function is restricted to 2D arrays.
+    
     """
     def _hdsd_1D(data,prob):
         "Computes the std error for 1D arrays."
@@ -172,16 +181,18 @@
     """Returns the selected confidence interval of the trimmed mean along the
 given axis.
 
-*Parameters* :
-    data : {sequence}
+Parameters
+----------
+    data : sequence
         Input data. The data is transformed to a masked array
-    proportiontocut : {float}
+    proportiontocut : float
         Proportion of the data to cut from each side of the data .
         As a result, (2*proportiontocut*n) values are actually trimmed.
-    alpha : {float}
+    alpha : float
         Confidence level of the intervals.
-    axis : {integer}
+    axis : int
         Axis along which to cut. If None, uses a flattened version of the input.
+    
     """
     data = masked_array(data, copy=False)
     trimmed = trim_both(data, proportiontocut=proportiontocut, axis=axis)
@@ -196,13 +207,15 @@
     """Returns the Maritz-Jarrett estimators of the standard error of selected
 experimental quantiles of the data.
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+-----------
+    data: ndarray
         Data array.
-    prob: {sequence}
+    prob: sequence
         Sequence of quantiles to compute.
-    axis : {integer}
+    axis : int
         Axis along which to compute the quantiles. If None, use a flattened array.
+    
     """
     def _mjci_1D(data, p):
         data = data.compressed()
@@ -236,14 +249,15 @@
     """Computes the alpha confidence interval for the selected quantiles of the
 data, with Maritz-Jarrett estimators.
 
-*Parameters* :
-    data: {ndarray}
+Parameters
+----------
+    data: ndarray
         Data array.
-    prob: {sequence}
+    prob: sequence
         Sequence of quantiles to compute.
-    alpha : {float}
+    alpha : float
         Confidence level of the intervals.
-    axis : {integer}
+    axis : integer
         Axis along which to compute the quantiles. If None, use a flattened array.
     """
     alpha = min(alpha, 1-alpha)
@@ -258,13 +272,14 @@
     """Computes the alpha-level confidence interval for the median of the data,
 following the Hettmasperger-Sheather method.
 
-*Parameters* :
-    data : {sequence}
+Parameters
+----------
+    data : sequence
         Input data. Masked values are discarded. The input should be 1D only, or
         axis should be set to None.
-    alpha : {float}
+    alpha : float
         Confidence level of the intervals.
-    axis : {integer}
+    axis : integer
         Axis along which to compute the quantiles. If None, use a flattened array.
     """
     def _cihs_1D(data, alpha):
@@ -299,7 +314,8 @@
 The comparison is performed using the McKean-Schrader estimate of the standard
 error of the medians.
 
-*Parameters* :
+Parameters
+----------
     group_1 : {sequence}
         First dataset.
     group_2 : {sequence}
@@ -307,7 +323,8 @@
     axis : {integer}
         Axis along which the medians are estimated. If None, the arrays are flattened.
 
-*Returns* :
+Returns
+-------
     A (p,) array of comparison values.
 
     """
@@ -325,22 +342,23 @@
 #..............................................................................
 def rank_data(data, axis=None, use_missing=False):
     """Returns the rank (also known as order statistics) of each data point
-along the given axis.
+    along the given axis.
 
-If some values are tied, their rank is averaged.
-If some values are masked, their rank is set to 0 if use_missing is False, or
-set to the average rank of the unmasked values if use_missing is True.
+    If some values are tied, their rank is averaged.
+    If some values are masked, their rank is set to 0 if use_missing is False, 
+    or set to the average rank of the unmasked values if use_missing is True.
 
-*Parameters* :
-    data : {sequence}
-        Input data. The data is transformed to a masked array
-    axis : {integer}
-        Axis along which to perform the ranking. If None, the array is first
-        flattened. An exception is raised if the axis is specified for arrays
-        with a dimension larger than 2
-    use_missing : {boolean}
-        Whether the masked values have a rank of 0 (False) or equal to the
-        average rank of the unmasked values (True).
+    Parameters
+    ----------
+        data : sequence
+            Input data. The data is transformed to a masked array
+        axis : integer
+            Axis along which to perform the ranking. 
+            If None, the array is first flattened. An exception is raised if 
+            the axis is specified for arrays with a dimension larger than 2
+        use_missing : boolean
+            Whether the masked values have a rank of 0 (False) or equal to the
+            average rank of the unmasked values (True).
     """
     #
     def _rank1d(data, use_missing=False):

Modified: trunk/numpy/ma/mstats.py
===================================================================
--- trunk/numpy/ma/mstats.py	2008-02-15 16:20:15 UTC (rev 4806)
+++ trunk/numpy/ma/mstats.py	2008-02-15 19:39:10 UTC (rev 4807)
@@ -33,16 +33,20 @@
 
 def winsorize(data, alpha=0.2):
     """Returns a Winsorized version of the input array.
+    
+    The (alpha/2.) lowest values are set to the (alpha/2.)th percentile, 
+    and the (alpha/2.) highest values are set to the (1-alpha/2.)th 
+    percentile.
+    Masked values are skipped.
 
-The (alpha/2.) lowest values are set to the (alpha/2.)th percentile, and
-the (alpha/2.) highest values are set to the (1-alpha/2.)th percentile
-Masked values are skipped.
+    Parameters
+    ----------
+        data : ndarray
+            Input data to Winsorize. The data is first flattened.
+        alpha : float
+            Percentage of total Winsorization: alpha/2. on the left, 
+            alpha/2. on the right
 
-*Parameters*:
-    data : {ndarray}
-        Input data to Winsorize. The data is first flattened.
-    alpha : {float}, optional
-        Percentage of total Winsorization : alpha/2. on the left, alpha/2. on the right
     """
     data = masked_array(data, copy=False).ravel()
     idxsort = data.argsort()
@@ -53,18 +57,26 @@
 
 #..............................................................................
 def trim_both(data, proportiontocut=0.2, axis=None):
-    """Trims the data by masking the int(trim*n) smallest and int(trim*n) largest
-values of data along the given axis, where n is the number of unmasked values.
+    """Trims the data by masking the int(trim*n) smallest and int(trim*n) 
+    largest values of data along the given axis, where n is the number 
+    of unmasked values.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    proportiontocut : {float}
-        Percentage of trimming. If n is the number of unmasked values before trimming,
-        the number of values after trimming is (1-2*trim)*n.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        proportiontocut : float
+            Percentage of trimming. If n is the number of unmasked values 
+            before trimming, the number of values after trimming is:
+                (1-2*trim)*n.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
+
+    Notes
+    -----
+        The function works only for arrays up to 2D.
+
     """
     #...................
     def _trim_1D(data, trim):
@@ -87,22 +99,30 @@
 
 #..............................................................................
 def trim_tail(data, proportiontocut=0.2, tail='left', axis=None):
-    """Trims the data by masking int(trim*n) values from ONE tail of the data
-along the given axis, where n is the number of unmasked values.
+    """Trims the data by masking int(trim*n) values from ONE tail of the 
+    data along the given axis, where n is the number of unmasked values.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    proportiontocut : {float}
-        Percentage of trimming. If n is the number of unmasked values before trimming,
-        the number of values after trimming is (1-trim)*n.
-    tail : {string}
-        Trimming direction, in ('left', 'right'). If left, the proportiontocut
-        lowest values are set to the corresponding percentile. If right, the
-        proportiontocut highest values are used instead.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        proportiontocut : float
+            Percentage of trimming. If n is the number of unmasked values 
+            before trimming, the number of values after trimming is 
+            (1-trim)*n.
+        tail : string
+            Trimming direction, in ('left', 'right'). 
+            If left, the ``proportiontocut`` lowest values are set to the 
+            corresponding percentile. If right, the ``proportiontocut`` 
+            highest values are used instead.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
+
+    Notes
+    -----
+        The function works only for arrays up to 2D.
+
     """
     #...................
     def _trim_1D(data, trim, left):
@@ -138,35 +158,43 @@
 
 #..............................................................................
 def trimmed_mean(data, proportiontocut=0.2, axis=None):
-    """Returns the trimmed mean of the data along the given axis. Trimming is
-performed on both ends of the distribution.
+    """Returns the trimmed mean of the data along the given axis. 
+    Trimming is performed on both ends of the distribution.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    proportiontocut : {float}
-        Proportion of the data to cut from each side of the data .
-        As a result, (2*proportiontocut*n) values are actually trimmed.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        proportiontocut : float
+            Proportion of the data to cut from each side of the data .
+            As a result, (2*proportiontocut*n) values are actually trimmed.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
+
     """
     return trim_both(data, proportiontocut=proportiontocut, axis=axis).mean(axis=axis)
 
 #..............................................................................
 def trimmed_stde(data, proportiontocut=0.2, axis=None):
     """Returns the standard error of the trimmed mean for the input data,
-along the given axis. Trimming is performed on both ends of the distribution.
+    along the given axis. Trimming is performed on both ends of the distribution.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    proportiontocut : {float}
-        Proportion of the data to cut from each side of the data .
-        As a result, (2*proportiontocut*n) values are actually trimmed.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        proportiontocut : float
+            Proportion of the data to cut from each side of the data .
+            As a result, (2*proportiontocut*n) values are actually trimmed.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
+
+    Notes
+    -----
+        The function worrks with arrays up to 2D.
+
     """
     #........................
     def _trimmed_stde_1D(data, trim=0.2):
@@ -189,13 +217,14 @@
     """Returns the McKean-Schrader estimate of the standard error of the sample
 median along the given axis.
 
+    Parameters
+    ----------
+        data : ndarray
+            Data to trim.
+        axis : int
+            Axis along which to perform the trimming. 
+            If None, the input array is first flattened.
 
-*Parameters*:
-    data : {ndarray}
-        Data to trim.
-    axis : {integer}
-        Axis along which to perform the trimming. If None, the input array is first
-        flattened.
     """
     def _stdemed_1D(data):
         sorted = numpy.sort(data.compressed())
@@ -240,16 +269,17 @@
     - (.4,.4)  : approximately quantile unbiased (Cunnane)
     - (.35,.35): APL, used with PWM
 
-*Parameters*:
-    x : {sequence}
+Parameters
+----------
+    x : sequence
         Input data, as a sequence or array of dimension at most 2.
-    prob : {sequence}
+    prob : sequence
         List of quantiles to compute.
-    alpha : {float}
+    alpha : float
         Plotting positions parameter.
-    beta : {float}
+    beta : float
         Plotting positions parameter.
-    axis : {integer}
+    axis : int
         Axis along which to perform the trimming. If None, the input array is first
         flattened.
     """
@@ -299,6 +329,18 @@
           if x is normally distributed (R type 9)
         - (.4,.4)  : approximately quantile unbiased (Cunnane)
         - (.35,.35): APL, used with PWM
+
+Parameters
+----------
+    x : sequence
+        Input data, as a sequence or array of dimension at most 2.
+    prob : sequence
+        List of quantiles to compute.
+    alpha : float
+        Plotting positions parameter.
+    beta : float
+        Plotting positions parameter.
+
     """
     data = masked_array(data, copy=False).reshape(1,-1)
     n = data.count()
@@ -311,7 +353,11 @@
 
 
 def mmedian(data, axis=None):
-    """Returns the median of data along the given axis. Missing data are discarded."""
+    """Returns the median of data along the given axis. 
+
+    Missing data are discarded.
+
+    """
     def _median1D(data):
         x = numpy.sort(data.compressed())
         if x.size == 0:
@@ -331,17 +377,18 @@
 Normalization is by (N-1) where N is the number of observations (unbiased
 estimate).  If bias is True then normalization is by N.
 
-*Parameters*:
-    x : {ndarray}
+Parameters
+----------
+    x : ndarray
         Input data. If x is a 1D array, returns the variance. If x is a 2D array,
         returns the covariance matrix.
-    y : {ndarray}, optional
+    y : ndarray
         Optional set of variables.
-    rowvar : {boolean}
+    rowvar : boolean
         If rowvar is true, then each row is a variable with obersvations in columns.
         If rowvar is False, each column is a variable and the observations are in
         the rows.
-    bias : {boolean}
+    bias : boolean
         Whether to use a biased or unbiased estimate of the covariance.
         If bias is True, then the normalization is by N, the number of observations.
         Otherwise, the normalization is by (N-1)
@@ -400,10 +447,10 @@
     """Evalutates Rosenblatt's shifted histogram estimators for each point
 on the dataset 'data'.
 
-*Parameters* :
-    data : {sequence}
+Parameters
+    data : sequence
         Input data. Masked values are ignored.
-    points : {sequence}
+    points : sequence
         Sequence of points where to evaluate Rosenblatt shifted histogram.
         If None, use the data.
     """

Modified: trunk/numpy/ma/tests/test_core.py
===================================================================
--- trunk/numpy/ma/tests/test_core.py	2008-02-15 16:20:15 UTC (rev 4806)
+++ trunk/numpy/ma/tests/test_core.py	2008-02-15 19:39:10 UTC (rev 4807)
@@ -838,6 +838,17 @@
         assert_equal(xs.mask, [0,1,0])
         assert_equal(xs.dtype, '|S3')
     #
+    def test_set_records(self):
+        "Check setting an element of a record)"
+        mtype = [('f',float_),('s','|S3')]
+        x = array([(1,'a'),(2,'b'),(numpy.pi,'pi')], dtype=mtype)
+        x[0] = (10,'A')
+        (xf, xs) = (x['f'], x['s'])
+        assert_equal(xf.data, [10,2,numpy.pi])
+        assert_equal(xf.dtype, float_)
+        assert_equal(xs.data, ['A', 'b', 'pi'])
+        assert_equal(xs.dtype, '|S3')
+        
 
 
 #...............................................................................



From numpy-svn at scipy.org  Sat Feb 16 07:28:52 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 16 Feb 2008 06:28:52 -0600 (CST)
Subject: [Numpy-svn] r4808 - branches
Message-ID: <20080216122852.253E039C127@new.scipy.org>

Author: cdavid
Date: 2008-02-16 06:28:40 -0600 (Sat, 16 Feb 2008)
New Revision: 4808

Removed:
   branches/cleanconfig_rtm/
Log:
remove cleanconfig_rtm branch, not needed anymore





From numpy-svn at scipy.org  Sat Feb 16 07:29:51 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 16 Feb 2008 06:29:51 -0600 (CST)
Subject: [Numpy-svn] r4809 - branches
Message-ID: <20080216122951.36B6339C229@new.scipy.org>

Author: cdavid
Date: 2008-02-16 06:29:45 -0600 (Sat, 16 Feb 2008)
New Revision: 4809

Removed:
   branches/distutils_scons_command/
Log:
remove distutils_scons_command branch, not needed anymore.





From numpy-svn at scipy.org  Sat Feb 16 07:30:23 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 16 Feb 2008 06:30:23 -0600 (CST)
Subject: [Numpy-svn] r4810 - branches
Message-ID: <20080216123023.AF6F439C11C@new.scipy.org>

Author: cdavid
Date: 2008-02-16 06:30:18 -0600 (Sat, 16 Feb 2008)
New Revision: 4810

Removed:
   branches/numpy.scons/
Log:
remove numpy.scons branch, not needed anymore.





From numpy-svn at scipy.org  Sat Feb 16 07:30:50 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 16 Feb 2008 06:30:50 -0600 (CST)
Subject: [Numpy-svn] r4811 - branches
Message-ID: <20080216123050.EFE2B39C11C@new.scipy.org>

Author: cdavid
Date: 2008-02-16 06:30:46 -0600 (Sat, 16 Feb 2008)
New Revision: 4811

Removed:
   branches/cleanconfig/
Log:
remove cleanconfig branch.





From numpy-svn at scipy.org  Tue Feb 19 14:44:10 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 19 Feb 2008 13:44:10 -0600 (CST)
Subject: [Numpy-svn] r4812 - trunk/numpy/core
Message-ID: <20080219194410.619FE39C2F3@new.scipy.org>

Author: stefan
Date: 2008-02-19 13:43:56 -0600 (Tue, 19 Feb 2008)
New Revision: 4812

Modified:
   trunk/numpy/core/fromnumeric.py
Log:
Remove 'Blah, blah' from docstrings.


Modified: trunk/numpy/core/fromnumeric.py
===================================================================
--- trunk/numpy/core/fromnumeric.py	2008-02-16 12:30:46 UTC (rev 4811)
+++ trunk/numpy/core/fromnumeric.py	2008-02-19 19:43:56 UTC (rev 4812)
@@ -174,7 +174,7 @@
     *Parameters*:
 
         a : {array_like}
-            Blah.
+            Input array.
         repeats : {integer, integer_array}
             The number of repetitions for each element. If a plain integer, then
             it is applied to all elements. If an array, it needs to be of the
@@ -227,8 +227,6 @@
 def swapaxes(a, axis1, axis2):
     """Return array a with axis1 and axis2 interchanged.
 
-    Blah, Blah.
-
     """
     try:
         swapaxes = a.swapaxes
@@ -986,8 +984,6 @@
 def cumsum (a, axis=None, dtype=None, out=None):
     """Sum the array over the given axis.
 
-    Blah, Blah.
-
     """
     try:
         cumsum = a.cumsum
@@ -999,8 +995,6 @@
 def cumproduct (a, axis=None, dtype=None, out=None):
     """Return the cumulative product over the given axis.
 
-    Blah, Blah.
-
     """
     try:
         cumprod = a.cumprod
@@ -1012,8 +1006,6 @@
 def ptp(a, axis=None, out=None):
     """Return maximum - minimum along the the given dimension.
 
-    Blah, Blah.
-
     """
     try:
         ptp = a.ptp
@@ -1025,8 +1017,6 @@
 def amax(a, axis=None, out=None):
     """Return the maximum of 'a' along dimension axis.
 
-    Blah, Blah.
-
     """
     try:
         amax = a.max
@@ -1038,8 +1028,6 @@
 def amin(a, axis=None, out=None):
     """Return the minimum of a along dimension axis.
 
-    Blah, Blah.
-
     """
     try:
         amin = a.min
@@ -1052,8 +1040,6 @@
     """Return the length of a Python object interpreted as an array
     of at least 1 dimension.
 
-    Blah, Blah.
-
     """
     try:
         return len(a)
@@ -1064,8 +1050,6 @@
 def prod(a, axis=None, dtype=None, out=None):
     """Return the product of the elements along the given axis.
 
-    Blah, Blah.
-
     """
     try:
         prod = a.prod
@@ -1077,8 +1061,6 @@
 def cumprod(a, axis=None, dtype=None, out=None):
     """Return the cumulative product of the elements along the given axis.
 
-    Blah, Blah.
-
     """
     try:
         cumprod = a.cumprod



From numpy-svn at scipy.org  Tue Feb 19 18:50:00 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 19 Feb 2008 17:50:00 -0600 (CST)
Subject: [Numpy-svn] r4813 - in trunk/numpy: core lib
Message-ID: <20080219235000.D6264C7C02F@new.scipy.org>

Author: matthew.brett at gmail.com
Date: 2008-02-19 17:49:50 -0600 (Tue, 19 Feb 2008)
New Revision: 4813

Modified:
   trunk/numpy/core/fromnumeric.py
   trunk/numpy/lib/function_base.py
Log:
cumprod docstring, median input array coercion

Modified: trunk/numpy/core/fromnumeric.py
===================================================================
--- trunk/numpy/core/fromnumeric.py	2008-02-19 19:43:56 UTC (rev 4812)
+++ trunk/numpy/core/fromnumeric.py	2008-02-19 23:49:50 UTC (rev 4813)
@@ -1061,6 +1061,33 @@
 def cumprod(a, axis=None, dtype=None, out=None):
     """Return the cumulative product of the elements along the given axis.
 
+    The cumulative product is taken over the flattened array by
+    default, otherwise over the specified axis.
+
+    Parameters
+    ----------
+    a : array-like
+        Input array or object that can be converted to an array
+    axis : {None, -1, int}, optional
+        Axis along which the product is computed. The default
+        (``axis``= None) is to compute over the flattened array.
+    dtype : type, optional
+        Type to use in computing the cumulative product. For arrays of
+        integer type the default is int64 for signed ints and uint64
+        for unsigned. For arrays of float types it is the same as the
+        array type. 
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary.
+
+    Returns
+    -------
+    cumprod : ndarray.
+        A new array holding the result is returned unless out is
+        specified, in which case a reference to out is returned.
+        Return datatype is ``dtype`` if specified, otherwise int64 for
+        ints, uint64 for uints, or the input datatype otherwise.
     """
     try:
         cumprod = a.cumprod

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-19 19:43:56 UTC (rev 4812)
+++ trunk/numpy/lib/function_base.py	2008-02-19 23:49:50 UTC (rev 4813)
@@ -1208,6 +1208,8 @@
 
     Parameters
     ----------
+    a : array-like
+        Input array or object that can be converted to an array
     axis : {int, None}, optional
         Axis along which the medians are computed. The default is to
         compute the median along the first dimension.  axis=None
@@ -1234,7 +1236,7 @@
         Return datatype is float64 for ints and floats smaller than
         float64, or the input datatype otherwise.
 
-    SeeAlso
+    See Also
     -------
     mean
 
@@ -1273,6 +1275,7 @@
     3.5
     >>> assert not np.all(a==b)
     """
+    a = asanyarray(a)
     if overwrite_input:
         if axis is None:
             sorted = a.ravel()



From numpy-svn at scipy.org  Wed Feb 20 04:08:01 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 20 Feb 2008 03:08:01 -0600 (CST)
Subject: [Numpy-svn] r4814 - trunk/numpy/core
Message-ID: <20080220090801.A41C1C7C026@new.scipy.org>

Author: stefan
Date: 2008-02-20 03:07:45 -0600 (Wed, 20 Feb 2008)
New Revision: 4814

Modified:
   trunk/numpy/core/fromnumeric.py
Log:
Restructure and add to documentation.


Modified: trunk/numpy/core/fromnumeric.py
===================================================================
--- trunk/numpy/core/fromnumeric.py	2008-02-19 23:49:50 UTC (rev 4813)
+++ trunk/numpy/core/fromnumeric.py	2008-02-20 09:07:45 UTC (rev 4814)
@@ -48,33 +48,33 @@
     This function does the same thing as "fancy" indexing; however, it can
     be easier to use if you need to specify a given axis.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : array
+        The source array
+    indices : int array
+        The indices of the values to extract.
+    axis : {None, int}, optional
+        The axis over which to select values. None signifies that the
+        operation should be performed over the flattened array.
+    out : {None, array}, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype.
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices will behave.
+        'raise' -- raise an error
+        'wrap' -- wrap around
+        'clip' -- clip to the range
 
-        a : array
-            The source array
-        indices : int array
-            The indices of the values to extract.
-        axis : {None, int}, optional
-            The axis over which to select values. None signifies that the
-            operation should be performed over the flattened array.
-        out : {None, array}, optional
-            If provided, the result will be inserted into this array. It should
-            be of the appropriate shape and dtype.
-        mode : {'raise', 'wrap', 'clip'}, optional
-            Specifies how out-of-bounds indices will behave.
-            'raise' -- raise an error
-            'wrap' -- wrap around
-            'clip' -- clip to the range
+    Returns
+    -------
+    subarray : array
+        The returned array has the same type as a.
 
-    *Returns*:
+    See Also
+    --------
+    ndarray.take : equivalent method
 
-        subarray : array
-            The returned array has the same type as a.
-
-    *See Also*:
-
-       `ndarray.take` : equivalent method
-
     """
     try:
         take = a.take
@@ -87,27 +87,27 @@
 def reshape(a, newshape, order='C'):
     """Returns an array containing the data of a, but with a new shape.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : array
+        Array to be reshaped.
+    newshape : shape tuple or int
+       The new shape should be compatible with the original shape. If an
+       integer, then the result will be a 1D array of that length.
+    order : {'C', 'FORTRAN'}, optional
+        Determines whether the array data should be viewed as in C
+        (row-major) order or FORTRAN (column-major) order.
 
-        a : array
-            Array to be reshaped.
-        newshape : shape tuple or int
-           The new shape should be compatible with the original shape. If an
-           integer, then the result will be a 1D array of that length.
-        order : {'C', 'FORTRAN'}, optional
-            Determines whether the array data should be viewed as in C
-            (row-major) order or FORTRAN (column-major) order.
+    Returns
+    -------
+    reshaped_array : array
+        This will be a new view object if possible; otherwise, it will
+        return a copy.
 
-    *Returns*:
+    See Also
+    --------
+    ndarray.reshape : Equivalent method.
 
-        reshaped_array : array
-            This will be a new view object if possible; otherwise, it will
-            return a copy.
-
-    *See Also*:
-
-        `ndarray.reshape` : Equivalent method.
-
     """
     try:
         reshape = a.reshape
@@ -117,49 +117,52 @@
 
 
 def choose(a, choices, out=None, mode='raise'):
-    """Use an index array to construct a new array from a set of choices.
+    """Use an index array to construct a new array from a set of
+    choices.
 
-    Given an array of integers in {0, 1, ..., n-1} and a set of n choice arrays,
-    this function will create a new array that merges each of the choice arrays.
-    Where a value in `a` is i, then the new array will have the value that
-    choices[i] contains in the same place.
+    Given an array of integers in {0, 1, ..., n-1} and a set of n
+    choice arrays, this function will create a new array that merges
+    each of the choice arrays.  Where a value in `a` is i, then the
+    new array will have the value that choices[i] contains in the same
+    place.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : int array
+        This array must contain integers in [0, n-1], where n is the number
+        of choices.
+    choices : sequence of arrays
+        Each of the choice arrays should have the same shape as the index
+        array.
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices will behave.
+        'raise' : raise an error
+        'wrap' : wrap around
+        'clip' : clip to the range
 
-        a : int array
-            This array must contain integers in [0, n-1], where n is the number
-            of choices.
-        choices : sequence of arrays
-            Each of the choice arrays should have the same shape as the index
-            array.
-        out : array, optional
-            If provided, the result will be inserted into this array. It should
-            be of the appropriate shape and dtype
-        mode : {'raise', 'wrap', 'clip'}, optional
-            Specifies how out-of-bounds indices will behave.
-            'raise' : raise an error
-            'wrap' : wrap around
-            'clip' : clip to the range
+    Returns
+    -------
+    merged_array : array
 
-    *Returns*:
+    See Also
+    --------
+    ndarray.choose : equivalent method
 
-        merged_array : array
+    Examples
+    --------
 
-    *See Also*:
+    >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
+    ...   [20, 21, 22, 23], [30, 31, 32, 33]]
+    >>> choose([2, 3, 1, 0], choices)
+    array([20, 31, 12,  3])
+    >>> choose([2, 4, 1, 0], choices, mode='clip')
+    array([20, 31, 12,  3])
+    >>> choose([2, 4, 1, 0], choices, mode='wrap')
+    array([20,  1, 12,  3])
 
-        `ndarray.choose` : equivalent method
-
-    *Examples*
-
-        >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
-        ...   [20, 21, 22, 23], [30, 31, 32, 33]]
-        >>> choose([2, 3, 1, 0], choices)
-        array([20, 31, 12,  3])
-        >>> choose([2, 4, 1, 0], choices, mode='clip')
-        array([20, 31, 12,  3])
-        >>> choose([2, 4, 1, 0], choices, mode='wrap')
-        array([20,  1, 12,  3])
-
     """
     try:
         choose = a.choose
@@ -171,34 +174,35 @@
 def repeat(a, repeats, axis=None):
     """Repeat elements of an array.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Input array.
+    repeats : {integer, integer_array}
+        The number of repetitions for each element. If a plain integer, then
+        it is applied to all elements. If an array, it needs to be of the
+        same length as the chosen axis.
+    axis : {None, integer}, optional
+        The axis along which to repeat values. If None, then this function
+        will operated on the flattened array `a` and return a similarly flat
+        result.
 
-        a : {array_like}
-            Input array.
-        repeats : {integer, integer_array}
-            The number of repetitions for each element. If a plain integer, then
-            it is applied to all elements. If an array, it needs to be of the
-            same length as the chosen axis.
-        axis : {None, integer}, optional
-            The axis along which to repeat values. If None, then this function
-            will operated on the flattened array `a` and return a similarly flat
-            result.
+    Returns
+    -------
+    repeated_array : array
 
-    *Returns*:
+    See Also
+    --------
+    ndarray.repeat : equivalent method
 
-        repeated_array : array
+    Examples
+    --------
 
-    *See Also*:
+    >>> repeat([0, 1, 2], 2)
+    array([0, 0, 1, 1, 2, 2])
+    >>> repeat([0, 1, 2], [2, 3, 4])
+    array([0, 0, 1, 1, 1, 2, 2, 2, 2])
 
-        `ndarray.repeat` : equivalent method
-
-    *Examples*
-
-        >>> repeat([0, 1, 2], 2)
-        array([0, 0, 1, 1, 2, 2])
-        >>> repeat([0, 1, 2], [2, 3, 4])
-        array([0, 0, 1, 1, 1, 2, 2, 2, 2])
-
     """
     try:
         repeat = a.repeat
@@ -207,9 +211,20 @@
     return repeat(repeats, axis)
 
 
-def put (a, ind, v, mode='raise'):
+def put(a, ind, v, mode='raise'):
     """Set a[n] = v[n] for all n in ind.
 
+    Parameters
+    ----------
+    a : array_like (contiguous)
+        Target array.
+    ind : array_like
+        Target indices, interpreted as integers.
+    v : array_like
+        Values to place in `a` at target indices.
+
+    Notes
+    -----
     If v is shorter than mask it will be repeated as necessary.  In particular v
     can be a scalar or length 1 array.  The routine put is the equivalent of the
     following (although the loop is in C for speed):
@@ -218,8 +233,14 @@
         v = array(values, copy=False).astype(a.dtype)
         for i in ind: a.flat[i] = v[i]
 
-    a must be a contiguous numpy array.
+    Examples
+    --------
 
+    >>> x = np.arange(5)
+    >>> np.put(x,[0,2,4],[-1,-2,-3])
+    >>> print x
+    [-1  1 -2  3 -3]
+
     """
     return a.put(ind, v, mode)
 
@@ -227,6 +248,38 @@
 def swapaxes(a, axis1, axis2):
     """Return array a with axis1 and axis2 interchanged.
 
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis1 : int
+        First axis.
+    axis2 : int
+        Second axis.
+
+    Examples
+    --------
+
+    >>> x = np.array([[1,2,3]])
+    >>> np.swapaxes(x,0,1)
+    array([[1],
+           [2],
+           [3]])
+
+    >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
+    >>> x
+    array([[[0, 1],
+            [2, 3]],
+
+           [[4, 5],
+            [6, 7]]])
+    >>> np.swapaxes(x,0,2)
+    array([[[0, 4],
+            [2, 6]],
+
+           [[1, 5],
+            [3, 7]]])
+
     """
     try:
         swapaxes = a.swapaxes
@@ -238,9 +291,29 @@
 def transpose(a, axes=None):
     """Return a view of the array with dimensions permuted.
 
-    Permutes axis according to list axes.  If axes is None (default) returns
-    array with dimensions reversed.
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axes : {None, list of int}, optional
+        If None (the default), reverse dimensions, otherwise permute
+        axes according to the values given.
 
+    Examples
+    --------
+    >>> x = np.arange(4).reshape((2,2))
+    >>> x
+    array([[0, 1],
+           [2, 3]])
+
+    >>> np.transpose(x)
+    array([[0, 2],
+           [1, 3]])
+
+    >>> np.transpose(x,(0,1)) # no change, axes are kept in current order
+    array([[0, 1],
+           [2, 3]])
+
     """
     try:
         transpose = a.transpose
@@ -255,55 +328,53 @@
     Perform an inplace sort along the given axis using the algorithm
     specified by the kind keyword.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : array
+        Array to be sorted.
+    axis : {None, int} optional
+        Axis along which to sort. None indicates that the flattened
+        array should be used.
+    kind : {'quicksort', 'mergesort', 'heapsort'}, optional
+        Sorting algorithm to use.
+    order : {None, list type}, optional
+        When a is an array with fields defined, this argument specifies
+        which fields to compare first, second, etc.  Not all fields need be
+        specified.
 
-        a : array
-            Array to be sorted.
-        axis : {None, int} optional
-            Axis along which to sort. None indicates that the flattened
-            array should be used.
-        kind : {'quicksort', 'mergesort', 'heapsort'}, optional
-            Sorting algorithm to use.
-        order : {None, list type}, optional
-            When a is an array with fields defined, this argument specifies
-            which fields to compare first, second, etc.  Not all fields need be
-            specified.
+    Returns
+    -------
+    sorted_array : array of same type as a
 
-    *Returns*:
+    See Also
+    --------
+    argsort : Indirect sort.
+    lexsort : Indirect stable sort on multiple keys.
+    searchsorted : Find keys in sorted array.
 
-        sorted_array : array of same type as a
+    Notes
+    -----
+    The various sorts are characterized by average speed, worst case
+    performance, need for work space, and whether they are stable. A
+    stable sort keeps items with the same key in the same relative
+    order. The three available algorithms have the following
+    properties:
 
-    *See Also*:
+    +-----------+-------+-------------+------------+-------+
+    |    kind   | speed |  worst case | work space | stable|
+    +===========+=======+=============+============+=======+
+    | quicksort |   1   | O(n^2)      |     0      |   no  |
+    +-----------+-------+-------------+------------+-------+
+    | mergesort |   2   | O(n*log(n)) |    ~n/2    |   yes |
+    +-----------+-------+-------------+------------+-------+
+    | heapsort  |   3   | O(n*log(n)) |     0      |   no  |
+    +-----------+-------+-------------+------------+-------+
 
-        `argsort` : Indirect sort.
+    All the sort algorithms make temporary copies of the data when
+    the sort is not along the last axis. Consequently, sorts along
+    the last axis are faster and use less space than sorts along
+    other axis.
 
-        `lexsort` : Indirect stable sort on multiple keys.
-
-        `searchsorted` : Find keys in sorted array.
-
-    *Notes*
-
-        The various sorts are characterized by average speed, worst case
-        performance, need for work space, and whether they are stable. A
-        stable sort keeps items with the same key in the same relative
-        order. The three available algorithms have the following
-        properties:
-
-        +-----------+-------+-------------+------------+-------+
-        |    kind   | speed |  worst case | work space | stable|
-        +===========+=======+=============+============+=======+
-        | quicksort |   1   | O(n^2)      |     0      |   no  |
-        +-----------+-------+-------------+------------+-------+
-        | mergesort |   2   | O(n*log(n)) |    ~n/2    |   yes |
-        +-----------+-------+-------------+------------+-------+
-        | heapsort  |   3   | O(n*log(n)) |     0      |   no  |
-        +-----------+-------+-------------+------------+-------+
-
-        All the sort algorithms make temporary copies of the data when
-        the sort is not along the last axis. Consequently, sorts along
-        the last axis are faster and use less space than sorts along
-        other axis.
-
     """
     if axis is None:
         a = asanyarray(a).flatten()
@@ -321,54 +392,53 @@
     by the kind keyword. It returns an array of indices of the same shape as a
     that index data along the given axis in sorted order.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : array
+        Array to be sorted.
+    axis : {None, int} optional
+        Axis along which to sort. None indicates that the flattened
+        array should be used.
+    kind : {'quicksort', 'mergesort', 'heapsort'}, optional
+        Sorting algorithm to use.
+    order : {None, list type}, optional
+        When a is an array with fields defined, this argument specifies
+        which fields to compare first, second, etc.  Not all fields need be
+        specified.
 
-        a : array
-            Array to be sorted.
-        axis : {None, int} optional
-            Axis along which to sort. None indicates that the flattened
-            array should be used.
-        kind : {'quicksort', 'mergesort', 'heapsort'}, optional
-            Sorting algorithm to use.
-        order : {None, list type}, optional
-            When a is an array with fields defined, this argument specifies
-            which fields to compare first, second, etc.  Not all fields need be
-            specified.
+    Returns
+    -------
+    index_array : {integer_array}
+        Array of indices that sort 'a' along the specified axis.
 
-    *Returns*:
+    See Also
+    --------
+    lexsort : Indirect stable sort with multiple keys.
+    sort : Inplace sort.
 
-        index_array : {integer_array}
-            Array of indices that sort 'a' along the specified axis.
+    Notes
+    -----
+    The various sorts are characterized by average speed, worst case
+    performance, need for work space, and whether they are stable. A
+    stable sort keeps items with the same key in the same relative
+    order. The three available algorithms have the following
+    properties:
 
-    *See Also*:
+    +-----------+-------+-------------+------------+-------+
+    |    kind   | speed |  worst case | work space | stable|
+    +===========+=======+=============+============+=======+
+    | quicksort |   1   | O(n^2)      |     0      |   no  |
+    +-----------+-------+-------------+------------+-------+
+    | mergesort |   2   | O(n*log(n)) |    ~n/2    |   yes |
+    +-----------+-------+-------------+------------+-------+
+    | heapsort  |   3   | O(n*log(n)) |     0      |   no  |
+    +-----------+-------+-------------+------------+-------+
 
-        `lexsort` : Indirect stable sort with multiple keys.
+    All the sort algorithms make temporary copies of the data when
+    the sort is not along the last axis. Consequently, sorts along
+    the last axis are faster and use less space than sorts along
+    other axis.
 
-        `sort` : Inplace sort.
-
-    *Notes*
-
-        The various sorts are characterized by average speed, worst case
-        performance, need for work space, and whether they are stable. A
-        stable sort keeps items with the same key in the same relative
-        order. The three available algorithms have the following
-        properties:
-
-        +-----------+-------+-------------+------------+-------+
-        |    kind   | speed |  worst case | work space | stable|
-        +===========+=======+=============+============+=======+
-        | quicksort |   1   | O(n^2)      |     0      |   no  |
-        +-----------+-------+-------------+------------+-------+
-        | mergesort |   2   | O(n*log(n)) |    ~n/2    |   yes |
-        +-----------+-------+-------------+------------+-------+
-        | heapsort  |   3   | O(n*log(n)) |     0      |   no  |
-        +-----------+-------+-------------+------------+-------+
-
-        All the sort algorithms make temporary copies of the data when
-        the sort is not along the last axis. Consequently, sorts along
-        the last axis are faster and use less space than sorts along
-        other axis.
-
     """
     try:
         argsort = a.argsort
@@ -380,28 +450,28 @@
 def argmax(a, axis=None):
     """Returns array of indices of the maximum values of along the given axis.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array to look in.
+    axis : {None, integer}
+        If None, the index is into the flattened array, otherwise along
+        the specified axis
 
-        a : {array_like}
-            Array to look in.
-        axis : {None, integer}
-            If None, the index is into the flattened array, otherwise along
-            the specified axis
+    Returns
+    -------
+    index_array : {integer_array}
 
-    *Returns*:
+    Examples
+    --------
+    >>> a = arange(6).reshape(2,3)
+    >>> argmax(a)
+    5
+    >>> argmax(a,0)
+    array([1, 1, 1])
+    >>> argmax(a,1)
+    array([2, 2])
 
-        index_array : {integer_array}
-
-    *Examples*
-
-        >>> a = arange(6).reshape(2,3)
-        >>> argmax(a)
-        5
-        >>> argmax(a,0)
-        array([1, 1, 1])
-        >>> argmax(a,1)
-        array([2, 2])
-
     """
     try:
         argmax = a.argmax
@@ -413,28 +483,28 @@
 def argmin(a, axis=None):
     """Return array of indices to the minimum values along the given axis.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array to look in.
+    axis : {None, integer}
+        If None, the index is into the flattened array, otherwise along
+        the specified axis
 
-        a : {array_like}
-            Array to look in.
-        axis : {None, integer}
-            If None, the index is into the flattened array, otherwise along
-            the specified axis
+    Returns
+    -------
+    index_array : {integer_array}
 
-    *Returns*:
+    Examples
+    --------
+    >>> a = arange(6).reshape(2,3)
+    >>> argmin(a)
+    0
+    >>> argmin(a,0)
+    array([0, 0, 0])
+    >>> argmin(a,1)
+    array([0, 0])
 
-        index_array : {integer_array}
-
-    *Examples*
-
-        >>> a = arange(6).reshape(2,3)
-        >>> argmin(a)
-        0
-        >>> argmin(a,0)
-        array([0, 0, 0])
-        >>> argmin(a,1)
-        array([0, 0])
-
     """
     try:
         argmin = a.argmin
@@ -453,40 +523,39 @@
     is out of bounds, then the length of a is returned, i.e., the key would need
     to be appended. The returned index array has the same shape as v.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : 1-d array
+        Array must be sorted in ascending order.
+    v : array or list type
+        Array of keys to be searched for in a.
+    side : {'left', 'right'}, optional
+        If 'left', the index of the first location where the key could be
+        inserted is found, if 'right', the index of the last such element is
+        returned. If the is no such element, then either 0 or N is returned,
+        where N is the size of the array.
 
-        a : 1-d array
-            Array must be sorted in ascending order.
-        v : array or list type
-            Array of keys to be searched for in a.
-        side : {'left', 'right'}, optional
-            If 'left', the index of the first location where the key could be
-            inserted is found, if 'right', the index of the last such element is
-            returned. If the is no such element, then either 0 or N is returned,
-            where N is the size of the array.
+    Returns
+    -------
+    indices : integer array
+        Array of insertion points with the same shape as v.
 
-    *Returns*:
+    See Also
+    --------
+    sort : Inplace sort.
+    histogram : Produce histogram from 1-d data.
 
-        indices : integer array
-            Array of insertion points with the same shape as v.
+    Notes
+    -----
+    The array a must be 1-d and is assumed to be sorted in ascending
+    order.  Searchsorted uses binary search to find the required
+    insertion points.
 
-    *See Also*:
+    Examples
+    --------
+    >>> searchsorted([1,2,3,4,5],[6,4,0])
+    array([5, 3, 0])
 
-        `sort` : Inplace sort.
-
-        `histogram` : Produce histogram from 1-d data.
-
-    *Notes*
-
-        The array a must be 1-d and is assumed to be sorted in ascending
-        order.  Searchsorted uses binary search to find the required
-        insertion points.
-
-    *Examples*
-
-        >>> searchsorted([1,2,3,4,5],[6,4,0])
-        array([5, 3, 0])
-
     """
     try:
         searchsorted = a.searchsorted
@@ -504,21 +573,21 @@
     Note that a.resize(new_shape) will fill the array with 0's beyond
     current definition of a.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array to be reshaped.
 
-        a : {array_like}
-            Array to be reshaped.
+    new_shape : {tuple}
+        Shape of reshaped array.
 
-        new_shape : {tuple}
-            Shape of reshaped array.
+    Returns
+    -------
+    reshaped_array : {array}
+        The new array is formed from the data in the old array, repeated if
+        necessary to fill out the required number of elements, with the new
+        shape.
 
-    *Returns*:
-
-        reshaped_array : {array}
-            The new array is formed from the data in the old array, repeated if
-            necessary to fill out the required number of elements, with the new
-            shape.
-
     """
     if isinstance(new_shape, (int, nt.integer)):
         new_shape = (new_shape,)
@@ -546,18 +615,18 @@
 def squeeze(a):
     """Remove single-dimensional entries from the shape of a.
 
-    *Examples*
+    Examples
+    --------
+    >>> x = array([[[1,1,1],[2,2,2],[3,3,3]]])
+    >>> x
+    array([[[1, 1, 1],
+          [2, 2, 2],
+          [3, 3, 3]]])
+    >>> x.shape
+    (1, 3, 3)
+    >>> squeeze(x).shape
+    (3, 3)
 
-        >>> x = array([[[1,1,1],[2,2,2],[3,3,3]]])
-        >>> x
-        array([[[1, 1, 1],
-              [2, 2, 2],
-              [3, 3, 3]]])
-        >>> x.shape
-        (1, 3, 3)
-        >>> squeeze(x).shape
-        (3, 3)
-
     """
     try:
         squeeze = a.squeeze
@@ -576,56 +645,54 @@
     array can be determined by removing axis1 and axis2 and appending an index
     to the right equal to the size of the resulting diagonals.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array from whis the diagonals are taken.
+    offset : {0, integer}, optional
+        Offset of the diagonal from the main diagonal. Can be both positive
+        and negative. Defaults to main diagonal.
+    axis1 : {0, integer}, optional
+        Axis to be used as the first axis of the 2-d subarrays from which
+        the diagonals should be taken. Defaults to first axis.
+    axis2 : {1, integer}, optional
+        Axis to be used as the second axis of the 2-d subarrays from which
+        the diagonals should be taken. Defaults to second axis.
 
-        a : {array_like}
-            Array from whis the diagonals are taken.
-        offset : {0, integer}, optional
-            Offset of the diagonal from the main diagonal. Can be both positive
-            and negative. Defaults to main diagonal.
-        axis1 : {0, integer}, optional
-            Axis to be used as the first axis of the 2-d subarrays from which
-            the diagonals should be taken. Defaults to first axis.
-        axis2 : {1, integer}, optional
-            Axis to be used as the second axis of the 2-d subarrays from which
-            the diagonals should be taken. Defaults to second axis.
+    Returns
+    -------
+    array_of_diagonals : array of same type as a
+        If a is 2-d, a 1-d array containing the diagonal is
+        returned.  If a has larger dimensions, then an array of
+        diagonals is returned.
 
-    *Returns*:
+    See Also
+    --------
+    diag : Matlab workalike for 1-d and 2-d arrays.
+    diagflat : Create diagonal arrays.
+    trace : Sum along diagonals.
 
-        array_of_diagonals : array of same type as a
-            If a is 2-d, a 1-d array containing the diagonal is
-            returned.  If a has larger dimensions, then an array of
-            diagonals is returned.
+    Examples
+    --------
+    >>> a = arange(4).reshape(2,2)
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> a.diagonal()
+    array([0, 3])
+    >>> a.diagonal(1)
+    array([1])
 
-    *See Also*:
+    >>> a = arange(8).reshape(2,2,2)
+    >>> a
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> a.diagonal(0,-2,-1)
+    array([[0, 3],
+           [4, 7]])
 
-        `diag` : Matlab workalike for 1-d and 2-d arrays.
-
-        `diagflat` : Create diagonal arrays.
-
-        `trace` : Sum along diagonals.
-
-    *Examples*
-
-        >>> a = arange(4).reshape(2,2)
-        >>> a
-        array([[0, 1],
-               [2, 3]])
-        >>> a.diagonal()
-        array([0, 3])
-        >>> a.diagonal(1)
-        array([1])
-
-        >>> a = arange(8).reshape(2,2,2)
-        >>> a
-        array([[[0, 1],
-                [2, 3]],
-               [[4, 5],
-                [6, 7]]])
-        >>> a.diagonal(0,-2,-1)
-        array([[0, 3],
-               [4, 7]])
-
     """
     return asarray(a).diagonal(offset, axis1, axis2)
 
@@ -641,44 +708,44 @@
     to the right equal to the size of the resulting diagonals. Arrays of integer
     type are summed
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array from whis the diagonals are taken.
+    offset : {0, integer}, optional
+        Offset of the diagonal from the main diagonal. Can be both positive
+        and negative. Defaults to main diagonal.
+    axis1 : {0, integer}, optional
+        Axis to be used as the first axis of the 2-d subarrays from which
+        the diagonals should be taken. Defaults to first axis.
+    axis2 : {1, integer}, optional
+        Axis to be used as the second axis of the 2-d subarrays from which
+        the diagonals should be taken. Defaults to second axis.
+    dtype : {None, dtype}, optional
+        Determines the type of the returned array and of the accumulator
+        where the elements are summed. If dtype has the value None and a is
+        of integer type of precision less than the default integer
+        precision, then the default integer precision is used. Otherwise,
+        the precision is the same as that of a.
+    out : {None, array}, optional
+        Array into which the sum can be placed. It's type is preserved and
+        it must be of the right shape to hold the output.
 
-        a : {array_like}
-            Array from whis the diagonals are taken.
-        offset : {0, integer}, optional
-            Offset of the diagonal from the main diagonal. Can be both positive
-            and negative. Defaults to main diagonal.
-        axis1 : {0, integer}, optional
-            Axis to be used as the first axis of the 2-d subarrays from which
-            the diagonals should be taken. Defaults to first axis.
-        axis2 : {1, integer}, optional
-            Axis to be used as the second axis of the 2-d subarrays from which
-            the diagonals should be taken. Defaults to second axis.
-        dtype : {None, dtype}, optional
-            Determines the type of the returned array and of the accumulator
-            where the elements are summed. If dtype has the value None and a is
-            of integer type of precision less than the default integer
-            precision, then the default integer precision is used. Otherwise,
-            the precision is the same as that of a.
-        out : {None, array}, optional
-            Array into which the sum can be placed. It's type is preserved and
-            it must be of the right shape to hold the output.
+    Returns
+    -------
+    sum_along_diagonals : array
+        If a is 2-d, a 0-d array containing the diagonal is
+        returned.  If a has larger dimensions, then an array of
+        diagonals is returned.
 
-    *Returns*:
+    Examples
+    --------
+    >>> trace(eye(3))
+    3.0
+    >>> a = arange(8).reshape((2,2,2))
+    >>> trace(a)
+    array([6, 8])
 
-        sum_along_diagonals : array
-            If a is 2-d, a 0-d array containing the diagonal is
-            returned.  If a has larger dimensions, then an array of
-            diagonals is returned.
-
-    *Examples*
-
-        >>> trace(eye(3))
-        3.0
-        >>> a = arange(8).reshape((2,2,2))
-        >>> trace(a)
-        array([6, 8])
-
     """
     return asarray(a).trace(offset, axis1, axis2, dtype, out)
 
@@ -689,33 +756,32 @@
     are taken in the order specified by the order keyword. The new array is
     a view of a if possible, otherwise it is a copy.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
 
-        a : {array_like}
+    order : {'C','F'}, optional
+        If order is 'C' the elements are taken in row major order. If order
+        is 'F' they are taken in column major order.
 
-        order : {'C','F'}, optional
-            If order is 'C' the elements are taken in row major order. If order
-            is 'F' they are taken in column major order.
+    Returns
+    -------
+    1d_array : {array}
 
-    *Returns*:
+    See Also
+    --------
+    ndarray.flat : 1d iterator over the array.
+    ndarray.flatten : 1d array copy of the elements of a in C order.
 
-        1d_array : {array}
+    Examples
+    --------
+    >>> x = array([[1,2,3],[4,5,6]])
+    >>> x
+    array([[1, 2, 3],
+          [4, 5, 6]])
+    >>> ravel(x)
+    array([1, 2, 3, 4, 5, 6])
 
-    *See Also*:
-
-        `ndarray.flat` : 1d iterator over the array.
-
-        `ndarray.flatten` : 1d array copy of the elements of a in C order.
-
-    *Examples*
-
-        >>> x = array([[1,2,3],[4,5,6]])
-        >>> x
-        array([[1, 2, 3],
-              [4, 5, 6]])
-        >>> ravel(x)
-        array([1, 2, 3, 4, 5, 6])
-
     """
     return asarray(a).ravel(order)
 
@@ -723,23 +789,23 @@
 def nonzero(a):
     """Return the indices of the elements of a which are not zero.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
 
-        a : {array_like}
+    Returns
+    -------
+    tuple_of_arrays : {tuple}
 
-    *Returns*:
+    Examples
+    --------
+    >>> eye(3)[nonzero(eye(3))]
+    array([ 1.,  1.,  1.])
+    >>> nonzero(eye(3))
+    (array([0, 1, 2]), array([0, 1, 2]))
+    >>> eye(3)[nonzero(eye(3))]
+    array([ 1.,  1.,  1.])
 
-        tuple_of_arrays : {tuple}
-
-    *Examples*
-
-        >>> eye(3)[nonzero(eye(3))]
-        array([ 1.,  1.,  1.])
-        >>> nonzero(eye(3))
-        (array([0, 1, 2]), array([0, 1, 2]))
-        >>> eye(3)[nonzero(eye(3))]
-        array([ 1.,  1.,  1.])
-
     """
     try:
         nonzero = a.nonzero
@@ -753,25 +819,25 @@
 def shape(a):
     """Return the shape of a.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array whose shape is desired. If a is not an array, a conversion is
+        attempted.
 
-        a : {array_like}
-            Array whose shape is desired. If a is not an array, a conversion is
-            attempted.
+    Returns
+    -------
+    tuple_of_integers :
+        The elements of the tuple are the length of the corresponding array
+        dimension.
 
-    *Returns*:
+    Examples
+    --------
+    >>> shape(eye(3))
+    (3, 3)
+    >>> shape([[1,2]])
+    (1, 2)
 
-        tuple_of_integers :
-            The elements of the tuple are the length of the corresponding array
-            dimension.
-
-    *Examples*
-
-        >>> shape(eye(3))
-        (3, 3)
-        >>> shape([[1,2]])
-        (1, 2)
-
     """
     try:
         result = a.shape
@@ -810,46 +876,46 @@
 def sum(a, axis=None, dtype=None, out=None):
     """Sum the array over the given axis.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_type}
+        Array containing elements whose sum is desired. If a is not an array, a
+        conversion is attempted.
+    axis : {None, integer}
+        Axis over which the sum is taken. If None is used, then the sum is
+        over all the array elements.
+    dtype : {None, dtype}, optional
+        Determines the type of the returned array and of the accumulator
+        where the elements are summed. If dtype has the value None and the
+        type of a is an integer type of precision less than the default
+        platform integer, then the default platform integer precision is
+        used.  Otherwise, the dtype is the same as that of a.
+    out : {None, array}, optional
+        Array into which the sum can be placed. It's type is preserved and
+        it must be of the right shape to hold the output.
 
-        a : {array_type}
-            Array containing elements whose sum is desired. If a is not an array, a
-            conversion is attempted.
-        axis : {None, integer}
-            Axis over which the sum is taken. If None is used, then the sum is
-            over all the array elements.
-        dtype : {None, dtype}, optional
-            Determines the type of the returned array and of the accumulator
-            where the elements are summed. If dtype has the value None and the
-            type of a is an integer type of precision less than the default
-            platform integer, then the default platform integer precision is
-            used.  Otherwise, the dtype is the same as that of a.
-        out : {None, array}, optional
-            Array into which the sum can be placed. It's type is preserved and
-            it must be of the right shape to hold the output.
+    Returns
+    -------
+    sum_along_axis : {array, scalar}, see dtype parameter above.
+        Returns an array whose shape is the same as a with the specified
+        axis removed. Returns a 0d array when a is 1d or dtype=None.
+        Returns a reference to the specified output array if specified.
 
-    *Returns*:
+    See Also
+    --------
+    ndarray.sum : equivalent method
 
-        sum_along_axis : {array, scalar}, see dtype parameter above.
-            Returns an array whose shape is the same as a with the specified
-            axis removed. Returns a 0d array when a is 1d or dtype=None.
-            Returns a reference to the specified output array if specified.
+    Examples
+    --------
+    >>> sum([0.5, 1.5])
+    2.0
+    >>> sum([0.5, 1.5], dtype=N.int32)
+    1
+    >>> sum([[0, 1], [0, 5]])
+    6
+    >>> sum([[0, 1], [0, 5]], axis=1)
+    array([1, 5])
 
-    *See Also*:
-
-        `ndarray.sum` : equivalent method
-
-    *Examples*
-
-        >>> sum([0.5, 1.5])
-        2.0
-        >>> sum([0.5, 1.5], dtype=N.int32)
-        1
-        >>> sum([[0, 1], [0, 5]])
-        6
-        >>> sum([[0, 1], [0, 5]], axis=1)
-        array([1, 5])
-
     """
     if isinstance(a, _gentype):
         res = _sum_(a)
@@ -867,48 +933,48 @@
 def product (a, axis=None, dtype=None, out=None):
     """Product of the array elements over the given axis.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array containing elements whose product is desired. If a is not an array, a
+        conversion is attempted.
+    axis : {None, integer}
+        Axis over which the product is taken. If None is used, then the
+        product is over all the array elements.
+    dtype : {None, dtype}, optional
+        Determines the type of the returned array and of the accumulator
+        where the elements are multiplied. If dtype has the value None and
+        the type of a is an integer type of precision less than the default
+        platform integer, then the default platform integer precision is
+        used.  Otherwise, the dtype is the same as that of a.
+    out : {None, array}, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type will be cast if
+        necessary.
 
-        a : {array_like}
-            Array containing elements whose product is desired. If a is not an array, a
-            conversion is attempted.
-        axis : {None, integer}
-            Axis over which the product is taken. If None is used, then the
-            product is over all the array elements.
-        dtype : {None, dtype}, optional
-            Determines the type of the returned array and of the accumulator
-            where the elements are multiplied. If dtype has the value None and
-            the type of a is an integer type of precision less than the default
-            platform integer, then the default platform integer precision is
-            used.  Otherwise, the dtype is the same as that of a.
-        out : {None, array}, optional
-            Alternative output array in which to place the result. It must have
-            the same shape as the expected output but the type will be cast if
-            necessary.
+    Returns
+    -------
+    product_along_axis : {array, scalar}, see dtype parameter above.
+        Returns an array whose shape is the same as a with the specified
+        axis removed. Returns a 0d array when a is 1d or dtype=None.
+        Returns a reference to the specified output array if specified.
 
-    *Returns*:
+    See Also
+    --------
+    ndarray.prod : equivalent method
 
-        product_along_axis : {array, scalar}, see dtype parameter above.
-            Returns an array whose shape is the same as a with the specified
-            axis removed. Returns a 0d array when a is 1d or dtype=None.
-            Returns a reference to the specified output array if specified.
+    Examples
+    --------
+    >>> product([1.,2.])
+    2.0
+    >>> product([1.,2.], dtype=int32)
+    2
+    >>> product([[1.,2.],[3.,4.]])
+    24.0
+    >>> product([[1.,2.],[3.,4.]], axis=1)
+    array([  2.,  12.])
 
-    *See Also*:
 
-        `ndarray.prod` : equivalent method
-
-    *Examples*
-
-        >>> product([1.,2.])
-        2.0
-        >>> product([1.,2.], dtype=int32)
-        2
-        >>> product([[1.,2.],[3.,4.]])
-        24.0
-        >>> product([[1.,2.],[3.,4.]], axis=1)
-        array([  2.,  12.])
-
-
     """
     try:
         prod = a.prod
@@ -920,10 +986,10 @@
 def sometrue (a, axis=None, out=None):
     """Perform a logical_or over the given axis.
 
-    *See Also*:
+    See Also
+    --------
+    ndarray.any : equivalent method
 
-        `ndarray.any` : equivalent method
-
     """
     try:
         any = a.any
@@ -935,12 +1001,11 @@
 def alltrue (a, axis=None, out=None):
     """Perform a logical_and over the given axis.
 
-    *See Also*:
+    See Also
+    --------
+    ndarray.all : equivalent method
+    all : equivalent function
 
-        `ndarray.all` : equivalent method
-
-        `all` : equivalent function
-
     """
     try:
         all = a.all
@@ -952,10 +1017,10 @@
 def any(a,axis=None, out=None):
     """Return true if any elements of x are true.
 
-    *See Also*:
+    See Also
+    --------
+    ndarray.any : equivalent method
 
-        `ndarray.any` : equivalent method
-
     """
     try:
         any = a.any
@@ -967,12 +1032,11 @@
 def all(a,axis=None, out=None):
     """Return true if all elements of x are true:
 
-    *See Also*:
+    See Also
+    --------
+    ndarray.all : equivalent method
+    alltrue : equivalent function
 
-        `ndarray.all` : equivalent method
-
-        `alltrue` : equivalent function
-
     """
     try:
         all = a.all
@@ -982,8 +1046,36 @@
 
 
 def cumsum (a, axis=None, dtype=None, out=None):
-    """Sum the array over the given axis.
+    """Return the cumulative sum of the elements along the given axis.
 
+    The cumulative sum is calculated over the flattened array by
+    default, otherwise over the specified axis.
+
+    Parameters
+    ----------
+    a : array-like
+        Input array or object that can be converted to an array.
+    axis : {None, -1, int}, optional
+        Axis along which the product is computed. The default
+        (``axis``= None) is to compute over the flattened array.
+    dtype : type, optional
+        Type to use in computing the cumulative sum. For arrays of
+        integer type the default is int64 for signed ints and uint64
+        for unsigned. For arrays of float types it is the same as the
+        array type.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary.
+
+    Returns
+    -------
+    cumsum : ndarray.
+        A new array holding the result is returned unless ``out`` is
+        specified, in which case a reference to ``out`` is returned.
+        Return datatype is ``dtype`` if specified, otherwise int64 for
+        ints, uint64 for uints, or the input datatype otherwise.
+
     """
     try:
         cumsum = a.cumsum
@@ -992,9 +1084,13 @@
     return cumsum(axis, dtype, out)
 
 
-def cumproduct (a, axis=None, dtype=None, out=None):
+def cumproduct(a, axis=None, dtype=None, out=None):
     """Return the cumulative product over the given axis.
 
+    See Also
+    --------
+    cumprod
+
     """
     try:
         cumprod = a.cumprod
@@ -1004,8 +1100,38 @@
 
 
 def ptp(a, axis=None, out=None):
-    """Return maximum - minimum along the the given dimension.
+    """Return (maximum - minimum) along the the given dimension
+    (i.e. peak-to-peak value).
 
+    Parameters
+    ----------
+    a : array_like
+        Input values.
+    axis : {None, int}, optional
+        Axis along which to find the peaks.  If None (default) the
+        flattened array is used.
+    out : array_like
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary.
+
+    Returns
+    -------
+    ptp : ndarray.
+        A new array holding the result, unless ``out`` was
+        specified, in which case a reference to ``out`` is returned.
+
+    Examples
+    --------
+    >>> x = np.arange(4).reshape((2,2))
+    >>> x
+    array([[0, 1],
+           [2, 3]])
+    >>> np.ptp(x,0)
+    array([2, 2])
+    >>> np.ptp(x,1)
+    array([1, 1])
+
     """
     try:
         ptp = a.ptp
@@ -1015,8 +1141,35 @@
 
 
 def amax(a, axis=None, out=None):
-    """Return the maximum of 'a' along dimension axis.
+    """Return the maximum along a given axis.
 
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : {None, int}, optional
+        Axis along which to operate.  By default, ``axis`` is None and the
+        flattened input is used.
+    out : array_like, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+
+    Results
+    -------
+    amax : array_like
+        New array holding the result, unless ``out`` was specified.
+
+    Examples
+    --------
+    >>> x = np.arange(4).reshape((2,2))
+    >>> x
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amax(x,0)
+    array([2, 3])
+    >>> np.amax(x,1)
+    array([1, 3])
+
     """
     try:
         amax = a.max
@@ -1026,8 +1179,35 @@
 
 
 def amin(a, axis=None, out=None):
-    """Return the minimum of a along dimension axis.
+    """Return the minimum along a given axis.
 
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : {None, int}, optional
+        Axis along which to operate.  By default, ``axis`` is None and the
+        flattened input is used.
+    out : array_like, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+
+    Results
+    -------
+    amin : array_like
+        New array holding the result, unless ``out`` was specified.
+
+    Examples
+    --------
+    >>> x = np.arange(4).reshape((2,2))
+    >>> x
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amin(x,0)
+    array([0, 1])
+    >>> np.amin(x,1)
+    array([0, 2])
+
     """
     try:
         amin = a.min
@@ -1040,6 +1220,23 @@
     """Return the length of a Python object interpreted as an array
     of at least 1 dimension.
 
+    Parameters
+    ----------
+    a : array_like
+
+    Returns
+    -------
+    alen : int
+       Length of the first dimension of a.
+
+    Examples
+    --------
+    >>> z = np.zeros((7,4,5))
+    >>> z.shape[0]
+    7
+    >>> np.alen(z)
+    7
+
     """
     try:
         return len(a)
@@ -1050,6 +1247,44 @@
 def prod(a, axis=None, dtype=None, out=None):
     """Return the product of the elements along the given axis.
 
+    Parameters
+    ----------
+    a : array-like
+        Input array.
+    axis : {None, int}, optional
+        Axis along which the product is computed. By default, ``axis``
+        is None and the flattened input is used.
+    dtype : type, optional
+        Type to use in computing the product. For arrays of
+        integer type the default is int64 for signed ints and uint64
+        for unsigned. For arrays of float types it is the same as the
+        array type.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary.
+
+    Returns
+    -------
+    prod : ndarray.
+        A new array holding the result is returned unless out is
+        specified, in which case a reference to out is returned.
+        Return datatype is ``dtype`` if specified, otherwise int64 for
+        ints, uint64 for uints, or the input datatype otherwise.
+
+    Examples
+    --------
+    >>> x = np.arange(4).reshape((2,2)) + 1
+    >>> x
+    array([[1, 2],
+           [3, 4]])
+    >>> np.prod(x)
+    24
+    >>> np.prod(x,0)
+    array([3, 8])
+    >>> np.prod(x,1)
+    array([ 2, 12])
+
     """
     try:
         prod = a.prod
@@ -1067,7 +1302,7 @@
     Parameters
     ----------
     a : array-like
-        Input array or object that can be converted to an array
+        Input array or object that can be converted to an array.
     axis : {None, -1, int}, optional
         Axis along which the product is computed. The default
         (``axis``= None) is to compute over the flattened array.
@@ -1075,7 +1310,7 @@
         Type to use in computing the cumulative product. For arrays of
         integer type the default is int64 for signed ints and uint64
         for unsigned. For arrays of float types it is the same as the
-        array type. 
+        array type.
     out : ndarray, optional
         Alternative output array in which to place the result. It must
         have the same shape and buffer length as the expected output
@@ -1088,6 +1323,7 @@
         specified, in which case a reference to out is returned.
         Return datatype is ``dtype`` if specified, otherwise int64 for
         ints, uint64 for uints, or the input datatype otherwise.
+
     """
     try:
         cumprod = a.cumprod
@@ -1102,36 +1338,33 @@
     If a is not already an array, a conversion is attempted. Scalars are zero
     dimensional.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array whose number of dimensions are desired. If a is not an
+        array, a conversion is attempted.
 
-        a : {array_like}
-            Array whose number of dimensions are desired. If a is not an array, a
-            conversion is attempted.
+    Returns
+    -------
+    number_of_dimensions : {integer}
+        Returns the number of dimensions.
 
-    *Returns*:
+    See Also
+    --------
+    rank : equivalent function.
+    ndarray.ndim : equivalent method
+    shape : dimensions of array
+    ndarray.shape : dimensions of array
 
-        number_of_dimensions : {integer}
-            Returns the number of dimensions.
+    Examples
+    --------
+    >>> ndim([[1,2,3],[4,5,6]])
+    2
+    >>> ndim(array([[1,2,3],[4,5,6]]))
+    2
+    >>> ndim(1)
+    0
 
-    *See Also*:
-
-        `rank` : equivalent function.
-
-        `ndarray.ndim` : equivalent method
-
-        `shape` : dimensions of array
-
-        `ndarray.shape` : dimensions of array
-
-    *Examples*
-
-        >>> ndim([[1,2,3],[4,5,6]])
-        2
-        >>> ndim(array([[1,2,3],[4,5,6]]))
-        2
-        >>> ndim(1)
-        0
-
     """
     try:
         return a.ndim
@@ -1146,36 +1379,33 @@
     not already an array, a conversion is attempted. Scalars are zero
     dimensional.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array whose number of dimensions is desired. If a is not an array, a
+        conversion is attempted.
 
-        a : {array_like}
-            Array whose number of dimensions is desired. If a is not an array, a
-            conversion is attempted.
+    Returns
+    -------
+    number_of_dimensions : {integer}
+        Returns the number of dimensions.
 
-    *Returns*:
+    See Also
+    --------
+    ndim : equivalent function
+    ndarray.ndim : equivalent method
+    shape : dimensions of array
+    ndarray.shape : dimensions of array
 
-        number_of_dimensions : {integer}
-            Returns the number of dimensions.
+    Examples
+    --------
+    >>> rank([[1,2,3],[4,5,6]])
+    2
+    >>> rank(array([[1,2,3],[4,5,6]]))
+    2
+    >>> rank(1)
+    0
 
-    *See Also*:
-
-        `ndim` : equivalent function
-
-        `ndarray.ndim` : equivalent method
-
-        `shape` : dimensions of array
-
-        `ndarray.shape` : dimensions of array
-
-    *Examples*
-
-        >>> rank([[1,2,3],[4,5,6]])
-        2
-        >>> rank(array([[1,2,3],[4,5,6]]))
-        2
-        >>> rank(1)
-        0
-
     """
     try:
         return a.ndim
@@ -1186,38 +1416,36 @@
 def size(a, axis=None):
     """Return the number of elements along given axis.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array whose axis size is desired. If a is not an array, a
+        conversion is attempted.
+    axis : {None, integer}, optional
+        Axis along which the elements are counted. None means all
+        elements in the array.
 
-        a : {array_like}
-            Array whose axis size is desired. If a is not an array, a conversion
-            is attempted.
-        axis : {None, integer}, optional
-            Axis along which the elements are counted. None means all elements
-            in the array.
+    Returns
+    -------
+    element_count : {integer}
+        Count of elements along specified axis.
 
-    *Returns*:
+    See Also
+    --------
+    shape : dimensions of array
+    ndarray.shape : dimensions of array
+    ndarray.size : number of elements in array
 
-        element_count : {integer}
-            Count of elements along specified axis.
+    Examples
+    --------
+    >>> a = array([[1,2,3],[4,5,6]])
+    >>> size(a)
+    6
+    >>> size(a,1)
+    3
+    >>> size(a,0)
+    2
 
-    *See Also*:
-
-        `shape` : dimensions of array
-
-        `ndarray.shape` : dimensions of array
-
-        `ndarray.size` : number of elements in array
-
-    *Examples*
-
-        >>> a = array([[1,2,3],[4,5,6]])
-        >>> size(a)
-        6
-        >>> size(a,1)
-        3
-        >>> size(a,0)
-        2
-
     """
     if axis is None:
         try:
@@ -1239,48 +1467,47 @@
     are desired.  Nothing is done if the input is an integer array and the
     decimals parameter has a value >= 0.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array containing numbers whose rounded values are desired. If a is
+        not an array, a conversion is attempted.
+    decimals : {0, int}, optional
+        Number of decimal places to round to. When decimals is negative it
+        specifies the number of positions to the left of the decimal point.
+    out : {None, array}, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type will be cast if
+        necessary. Numpy rounds floats to floats by default.
 
-        a : {array_like}
-            Array containing numbers whose rounded values are desired. If a is
-            not an array, a conversion is attempted.
-        decimals : {0, int}, optional
-            Number of decimal places to round to. When decimals is negative it
-            specifies the number of positions to the left of the decimal point.
-        out : {None, array}, optional
-            Alternative output array in which to place the result. It must have
-            the same shape as the expected output but the type will be cast if
-            necessary. Numpy rounds floats to floats by default.
+    Returns
+    -------
+    rounded_array : {array}
+        If out=None, returns a new array of the same type as a containing
+        the rounded values, otherwise a reference to the output array is
+        returned.
 
-        *Returns*:
+    See Also
+    --------
+    round_ : equivalent function
+    ndarray.round : equivalent method
 
-        rounded_array : {array}
-            If out=None, returns a new array of the same type as a containing
-            the rounded values, otherwise a reference to the output array is
-            returned.
+    Notes
+    -----
+    Numpy rounds to even. Thus 1.5 and 2.5 round to 2.0, -0.5 and 0.5 round
+    to 0.0, etc. Results may also be surprising due to the inexact
+    representation of decimal fractions in IEEE floating point and the
+    errors introduced when scaling by powers of ten.
 
-    *See Also*:
+    Examples
+    --------
+    >>> around([.5, 1.5, 2.5, 3.5, 4.5])
+    array([ 0.,  2.,  2.,  4.,  4.])
+    >>> around([1,2,3,11], decimals=1)
+    array([ 1,  2,  3, 11])
+    >>> around([1,2,3,11], decimals=-1)
+    array([ 0,  0,  0, 10])
 
-        `round_` : equivalent function
-
-        `ndarray.round` : equivalent method
-
-    *Notes*
-
-        Numpy rounds to even. Thus 1.5 and 2.5 round to 2.0, -0.5 and 0.5 round
-        to 0.0, etc. Results may also be surprising due to the inexact
-        representation of decimal fractions in IEEE floating point and the
-        errors introduced when scaling by powers of ten.
-
-    *Examples*
-
-        >>> around([.5, 1.5, 2.5, 3.5, 4.5])
-        array([ 0.,  2.,  2.,  4.,  4.])
-        >>> around([1,2,3,11], decimals=1)
-        array([ 1,  2,  3, 11])
-        >>> around([1,2,3,11], decimals=-1)
-        array([ 0,  0,  0, 10])
-
     """
     try:
         round = a.round
@@ -1297,48 +1524,47 @@
     are desired.  Nothing is done if the input is an integer array and the
     decimals parameter has a value >= 0.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array containing numbers whose rounded values are desired. If a is
+        not an array, a conversion is attempted.
+    decimals : {0, integer}, optional
+        Number of decimal places to round to. When decimals is negative it
+        specifies the number of positions to the left of the decimal point.
+    out : {None, array}, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type will be cast if
+        necessary.
 
-        a : {array_like}
-            Array containing numbers whose rounded values are desired. If a is
-            not an array, a conversion is attempted.
-        decimals : {0, integer}, optional
-            Number of decimal places to round to. When decimals is negative it
-            specifies the number of positions to the left of the decimal point.
-        out : {None, array}, optional
-            Alternative output array in which to place the result. It must have
-            the same shape as the expected output but the type will be cast if
-            necessary.
+    Returns
+    -------
+    rounded_array : {array}
+        If out=None, returns a new array of the same type as a containing
+        the rounded values, otherwise a reference to the output array is
+        returned.
 
-    *Returns*:
+    See Also
+    --------
+    around : equivalent function
+    ndarray.round : equivalent method
 
-        rounded_array : {array}
-            If out=None, returns a new array of the same type as a containing
-            the rounded values, otherwise a reference to the output array is
-            returned.
+    Notes
+    -----
+    Numpy rounds to even. Thus 1.5 and 2.5 round to 2.0, -0.5 and 0.5 round
+    to 0.0, etc. Results may also be surprising due to the inexact
+    representation of decimal fractions in IEEE floating point and the
+    errors introduced when scaling by powers of ten.
 
-    *See Also*:
+    Examples
+    --------
+    >>> round_([.5, 1.5, 2.5, 3.5, 4.5])
+    array([ 0.,  2.,  2.,  4.,  4.])
+    >>> round_([1,2,3,11], decimals=1)
+    array([ 1,  2,  3, 11])
+    >>> round_([1,2,3,11], decimals=-1)
+    array([ 0,  0,  0, 10])
 
-        `around` : equivalent function
-
-        `ndarray.round` : equivalent method
-
-    *Notes*
-
-        Numpy rounds to even. Thus 1.5 and 2.5 round to 2.0, -0.5 and 0.5 round
-        to 0.0, etc. Results may also be surprising due to the inexact
-        representation of decimal fractions in IEEE floating point and the
-        errors introduced when scaling by powers of ten.
-
-    *Examples*
-
-        >>> round_([.5, 1.5, 2.5, 3.5, 4.5])
-        array([ 0.,  2.,  2.,  4.,  4.])
-        >>> round_([1,2,3,11], decimals=1)
-        array([ 1,  2,  3, 11])
-        >>> round_([1,2,3,11], decimals=-1)
-        array([ 0,  0,  0, 10])
-
     """
     try:
         round = a.round
@@ -1354,50 +1580,49 @@
     over the flattened array by default, otherwise over the specified
     axis. The dtype returned for integer type arrays is float
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array containing numbers whose mean is desired. If a is not an
+        array, a conversion is attempted.
+    axis : {None, integer}, optional
+        Axis along which the means are computed. The default is to compute
+        the standard deviation of the flattened array.
+    dtype : {None, dtype}, optional
+        Type to use in computing the means. For arrays of integer type the
+        default is float32, for arrays of float types it is the same as the
+        array type.
+    out : {None, array}, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type will be cast if
+        necessary.
 
-        a : {array_like}
-            Array containing numbers whose mean is desired. If a is not an
-            array, a conversion is attempted.
-        axis : {None, integer}, optional
-            Axis along which the means are computed. The default is to compute
-            the standard deviation of the flattened array.
-        dtype : {None, dtype}, optional
-            Type to use in computing the means. For arrays of integer type the
-            default is float32, for arrays of float types it is the same as the
-            array type.
-        out : {None, array}, optional
-            Alternative output array in which to place the result. It must have
-            the same shape as the expected output but the type will be cast if
-            necessary.
+    Returns
+    -------
+    mean : {array, scalar}, see dtype parameter above
+        If out=None, returns a new array containing the mean values,
+        otherwise a reference to the output array is returned.
 
-    *Returns*:
+    See Also
+    --------
+    var : Variance
+    std : Standard deviation
 
-        mean : {array, scalar}, see dtype parameter above
-            If out=None, returns a new array containing the mean values,
-            otherwise a reference to the output array is returned.
+    Notes
+    -----
+    The mean is the sum of the elements along the axis divided by the
+    number of elements.
 
-    *See Also*:
+    Examples
+    --------
+    >>> a = array([[1,2],[3,4]])
+    >>> mean(a)
+    2.5
+    >>> mean(a,0)
+    array([ 2.,  3.])
+    >>> mean(a,1)
+    array([ 1.5,  3.5])
 
-        `var` : Variance
-
-        `std` : Standard deviation
-
-    *Notes*
-
-        The mean is the sum of the elements along the axis divided by the number
-        of elements.
-
-    *Examples*
-
-        >>> a = array([[1,2],[3,4]])
-        >>> mean(a)
-        2.5
-        >>> mean(a,0)
-        array([ 2.,  3.])
-        >>> mean(a,1)
-        array([ 1.5,  3.5])
-
     """
     try:
         mean = a.mean
@@ -1413,52 +1638,51 @@
     spread of a distribution. The standard deviation is computed for the
     flattened array by default, otherwise over the specified axis.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array containing numbers whose standard deviation is desired. If a
+        is not an array, a conversion is attempted.
+    axis : {None, integer}, optional
+        Axis along which the standard deviation is computed. The default is
+        to compute the standard deviation of the flattened array.
+    dtype : {None, dtype}, optional
+        Type to use in computing the standard deviation. For arrays of
+        integer type the default is float32, for arrays of float types it is
+        the same as the array type.
+    out : {None, array}, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type will be cast if
+        necessary.
 
-        a : {array_like}
-            Array containing numbers whose standard deviation is desired. If a
-            is not an array, a conversion is attempted.
-        axis : {None, integer}, optional
-            Axis along which the standard deviation is computed. The default is
-            to compute the standard deviation of the flattened array.
-        dtype : {None, dtype}, optional
-            Type to use in computing the standard deviation. For arrays of
-            integer type the default is float32, for arrays of float types it is
-            the same as the array type.
-        out : {None, array}, optional
-            Alternative output array in which to place the result. It must have
-            the same shape as the expected output but the type will be cast if
-            necessary.
+    Returns
+    -------
+    standard_deviation : {array, scalar}, see dtype parameter above.
+        If out=None, returns a new array containing the standard deviation,
+        otherwise a reference to the output array is returned.
 
-    *Returns*:
+    See Also
+    --------
+    var : Variance
+    mean : Average
 
-        standard_deviation : {array, scalar}, see dtype parameter above.
-            If out=None, returns a new array containing the standard deviation,
-            otherwise a reference to the output array is returned.
+    Notes
+    -----
+    The standard deviation is the square root of the average of the squared
+    deviations from the mean, i.e. var = sqrt(mean((x - x.mean())**2)).  The
+    computed standard deviation is biased, i.e., the mean is computed by
+    dividing by the number of elements, N, rather than by N-1.
 
-    *See Also*:
+    Examples
+    --------
+    >>> a = array([[1,2],[3,4]])
+    >>> std(a)
+    1.1180339887498949
+    >>> std(a,0)
+    array([ 1.,  1.])
+    >>> std(a,1)
+    array([ 0.5,  0.5])
 
-        `var` : Variance
-
-        `mean` : Average
-
-    *Notes*
-
-        The standard deviation is the square root of the average of the squared
-        deviations from the mean, i.e. var = sqrt(mean((x - x.mean())**2)).  The
-        computed standard deviation is biased, i.e., the mean is computed by
-        dividing by the number of elements, N, rather than by N-1.
-
-    *Examples*
-
-        >>> a = array([[1,2],[3,4]])
-        >>> std(a)
-        1.1180339887498949
-        >>> std(a,0)
-        array([ 1.,  1.])
-        >>> std(a,1)
-        array([ 0.5,  0.5])
-
     """
     try:
         std = a.std
@@ -1474,52 +1698,51 @@
     distribution. The variance is computed for the flattened array by default,
     otherwise over the specified axis.
 
-    *Parameters*:
+    Parameters
+    ----------
+    a : {array_like}
+        Array containing numbers whose variance is desired. If a is not an
+        array, a conversion is attempted.
+    axis : {None, integer}, optional
+        Axis along which the variance is computed. The default is to compute
+        the variance of the flattened array.
+    dtype : {None, dtype}, optional
+        Type to use in computing the variance. For arrays of integer type
+        the default is float32, for arrays of float types it is the same as
+        the array type.
+    out : {None, array}, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type will be cast if
+        necessary.
 
-        a : {array_like}
-            Array containing numbers whose variance is desired. If a is not an
-            array, a conversion is attempted.
-        axis : {None, integer}, optional
-            Axis along which the variance is computed. The default is to compute
-            the variance of the flattened array.
-        dtype : {None, dtype}, optional
-            Type to use in computing the variance. For arrays of integer type
-            the default is float32, for arrays of float types it is the same as
-            the array type.
-        out : {None, array}, optional
-            Alternative output array in which to place the result. It must have
-            the same shape as the expected output but the type will be cast if
-            necessary.
+    Returns
+    -------
+    variance : {array, scalar}, see dtype parameter above
+        If out=None, returns a new array containing the variance, otherwise
+        a reference to the output array is returned.
 
-    *Returns*:
+    See Also
+    --------
+    std : Standard deviation
+    mean : Average
 
-        variance : {array, scalar}, see dtype parameter above
-            If out=None, returns a new array containing the variance, otherwise
-            a reference to the output array is returned.
+    Notes
+    -----
+    The variance is the average of the squared deviations from the mean,
+    i.e.  var = mean((x - x.mean())**2).  The computed variance is biased,
+    i.e., the mean is computed by dividing by the number of elements, N,
+    rather than by N-1.
 
-    *See Also*:
+    Examples
+    --------
+    >>> a = array([[1,2],[3,4]])
+    >>> var(a)
+    1.25
+    >>> var(a,0)
+    array([ 1.,  1.])
+    >>> var(a,1)
+    array([ 0.25,  0.25])
 
-        `std` : Standard deviation
-
-        `mean` : Average
-
-    *Notes*
-
-        The variance is the average of the squared deviations from the mean,
-        i.e.  var = mean((x - x.mean())**2).  The computed variance is biased,
-        i.e., the mean is computed by dividing by the number of elements, N,
-        rather than by N-1.
-
-    *Examples*
-
-        >>> a = array([[1,2],[3,4]])
-        >>> var(a)
-        1.25
-        >>> var(a,0)
-        array([ 1.,  1.])
-        >>> var(a,1)
-        array([ 0.25,  0.25])
-
     """
     try:
         var = a.var



From numpy-svn at scipy.org  Wed Feb 20 17:04:54 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 20 Feb 2008 16:04:54 -0600 (CST)
Subject: [Numpy-svn] r4815 - trunk/numpy/lib
Message-ID: <20080220220454.F1D0C39C032@new.scipy.org>

Author: rkern
Date: 2008-02-20 16:04:52 -0600 (Wed, 20 Feb 2008)
New Revision: 4815

Modified:
   trunk/numpy/lib/function_base.py
Log:
Use x.any() instead of any(x)

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-20 09:07:45 UTC (rev 4814)
+++ trunk/numpy/lib/function_base.py	2008-02-20 22:04:52 UTC (rev 4815)
@@ -15,7 +15,7 @@
 import types
 import numpy.core.numeric as _nx
 from numpy.core.numeric import ones, zeros, arange, concatenate, array, \
-     asarray, asanyarray, empty, empty_like, asanyarray, ndarray, around
+     asarray, asanyarray, empty, empty_like, ndarray, around
 from numpy.core.numeric import ScalarType, dot, where, newaxis, intp, \
      integer, isscalar
 from numpy.core.umath import pi, multiply, add, arctan2,  \
@@ -152,7 +152,7 @@
         bins = linspace(mn, mx, bins, endpoint=False)
     else:
         bins = asarray(bins)
-        if(any(bins[1:]-bins[:-1] < 0)):
+        if (bins[1:]-bins[:-1] < 0).any():
             raise AttributeError, 'bins must increase monotonically.'
 
     # best block size probably depends on processor cache size



From numpy-svn at scipy.org  Thu Feb 21 18:37:46 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 21 Feb 2008 17:37:46 -0600 (CST)
Subject: [Numpy-svn] r4816 - in trunk/numpy/core: . tests
Message-ID: <20080221233746.0D99439C3D6@new.scipy.org>

Author: chris.burns
Date: 2008-02-21 17:37:43 -0600 (Thu, 21 Feb 2008)
New Revision: 4816

Added:
   trunk/numpy/core/tests/test_memmap.py
Modified:
   trunk/numpy/core/memmap.py
Log:
Remove type-checking which failed with MaskedArrays.  Add documentation and tests.

Modified: trunk/numpy/core/memmap.py
===================================================================
--- trunk/numpy/core/memmap.py	2008-02-20 22:04:52 UTC (rev 4815)
+++ trunk/numpy/core/memmap.py	2008-02-21 23:37:43 UTC (rev 4816)
@@ -15,6 +15,127 @@
     }
 
 class memmap(ndarray):
+    """Create a memory-map to an array stored in a file on disk.
+
+    Memory-mapped files are used for accessing small segments of large files
+    on disk, without reading the entire file into memory.  Numpy's memmaps are
+    array-like objects.  This differs from python's mmap module which are 
+    file-like objects.
+
+    Parameters
+    ----------
+    name : filename
+        The file name to be used as the array data buffer.
+    dtype : data-type, optional
+        The data-type used to interpret the file contents.
+        Default is uint8
+    mode : {'r', 'r+', 'w+', 'c'}, optional
+        The mode to open the file.
+        'r',  open existing file for read-only
+        'r+', open existing file for read-write
+        'w+', create or overwrite existing file and open for read-write
+        'c',  copy-on-write, assignments effect data in memory, but changes
+              are not saved to disk.  File on disk is read-only.
+        Default is 'r+'
+    offset : integer, optional
+        Byte offset into the file to start the array data. Should be a
+        multiple of the data-type of the data.  Requires shape=None.
+        Default is 0
+    shape : tuple, optional
+        The desired shape of the array. If None, the returned array will be 1-D
+        with the number of elements determined by file size and data-type.
+        Default is None
+    order : {'C', 'F'}, optional
+        Specify the order of the N-D array, C or Fortran ordered. This only
+        has an effect if the shape is greater than 2-D.
+        Default is 'C'
+
+    Methods
+    -------
+    close : close the memmap file
+    sync : flush any changes in memory to file on disk
+        When you delete a memmap object, sync is called first to write
+        changes to disk before removing the object.
+
+    Returns
+    -------
+    memmap : array-like memmap object
+        The memmap object can be used anywhere an ndarray is accepted.
+        If fp is a memmap, isinstance(fp, numpy.ndarray) will return True.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> data = np.arange(12, dtype='float32')
+    >>> data.resize((3,4))
+
+    >>> # Using a tempfile so doctest doesn't write files to your directory.
+    >>> # You would use a 'normal' filename.
+    >>> from tempfile import mkdtemp
+    >>> import os.path as path
+    >>> filename = path.join(mkdtemp(), 'newfile.dat')
+
+    >>> # Create a memmap with dtype and shape that matches our data
+    >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))
+    >>> fp
+    memmap([[ 0.,  0.,  0.,  0.],
+           [ 0.,  0.,  0.,  0.],
+           [ 0.,  0.,  0.,  0.]], dtype=float32)
+
+    >>> # Write data to memmap array
+    >>> fp[:] = data[:]
+    >>> fp
+    memmap([[  0.,   1.,   2.,   3.],
+           [  4.,   5.,   6.,   7.],
+           [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    >>> # Deletion flushes memory changes to disk before removing the object.
+    >>> del fp
+    >>> # Load the memmap and verify data was stored
+    >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
+    >>> newfp
+    memmap([[  0.,   1.,   2.,   3.],
+           [  4.,   5.,   6.,   7.],
+           [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    >>> # read-only memmap
+    >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
+    >>> fpr.flags.writeable
+    False
+    >>> # Cannot assign to read-only, obviously
+    >>> fpr[0, 3] = 56
+    Traceback (most recent call last):
+        ...
+    RuntimeError: array is not writeable
+
+    >>> # copy-on-write memmap
+    >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
+    >>> fpc.flags.writeable
+    True
+    >>> # Can assign to copy-on-write array, but values are only written
+    >>> # into the memory copy of the array, and not written to disk.
+    >>> fpc
+    memmap([[  0.,   1.,   2.,   3.],
+           [  4.,   5.,   6.,   7.],
+           [  8.,   9.,  10.,  11.]], dtype=float32)
+    >>> fpc[0,:] = 0
+    >>> fpc
+    memmap([[  0.,   0.,   0.,   0.],
+           [  4.,   5.,   6.,   7.],
+           [  8.,   9.,  10.,  11.]], dtype=float32)
+    >>> # file on disk is unchanged
+    >>> fpr
+    memmap([[  0.,   1.,   2.,   3.],
+           [  4.,   5.,   6.,   7.],
+           [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    >>> # offset into a memmap
+    >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
+    >>> fpo
+    memmap([  4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.], dtype=float32)
+
+    """
+
     __array_priority__ = -100.0
     def __new__(subtype, name, dtype=uint8, mode='r+', offset=0,
                 shape=None, order='C'):
@@ -78,17 +199,20 @@
 
     def __array_finalize__(self, obj):
         if obj is not None:
-            if not isinstance(obj, memmap):
-                raise ValueError, "Cannot create a memmap array that way"
-            self._mmap = obj._mmap
+            if hasattr(obj, '_mmap'):
+                self._mmap = obj._mmap
+            else:
+                raise ValueError, 'Cannot create a memmap from object %s'%obj
         else:
             self._mmap = None
 
     def sync(self):
+        """Flush any changes in the array to the file on disk."""
         if self._mmap is not None:
             self._mmap.flush()
 
     def close(self):
+        """Close the memmap file."""
         if (self.base is self._mmap):
             self._mmap.close()
         elif self._mmap is not None:

Added: trunk/numpy/core/tests/test_memmap.py
===================================================================
--- trunk/numpy/core/tests/test_memmap.py	2008-02-20 22:04:52 UTC (rev 4815)
+++ trunk/numpy/core/tests/test_memmap.py	2008-02-21 23:37:43 UTC (rev 4816)
@@ -0,0 +1,27 @@
+
+from tempfile import NamedTemporaryFile
+
+from numpy.core import memmap
+from numpy import arange, allclose
+from numpy.testing import *
+
+class TestMemmap(NumpyTestCase):
+    def setUp(self):
+        self.tmpfp = NamedTemporaryFile(prefix='mmap')
+        self.shape = (3,4)
+        self.dtype = 'float32'
+        self.data = arange(12, dtype=self.dtype)
+        self.data.resize(self.shape)
+
+    def test_RoundTrip(self):
+        fp = memmap(self.tmpfp.name, dtype=self.dtype, mode='w+', 
+                    shape=self.shape)
+        fp[:] = self.data[:]
+        del fp
+        newfp = memmap(self.tmpfp.name, dtype=self.dtype, mode='r', 
+                       shape=self.shape)
+        assert allclose(self.data, newfp)
+        assert_array_equal(self.data, newfp)
+
+if __name__ == '__main__':
+    NumpyTest().run()



From numpy-svn at scipy.org  Fri Feb 22 03:58:44 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 22 Feb 2008 02:58:44 -0600 (CST)
Subject: [Numpy-svn] r4817 - in trunk/numpy/core: . tests
Message-ID: <20080222085844.B23A039C43D@new.scipy.org>

Author: stefan
Date: 2008-02-22 02:58:25 -0600 (Fri, 22 Feb 2008)
New Revision: 4817

Modified:
   trunk/numpy/core/memmap.py
   trunk/numpy/core/tests/test_memmap.py
Log:
Deprecate 'sync' in favour of 'flush'.


Modified: trunk/numpy/core/memmap.py
===================================================================
--- trunk/numpy/core/memmap.py	2008-02-21 23:37:43 UTC (rev 4816)
+++ trunk/numpy/core/memmap.py	2008-02-22 08:58:25 UTC (rev 4817)
@@ -1,6 +1,7 @@
 __all__ = ['memmap']
 
 import mmap
+import warnings
 from numeric import uint8, ndarray, dtype
 
 dtypedescr = dtype
@@ -206,11 +207,16 @@
         else:
             self._mmap = None
 
-    def sync(self):
+    def flush(self):
         """Flush any changes in the array to the file on disk."""
         if self._mmap is not None:
             self._mmap.flush()
 
+    def sync(self):
+        """Flush any changes in the array to the file on disk."""
+        warnings.warn("Use ``flush``.", DeprecationWarning)
+        self.flush()
+
     def close(self):
         """Close the memmap file."""
         if (self.base is self._mmap):
@@ -220,7 +226,7 @@
                   "by another object."
 
     def __del__(self):
-        self.sync()
+        self.flush()
         try:
             self.close()
         except ValueError:

Modified: trunk/numpy/core/tests/test_memmap.py
===================================================================
--- trunk/numpy/core/tests/test_memmap.py	2008-02-21 23:37:43 UTC (rev 4816)
+++ trunk/numpy/core/tests/test_memmap.py	2008-02-22 08:58:25 UTC (rev 4817)
@@ -1,10 +1,11 @@
-
 from tempfile import NamedTemporaryFile
 
 from numpy.core import memmap
 from numpy import arange, allclose
 from numpy.testing import *
 
+import warnings
+
 class TestMemmap(NumpyTestCase):
     def setUp(self):
         self.tmpfp = NamedTemporaryFile(prefix='mmap')
@@ -14,14 +15,24 @@
         self.data.resize(self.shape)
 
     def test_RoundTrip(self):
-        fp = memmap(self.tmpfp.name, dtype=self.dtype, mode='w+', 
+        fp = memmap(self.tmpfp.name, dtype=self.dtype, mode='w+',
                     shape=self.shape)
         fp[:] = self.data[:]
         del fp
-        newfp = memmap(self.tmpfp.name, dtype=self.dtype, mode='r', 
+        newfp = memmap(self.tmpfp.name, dtype=self.dtype, mode='r',
                        shape=self.shape)
         assert allclose(self.data, newfp)
         assert_array_equal(self.data, newfp)
 
+    def test_flush(self):
+        fp = memmap(self.tmpfp.name, dtype=self.dtype, mode='w+',
+                    shape=self.shape)
+        fp[:] = self.data[:]
+        fp.flush()
+
+        warnings.simplefilter('ignore', DeprecationWarning)
+        fp.sync()
+        warnings.simplefilter('default', DeprecationWarning)
+
 if __name__ == '__main__':
     NumpyTest().run()



From numpy-svn at scipy.org  Fri Feb 22 17:42:25 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 22 Feb 2008 16:42:25 -0600 (CST)
Subject: [Numpy-svn] r4818 - trunk/numpy/core
Message-ID: <20080222224225.0A83639C071@new.scipy.org>

Author: chris.burns
Date: 2008-02-22 16:42:06 -0600 (Fri, 22 Feb 2008)
New Revision: 4818

Modified:
   trunk/numpy/core/memmap.py
Log:
Small sync-to-flush doc update.

Modified: trunk/numpy/core/memmap.py
===================================================================
--- trunk/numpy/core/memmap.py	2008-02-22 08:58:25 UTC (rev 4817)
+++ trunk/numpy/core/memmap.py	2008-02-22 22:42:06 UTC (rev 4818)
@@ -54,8 +54,8 @@
     Methods
     -------
     close : close the memmap file
-    sync : flush any changes in memory to file on disk
-        When you delete a memmap object, sync is called first to write
+    flush : flush any changes in memory to file on disk
+        When you delete a memmap object, flush is called first to write
         changes to disk before removing the object.
 
     Returns



From numpy-svn at scipy.org  Fri Feb 22 20:14:41 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 22 Feb 2008 19:14:41 -0600 (CST)
Subject: [Numpy-svn] r4819 - trunk/numpy/lib
Message-ID: <20080223011441.24A1D39C413@new.scipy.org>

Author: oliphant
Date: 2008-02-22 19:14:40 -0600 (Fri, 22 Feb 2008)
New Revision: 4819

Modified:
   trunk/numpy/lib/function_base.py
Log:
Fix bug reported by Debian package maintainer.

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-22 22:42:06 UTC (rev 4818)
+++ trunk/numpy/lib/function_base.py	2008-02-23 01:14:40 UTC (rev 4819)
@@ -375,7 +375,7 @@
                 n = add.reduce(a*w, axis)
                 d = add.reduce(w, axis)
             elif wsh == (ash[axis],):
-                ni = ash[axis]
+                ni = len(ash)
                 r = [newaxis]*ni
                 r[axis] = slice(None, None, 1)
                 w1 = eval("w["+repr(tuple(r))+"]*ones(ash, float)")



From numpy-svn at scipy.org  Sat Feb 23 01:37:47 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sat, 23 Feb 2008 00:37:47 -0600 (CST)
Subject: [Numpy-svn] r4820 - trunk/numpy/lib
Message-ID: <20080223063747.0C6D539C07C@new.scipy.org>

Author: oliphant
Date: 2008-02-23 00:37:45 -0600 (Sat, 23 Feb 2008)
New Revision: 4820

Modified:
   trunk/numpy/lib/function_base.py
Log:
Add Anne Archibald's fix to average to remove eval.

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-23 01:14:40 UTC (rev 4819)
+++ trunk/numpy/lib/function_base.py	2008-02-23 06:37:45 UTC (rev 4820)
@@ -378,9 +378,9 @@
                 ni = len(ash)
                 r = [newaxis]*ni
                 r[axis] = slice(None, None, 1)
-                w1 = eval("w["+repr(tuple(r))+"]*ones(ash, float)")
-                n = add.reduce(a*w1, axis)
-                d = add.reduce(w1, axis)
+                r = tuple(r)
+                n = add.reduce(a*w[r], axis)
+                d = add.reduce(w, axis)
             else:
                 raise ValueError, 'averaging weights have wrong shape'
 



From numpy-svn at scipy.org  Sun Feb 24 13:01:57 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Sun, 24 Feb 2008 12:01:57 -0600 (CST)
Subject: [Numpy-svn] r4821 - trunk/numpy/lib
Message-ID: <20080224180157.6C39539C266@new.scipy.org>

Author: matthew.brett at gmail.com
Date: 2008-02-24 12:01:43 -0600 (Sun, 24 Feb 2008)
New Revision: 4821

Modified:
   trunk/numpy/lib/function_base.py
Log:
Return to condition where overwrite_output for median raises error for non-ndarray input

Modified: trunk/numpy/lib/function_base.py
===================================================================
--- trunk/numpy/lib/function_base.py	2008-02-23 06:37:45 UTC (rev 4820)
+++ trunk/numpy/lib/function_base.py	2008-02-24 18:01:43 UTC (rev 4821)
@@ -1226,7 +1226,8 @@
        median. This will save memory when you do not need to preserve
        the contents of the input array. Treat the input as undefined,
        but it will probably be fully or partially sorted. Default is
-       False
+       False. Note that, if overwrite_input is true, and the input
+       is not already an ndarray, an error will be raised.
 
     Returns
     -------
@@ -1275,7 +1276,6 @@
     3.5
     >>> assert not np.all(a==b)
     """
-    a = asanyarray(a)
     if overwrite_input:
         if axis is None:
             sorted = a.ravel()



From numpy-svn at scipy.org  Mon Feb 25 17:51:24 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Mon, 25 Feb 2008 16:51:24 -0600 (CST)
Subject: [Numpy-svn] r4822 - trunk/numpy/core/src
Message-ID: <20080225225124.736CD39C043@new.scipy.org>

Author: oliphant
Date: 2008-02-25 16:51:21 -0600 (Mon, 25 Feb 2008)
New Revision: 4822

Modified:
   trunk/numpy/core/src/arrayobject.c
   trunk/numpy/core/src/scalartypes.inc.src
Log:
Allow numpy scalars to be indexed in limited ways, but not be iterable.  Fix consistency bug with [...] indexing and remove useless check and allow 0-d boolean arrays to work as masks for scalars.

Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2008-02-24 18:01:43 UTC (rev 4821)
+++ trunk/numpy/core/src/arrayobject.c	2008-02-25 22:51:21 UTC (rev 4822)
@@ -2490,7 +2490,7 @@
     return 0;
 }
 
-int
+static int
 count_new_axes_0d(PyObject *tuple)
 {
     int i, argument_count;
@@ -2706,14 +2706,12 @@
         return NULL;
     }
 
+    if (op == Py_Ellipsis) {
+	Py_INCREF(self);
+	return (PyObject *)self;
+    }
+
     if (self->nd == 0) {
-        if (op == Py_Ellipsis) {
-            /* XXX: This leads to a small inconsistency
-               XXX: with the nd>0 case where (x[...] is x)
-               XXX: is false for nd>0 case. */
-            Py_INCREF(self);
-            return (PyObject *)self;
-        }
         if (op == Py_None)
             return add_new_axes_0d(self, 1);
         if (PyTuple_Check(op)) {
@@ -2726,9 +2724,8 @@
             return add_new_axes_0d(self, nd);
         }
         /* Allow Boolean mask selection also */
-        if (PyBool_Check(op) || PyArray_IsScalar(op, Bool) ||
-            (PyArray_Check(op) && (PyArray_DIMS(op)==0) &&
-             PyArray_ISBOOL(op))) {
+        if ((PyArray_Check(op) && (PyArray_DIMS(op)==0) &&
+	     PyArray_ISBOOL(op))) {
             if (PyObject_IsTrue(op)) {
                 Py_INCREF(self);
                 return (PyObject *)self;
@@ -3051,7 +3048,8 @@
         if ((op == Py_Ellipsis) || PyString_Check(op) || PyUnicode_Check(op))
             noellipses = FALSE;
         else if (PyBool_Check(op) || PyArray_IsScalar(op, Bool) ||
-                 (PyArray_Check(op) && (PyArray_DIMS(op)==0)))
+                 (PyArray_Check(op) && (PyArray_DIMS(op)==0) &&
+		  PyArray_ISBOOL(op)))
             noellipses = FALSE;
         else if (PySequence_Check(op)) {
             int n, i;
@@ -9212,7 +9210,6 @@
     char *dptr;
     int size;
     PyObject *obj = NULL;
-    int swap;
     PyArray_CopySwapFunc *copyswap;
 
     if (ind == Py_Ellipsis) {

Modified: trunk/numpy/core/src/scalartypes.inc.src
===================================================================
--- trunk/numpy/core/src/scalartypes.inc.src	2008-02-24 18:01:43 UTC (rev 4821)
+++ trunk/numpy/core/src/scalartypes.inc.src	2008-02-25 22:51:21 UTC (rev 4822)
@@ -2373,6 +2373,54 @@
         0,                                        /* tp_flags */
 };
 
+
+static PyObject *
+add_new_axes_0d(PyArrayObject *,  int);
+
+static int 
+count_new_axes_0d(PyObject *);
+
+static PyObject *
+gen_arrtype_subscript(PyObject *self, PyObject *key)
+{
+	/* Only [...], [...,<???>], [<???>, ...],
+	   is allowed for indexing a scalar
+	   
+	   These return a new N-d array with a copy of
+	   the data where N is the number of None's in <???>.
+
+	 */
+	PyObject *res, *ret;
+	int N;
+
+	if (key == Py_Ellipsis || key == Py_None ||
+	    PyTuple_Check(key)) {
+		res = PyArray_FromScalar(self, NULL);
+	}
+	else {
+		PyErr_SetString(PyExc_IndexError, 
+				"invalid index to scalar variable.");
+		return NULL;
+	}
+
+	if (key == Py_Ellipsis) 
+		return res;
+
+	if (key == Py_None) {
+		ret = add_new_axes_0d((PyArrayObject *)res, 1);
+		Py_DECREF(res);
+		return ret;
+	}
+	/* Must be a Tuple */
+	
+	N = count_new_axes_0d(key);
+	if (N < 0) return NULL;
+	ret = add_new_axes_0d((PyArrayObject *)res, N);
+	Py_DECREF(res);
+	return ret;
+}
+
+
 /**begin repeat
 #name=bool, string, unicode, void#
 #NAME=Bool, String, Unicode, Void#
@@ -2418,6 +2466,14 @@
 #undef _THIS_SIZE
 /**end repeat**/
 
+
+static PyMappingMethods gentype_as_mapping = {
+	NULL,
+        (binaryfunc)gen_arrtype_subscript,
+        NULL
+};
+
+
 /**begin repeat
 #NAME=CFloat, CDouble, CLongDouble#
 #name=complex*3#
@@ -2475,7 +2531,6 @@
 /**end repeat**/
 
 
-
 static PyNumberMethods longdoubletype_as_number;
 static PyNumberMethods clongdoubletype_as_number;
 
@@ -2486,6 +2541,7 @@
         PyGenericArrType_Type.tp_dealloc = (destructor)gentype_dealloc;
         PyGenericArrType_Type.tp_as_number = &gentype_as_number;
         PyGenericArrType_Type.tp_as_buffer = &gentype_as_buffer;
+        PyGenericArrType_Type.tp_as_mapping = &gentype_as_mapping;
         PyGenericArrType_Type.tp_flags = BASEFLAGS;
         PyGenericArrType_Type.tp_methods = gentype_methods;
         PyGenericArrType_Type.tp_getset = gentype_getsets;



From numpy-svn at scipy.org  Tue Feb 26 16:17:18 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 26 Feb 2008 15:17:18 -0600 (CST)
Subject: [Numpy-svn] r4823 - trunk/numpy/core/src
Message-ID: <20080226211718.855A539C0E4@new.scipy.org>

Author: oliphant
Date: 2008-02-26 15:17:13 -0600 (Tue, 26 Feb 2008)
New Revision: 4823

Modified:
   trunk/numpy/core/src/arrayobject.c
Log:
Make sure that mp is an array before testing for 0-d ness.

Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2008-02-25 22:51:21 UTC (rev 4822)
+++ trunk/numpy/core/src/arrayobject.c	2008-02-26 21:17:13 UTC (rev 4823)
@@ -3032,6 +3032,11 @@
 
     mp = (PyArrayObject *)array_subscript(self, op);
 
+    /* mp could be a scalar if op is not an Int, Scalar, Long or other Index
+       object and still convertable to an integer (so that the code goes to 
+       array_subscript_simple).  So, this cast is a bit dangerous..
+    */
+
     /* The following is just a copy of PyArray_Return with an
        additional logic in the nd == 0 case.
     */
@@ -3043,14 +3048,15 @@
         return NULL;
     }
 
-    if (mp->nd == 0) {
+    if (PyArray_Check(mp) && mp->nd == 0) {
         Bool noellipses = TRUE;
         if ((op == Py_Ellipsis) || PyString_Check(op) || PyUnicode_Check(op))
             noellipses = FALSE;
         else if (PyBool_Check(op) || PyArray_IsScalar(op, Bool) ||
                  (PyArray_Check(op) && (PyArray_DIMS(op)==0) &&
-		  PyArray_ISBOOL(op)))
-            noellipses = FALSE;
+		  PyArray_ISBOOL(op))) {
+	    noellipses = FALSE;
+	}
         else if (PySequence_Check(op)) {
             int n, i;
             PyObject *temp;



From numpy-svn at scipy.org  Tue Feb 26 19:51:53 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Tue, 26 Feb 2008 18:51:53 -0600 (CST)
Subject: [Numpy-svn] r4824 - trunk/numpy/core/src
Message-ID: <20080227005153.53A2039C0BB@new.scipy.org>

Author: oliphant
Date: 2008-02-26 18:51:51 -0600 (Tue, 26 Feb 2008)
New Revision: 4824

Modified:
   trunk/numpy/core/src/arrayobject.c
Log:
Don't use FAST moves on aligned flexible data-types to avoid bus errors on SPARC archiecture.

Modified: trunk/numpy/core/src/arrayobject.c
===================================================================
--- trunk/numpy/core/src/arrayobject.c	2008-02-26 21:17:13 UTC (rev 4823)
+++ trunk/numpy/core/src/arrayobject.c	2008-02-27 00:51:51 UTC (rev 4824)
@@ -758,7 +758,12 @@
         sptr = aligned;
     }
     else sptr = src->data;
-    if (PyArray_ISALIGNED(dest)) {
+    /* FIXME: This should check for a flag on the data-type
+       that states whether or not it is variable length.
+       Because the ISFLEXIBLE check is hard-coded to the 
+       built-in data-types.
+     */ 
+    if (PyArray_ISALIGNED(dest) && !PyArray_ISFLEXIBLE(dest)) {
         myfunc = _strided_byte_copy;
     }
     else if (usecopy) {



From numpy-svn at scipy.org  Wed Feb 27 14:37:13 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 27 Feb 2008 13:37:13 -0600 (CST)
Subject: [Numpy-svn] r4825 - trunk/numpy/lib
Message-ID: <20080227193713.BB69E39C19A@new.scipy.org>

Author: rkern
Date: 2008-02-27 13:37:11 -0600 (Wed, 27 Feb 2008)
New Revision: 4825

Modified:
   trunk/numpy/lib/format.py
Log:
Documentation update for the NPY format.

Modified: trunk/numpy/lib/format.py
===================================================================
--- trunk/numpy/lib/format.py	2008-02-27 00:51:51 UTC (rev 4824)
+++ trunk/numpy/lib/format.py	2008-02-27 19:37:11 UTC (rev 4825)
@@ -1,12 +1,12 @@
 """ Define a simple format for saving numpy arrays to disk with the full
 information about them.
 
-WARNING: THE FORMAT IS CURRENTLY UNSTABLE. DO NOT STORE CRITICAL DATA WITH IT.
-         While this code is in an SVN branch, the format may change without
-         notice, without backwards compatibility, and without changing the
-         format's version number. When the code moves into the trunk the format
-         will be stabilized, the version number will increment as changes occur,
-         and backwards compatibility with older versions will be maintained.
+WARNING: Due to limitations in the string representation of dtypes, some
+complicated nested structures will not be faithfully recorded in the file. We
+are working on a fix for this. This fix will not require a change in the file
+format. The arrays with complicated structures can still be saved, but the
+correct dtype will have to be restored by using the
+`loadedarray.view(correct_dtype)` method.
 
 Format Version 1.0
 ------------------
@@ -42,7 +42,9 @@
         The shape of the array.
 
 For repeatability and readability, this dictionary is formatted using
-pprint.pformat() so the keys are in alphabetic order.
+pprint.pformat() so the keys are in alphabetic order. This is for convenience
+only. A writer SHOULD implement this if possible. A reader MUST NOT depend on
+this.
 
 Following the header comes the array data. If the dtype contains Python objects
 (i.e. dtype.hasobject is True), then the data is a Python pickle of the array.



From numpy-svn at scipy.org  Wed Feb 27 15:59:24 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 27 Feb 2008 14:59:24 -0600 (CST)
Subject: [Numpy-svn] r4826 - trunk/numpy/core
Message-ID: <20080227205924.DB50539C0A2@new.scipy.org>

Author: oliphant
Date: 2008-02-27 14:59:20 -0600 (Wed, 27 Feb 2008)
New Revision: 4826

Modified:
   trunk/numpy/core/_internal.py
Log:
Fix printing of complicated dtypes.

Modified: trunk/numpy/core/_internal.py
===================================================================
--- trunk/numpy/core/_internal.py	2008-02-27 19:37:11 UTC (rev 4825)
+++ trunk/numpy/core/_internal.py	2008-02-27 20:59:20 UTC (rev 4826)
@@ -79,8 +79,13 @@
 def _array_descr(descriptor):
     fields = descriptor.fields
     if fields is None:
-        return descriptor.str
+        subdtype = descriptor.subdtype
+        if subdtype is None:
+            return descriptor.str
+        else:
+            return (_array_descr(subdtype[0]), subdtype[1])
 
+
     names = descriptor.names
     ordered_fields = [fields[x] + (x,) for x in names]
     result = []



From numpy-svn at scipy.org  Wed Feb 27 17:56:11 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 27 Feb 2008 16:56:11 -0600 (CST)
Subject: [Numpy-svn] r4827 - trunk/numpy/lib
Message-ID: <20080227225611.00E3639C071@new.scipy.org>

Author: rkern
Date: 2008-02-27 16:56:07 -0600 (Wed, 27 Feb 2008)
New Revision: 4827

Modified:
   trunk/numpy/lib/io.py
Log:
Handle the no-comment case correctly.

Modified: trunk/numpy/lib/io.py
===================================================================
--- trunk/numpy/lib/io.py	2008-02-27 20:59:20 UTC (rev 4826)
+++ trunk/numpy/lib/io.py	2008-02-27 22:56:07 UTC (rev 4827)
@@ -293,7 +293,11 @@
 
     for i,line in enumerate(fh):
         if i<skiprows: continue
-        line = line[:line.find(comments)].strip()
+        comment_start = line.find(comments)
+        if comment_start > 0:
+            line = line[:comments_start].strip()
+        else:
+            line = line.strip()
         if not len(line): continue
         vals = line.split(delimiter)
         if converterseq is None:



From numpy-svn at scipy.org  Wed Feb 27 18:00:48 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 27 Feb 2008 17:00:48 -0600 (CST)
Subject: [Numpy-svn] r4828 - trunk/numpy/lib
Message-ID: <20080227230048.DF21A39C05E@new.scipy.org>

Author: rkern
Date: 2008-02-27 17:00:48 -0600 (Wed, 27 Feb 2008)
New Revision: 4828

Modified:
   trunk/numpy/lib/format.py
Log:
One dtype representation issue got fixed. Documented the remaining one.

Modified: trunk/numpy/lib/format.py
===================================================================
--- trunk/numpy/lib/format.py	2008-02-27 22:56:07 UTC (rev 4827)
+++ trunk/numpy/lib/format.py	2008-02-27 23:00:48 UTC (rev 4828)
@@ -1,12 +1,13 @@
 """ Define a simple format for saving numpy arrays to disk with the full
 information about them.
 
-WARNING: Due to limitations in the string representation of dtypes, some
-complicated nested structures will not be faithfully recorded in the file. We
-are working on a fix for this. This fix will not require a change in the file
-format. The arrays with complicated structures can still be saved, but the
-correct dtype will have to be restored by using the
-`loadedarray.view(correct_dtype)` method.
+WARNING: Due to limitations in the interpretation of structured dtypes, dtypes
+with fields with empty names will have the names replaced by 'f0', 'f1', etc.
+Such arrays will not round-trip through the format entirely accurately. The data
+is intact; only the field names will differ. We are working on a fix for this.
+This fix will not require a change in the file format. The arrays with such
+structures can still be saved and restored, and the correct dtype may be
+restored by using the `loadedarray.view(correct_dtype)` method.
 
 Format Version 1.0
 ------------------



From numpy-svn at scipy.org  Wed Feb 27 18:53:40 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Wed, 27 Feb 2008 17:53:40 -0600 (CST)
Subject: [Numpy-svn] r4829 - trunk/numpy/doc
Message-ID: <20080227235340.25E3E39C04F@new.scipy.org>

Author: rkern
Date: 2008-02-27 17:53:39 -0600 (Wed, 27 Feb 2008)
New Revision: 4829

Added:
   trunk/numpy/doc/npy-format.txt
Log:
Add PEP-style document describing the NPY format.

Added: trunk/numpy/doc/npy-format.txt
===================================================================
--- trunk/numpy/doc/npy-format.txt	2008-02-27 23:00:48 UTC (rev 4828)
+++ trunk/numpy/doc/npy-format.txt	2008-02-27 23:53:39 UTC (rev 4829)
@@ -0,0 +1,294 @@
+Title: A Simple File Format for NumPy Arrays
+Discussions-To: numpy-discussion at mail.scipy.org
+Version: $Revision$
+Last-Modified: $Date$
+Author: Robert Kern <robert.kern at gmail.com>
+Status: Draft
+Type: Standards Track
+Content-Type: text/plain
+Created: 20-Dec-2007
+
+
+Abstract
+
+    We propose a standard binary file format (NPY) for persisting
+    a single arbitrary NumPy array on disk.  The format stores all of
+    the shape and dtype information necessary to reconstruct the array
+    correctly even on another machine with a different architecture.
+    The format is designed to be as simple as possible while achieving
+    its limited goals.  The implementation is intended to be pure
+    Python and distributed as part of the main numpy package.
+
+
+Rationale
+
+    A lightweight, omnipresent system for saving NumPy arrays to disk
+    is a frequent need.  Python in general has pickle [1] for saving
+    most Python objects to disk.  This often works well enough with
+    NumPy arrays for many purposes, but it has a few drawbacks:
+
+    - Dumping or loading a pickle file require the duplication of the
+      data in memory.  For large arrays, this can be a showstopper.
+
+    - The array data is not directly accessible through
+      memory-mapping.  Now that numpy has that capability, it has
+      proved very useful for loading large amounts of data (or more to
+      the point: avoiding loading large amounts of data when you only
+      need a small part).
+
+    Both of these problems can be addressed by dumping the raw bytes
+    to disk using ndarray.tofile() and numpy.fromfile().  However,
+    these have their own problems:
+
+    - The data which is written has no information about the shape or
+      dtype of the array.
+
+    - It is incapable of handling object arrays.
+
+    The NPY file format is an evolutionary advance over these two
+    approaches.  Its design is mostly limited to solving the problems
+    with pickles and tofile()/fromfile().  It does not intend to solve
+    more complicated problems for which more complicated formats like
+    HDF5 [2] are a better solution.
+
+
+Use Cases
+
+    - Neville Newbie has just started to pick up Python and NumPy.  He
+      has not installed many packages, yet, nor learned the standard
+      library, but he has been playing with NumPy at the interactive
+      prompt to do small tasks.  He gets a result that he wants to
+      save.
+
+    - Annie Analyst has been using large nested record arrays to
+      represent her statistical data.  She wants to convince her
+      R-using colleague, David Doubter, that Python and NumPy are
+      awesome by sending him her analysis code and data.  She needs
+      the data to load at interactive speeds.  Since David does not
+      use Python usually, needing to install large packages would turn
+      him off.
+
+    - Simon Seismologist is developing new seismic processing tools.
+      One of his algorithms requires large amounts of intermediate
+      data to be written to disk.  The data does not really fit into
+      the industry-standard SEG-Y schema, but he already has a nice
+      record-array dtype for using it internally.
+
+    - Polly Parallel wants to split up a computation on her multicore
+      machine as simply as possible.  Parts of the computation can be
+      split up among different processes without any communication
+      between processes; they just need to fill in the appropriate
+      portion of a large array with their results.  Having several
+      child processes memory-mapping a common array is a good way to
+      achieve this.
+
+
+Requirements
+
+    The format MUST be able to:
+
+    - Represent all NumPy arrays including nested record
+      arrays and object arrays.
+
+    - Represent the data in its native binary form.
+
+    - Be contained in a single file.
+
+    - Support Fortran-contiguous arrays directly.
+
+    - Store all of the necessary information to reconstruct the array
+      including shape and dtype on a machine of a different
+      architecture.  Both little-endian and big-endian arrays must be
+      supported and a file with little-endian numbers will yield
+      a little-endian array on any machine reading the file.  The
+      types must be described in terms of their actual sizes.  For
+      example, if a machine with a 64-bit C "long int" writes out an
+      array with "long ints", a reading machine with 32-bit C "long
+      ints" will yield an array with 64-bit integers.
+
+    - Be reverse engineered.  Datasets often live longer than the
+      programs that created them.  A competent developer should be
+      able create a solution in his preferred programming language to
+      read most NPY files that he has been given without much
+      documentation.
+
+    - Allow memory-mapping of the data.
+
+    - Be read from a filelike stream object instead of an actual file.
+      This allows the implementation to be tested easily and makes the
+      system more flexible.  NPY files can be stored in ZIP files and
+      easily read from a ZipFile object.
+
+    - Store object arrays.  Since general Python objects are
+      complicated and can only be reliably serialized by pickle (if at
+      all), many of the other requirements are waived for files
+      containing object arrays.  Files with object arrays do not have
+      to be mmapable since that would be technically impossible.  We
+      cannot expect the pickle format to be reverse engineered without
+      knowledge of pickle.  However, one should at least be able to
+      read and write object arrays with the same generic interface as
+      other arrays.
+
+    - Be read and written using APIs provided in the numpy package
+      itself without any other libraries.  The implementation inside
+      numpy may be in C if necessary.
+
+    The format explicitly *does not* need to:
+
+    - Support multiple arrays in a file.  Since we require filelike
+      objects to be supported, one could use the API to build an ad
+      hoc format that supported multiple arrays.  However, solving the
+      general problem and use cases is beyond the scope of the format
+      and the API for numpy.
+
+    - Fully handle arbitrary subclasses of numpy.ndarray.  Subclasses
+      will be accepted for writing, but only the array data will be
+      written out.  A regular numpy.ndarray object will be created
+      upon reading the file.  The API can be used to build a format
+      for a particular subclass, but that is out of scope for the
+      general NPY format.
+
+
+Format Specification: Version 1.0
+
+    The first 6 bytes are a magic string: exactly "\x93NUMPY".
+
+    The next 1 byte is an unsigned byte: the major version number of
+    the file format, e.g. \x01.
+
+    The next 1 byte is an unsigned byte: the minor version number of
+    the file format, e.g. \x00.  Note: the version of the file format
+    is not tied to the version of the numpy package.
+
+    The next 2 bytes form a little-endian unsigned short int: the
+    length of the header data HEADER_LEN.
+
+    The next HEADER_LEN bytes form the header data describing the
+    array's format.  It is an ASCII string which contains a Python
+    literal expression of a dictionary.  It is terminated by a newline
+    ('\n') and padded with spaces ('\x20') to make the total length of
+    the magic string + 4 + HEADER_LEN be evenly divisible by 16 for
+    alignment purposes.
+
+    The dictionary contains three keys:
+
+        "descr" : dtype.descr
+            An object that can be passed as an argument to the
+            numpy.dtype() constructor to create the array's dtype.
+
+        "fortran_order" : bool
+            Whether the array data is Fortran-contiguous or not.
+            Since Fortran-contiguous arrays are a common form of
+            non-C-contiguity, we allow them to be written directly to
+            disk for efficiency.
+
+        "shape" : tuple of int
+            The shape of the array.
+
+    For repeatability and readability, this dictionary is formatted
+    using pprint.pformat() so the keys are in alphabetic order.
+
+    Following the header comes the array data.  If the dtype contains
+    Python objects (i.e. dtype.hasobject is True), then the data is
+    a Python pickle of the array.  Otherwise the data is the
+    contiguous (either C- or Fortran-, depending on fortran_order)
+    bytes of the array.  Consumers can figure out the number of bytes
+    by multiplying the number of elements given by the shape (noting
+    that shape=() means there is 1 element) by dtype.itemsize.
+
+
+Conventions
+
+    We recommend using the ".npy" extension for files following this
+    format.  This is by no means a requirement; applications may wish
+    to use this file format but use an extension specific to the
+    application.  In the absence of an obvious alternative, however,
+    we suggest using ".npy".
+
+    For a simple way to combine multiple arrays into a single file,
+    one can use ZipFile to contain multiple ".npy" files.  We
+    recommend using the file extension ".npz" for these archives.
+
+
+Alternatives
+
+    The author believes that this system (or one along these lines) is
+    about the simplest system that satisfies all of the requirements.
+    However, one must always be wary of introducing a new binary
+    format to the world.
+
+    HDF5 [2] is a very flexible format that should be able to
+    represent all of NumPy's arrays in some fashion.  It is probably
+    the only widely-used format that can faithfully represent all of
+    NumPy's array features.  It has seen substantial adoption by the
+    scientific community in general and the NumPy community in
+    particular.  It is an excellent solution for a wide variety of
+    array storage problems with or without NumPy.
+
+    HDF5 is a complicated format that more or less implements
+    a hierarchical filesystem-in-a-file.  This fact makes satisfying
+    some of the Requirements difficult.  To the author's knowledge, as
+    of this writing, there is no application or library that reads or
+    writes even a subset of HDF5 files that does not use the canonical
+    libhdf5 implementation.  This implementation is a large library
+    that is not always easy to build.  It would be infeasible to
+    include it in numpy.
+
+    It might be feasible to target an extremely limited subset of
+    HDF5.  Namely, there would be only one object in it: the array.
+    Using contiguous storage for the data, one should be able to
+    implement just enough of the format to provide the same metadata
+    that the proposed format does.  One could still meet all of the
+    technical requirements like mmapability.
+
+    We would accrue a substantial benefit by being able to generate
+    files that could be read by other HDF5 software.  Furthermore, by
+    providing the first non-libhdf5 implementation of HDF5, we would
+    be able to encourage more adoption of simple HDF5 in applications
+    where it was previously infeasible because of the size of the
+    library.  The basic work may encourage similar dead-simple
+    implementations in other languages and further expand the
+    community.
+
+    The remaining concern is about reverse engineerability of the
+    format.  Even the simple subset of HDF5 would be very difficult to
+    reverse engineer given just a file by itself.  However, given the
+    prominence of HDF5, this might not be a substantial concern.
+
+    In conclusion, we are going forward with the design laid out in
+    this document.  If someone writes code to handle the simple subset
+    of HDF5 that would be useful to us, we may consider a revision of
+    the file format.
+
+
+Implementation
+
+    The current implementation is in the trunk of the numpy SVN
+    repository and will be part of the 1.0.5 release.
+
+        http://svn.scipy.org/svn/numpy/trunk
+
+    Specifically, the file format.py in this directory implements the
+    format as described here.
+
+
+References
+
+    [1] http://docs.python.org/lib/module-pickle.html
+
+    [2] http://hdf.ncsa.uiuc.edu/products/hdf5/index.html
+
+
+Copyright
+
+    This document has been placed in the public domain.
+
+
+

+Local Variables:
+mode: indented-text
+indent-tabs-mode: nil
+sentence-end-double-space: t
+fill-column: 70
+coding: utf-8
+End:


Property changes on: trunk/numpy/doc/npy-format.txt
___________________________________________________________________
Name: svn:eol-style
   + native



From numpy-svn at scipy.org  Thu Feb 28 01:31:58 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 28 Feb 2008 00:31:58 -0600 (CST)
Subject: [Numpy-svn] r4830 - trunk/numpy/lib
Message-ID: <20080228063158.E344239C215@new.scipy.org>

Author: rkern
Date: 2008-02-28 00:31:48 -0600 (Thu, 28 Feb 2008)
New Revision: 4830

Modified:
   trunk/numpy/lib/io.py
Log:
Typo.

Modified: trunk/numpy/lib/io.py
===================================================================
--- trunk/numpy/lib/io.py	2008-02-27 23:53:39 UTC (rev 4829)
+++ trunk/numpy/lib/io.py	2008-02-28 06:31:48 UTC (rev 4830)
@@ -295,7 +295,7 @@
         if i<skiprows: continue
         comment_start = line.find(comments)
         if comment_start > 0:
-            line = line[:comments_start].strip()
+            line = line[:comment_start].strip()
         else:
             line = line.strip()
         if not len(line): continue



From numpy-svn at scipy.org  Thu Feb 28 01:39:52 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 28 Feb 2008 00:39:52 -0600 (CST)
Subject: [Numpy-svn] r4831 - trunk/numpy/lib
Message-ID: <20080228063952.2F71739C1B6@new.scipy.org>

Author: rkern
Date: 2008-02-28 00:39:28 -0600 (Thu, 28 Feb 2008)
New Revision: 4831

Modified:
   trunk/numpy/lib/io.py
Log:
Correct condition.

Modified: trunk/numpy/lib/io.py
===================================================================
--- trunk/numpy/lib/io.py	2008-02-28 06:31:48 UTC (rev 4830)
+++ trunk/numpy/lib/io.py	2008-02-28 06:39:28 UTC (rev 4831)
@@ -294,7 +294,7 @@
     for i,line in enumerate(fh):
         if i<skiprows: continue
         comment_start = line.find(comments)
-        if comment_start > 0:
+        if comment_start != -1:
             line = line[:comment_start].strip()
         else:
             line = line.strip()



From numpy-svn at scipy.org  Thu Feb 28 01:42:54 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 28 Feb 2008 00:42:54 -0600 (CST)
Subject: [Numpy-svn] r4832 - trunk/numpy/core
Message-ID: <20080228064254.01F8739C271@new.scipy.org>

Author: rkern
Date: 2008-02-28 00:42:48 -0600 (Thu, 28 Feb 2008)
New Revision: 4832

Modified:
   trunk/numpy/core/numeric.py
Log:
loadtxt and savetxt moved to lib/io.py

Modified: trunk/numpy/core/numeric.py
===================================================================
--- trunk/numpy/core/numeric.py	2008-02-28 06:39:28 UTC (rev 4831)
+++ trunk/numpy/core/numeric.py	2008-02-28 06:42:48 UTC (rev 4832)
@@ -636,177 +636,6 @@
         file = _file(file,"rb")
     return _cload(file)
 
-# Adapted from matplotlib
-
-def _getconv(dtype):
-    typ = dtype.type
-    if issubclass(typ, bool_):
-        return lambda x: bool(int(x))
-    if issubclass(typ, integer):
-        return int
-    elif issubclass(typ, floating):
-        return float
-    elif issubclass(typ, complex):
-        return complex
-    else:
-        return str
-
-
-def _string_like(obj):
-    try: obj + ''
-    except (TypeError, ValueError): return 0
-    return 1
-
-def loadtxt(fname, dtype=float, comments='#', delimiter=None, converters=None,
-            skiprows=0, usecols=None, unpack=False):
-    """
-    Load ASCII data from fname into an array and return the array.
-
-    The data must be regular, same number of values in every row
-
-    fname can be a filename or a file handle.  Support for gzipped files is
-    automatic, if the filename ends in .gz
-
-    See scipy.io.loadmat to read and write matfiles.
-
-    Example usage:
-
-      X = loadtxt('test.dat')  # data in two columns
-      t = X[:,0]
-      y = X[:,1]
-
-    Alternatively, you can do the same with "unpack"; see below
-
-      X = loadtxt('test.dat')    # a matrix of data
-      x = loadtxt('test.dat')    # a single column of data
-
-
-    dtype - the data-type of the resulting array.  If this is a
-    record data-type, the the resulting array will be 1-d and each row will
-    be interpreted as an element of the array. The number of columns
-    used must match the number of fields in the data-type in this case.
-
-    comments - the character used to indicate the start of a comment
-    in the file
-
-    delimiter is a string-like character used to seperate values in the
-    file. If delimiter is unspecified or none, any whitespace string is
-    a separator.
-
-    converters, if not None, is a dictionary mapping column number to
-    a function that will convert that column to a float.  Eg, if
-    column 0 is a date string: converters={0:datestr2num}
-
-    skiprows is the number of rows from the top to skip
-
-    usecols, if not None, is a sequence of integer column indexes to
-    extract where 0 is the first column, eg usecols=(1,4,5) to extract
-    just the 2nd, 5th and 6th columns
-
-    unpack, if True, will transpose the matrix allowing you to unpack
-    into named arguments on the left hand side
-
-        t,y = load('test.dat', unpack=True) # for  two column data
-        x,y,z = load('somefile.dat', usecols=(3,5,7), unpack=True)
-
-    """
-
-    if _string_like(fname):
-        if fname.endswith('.gz'):
-            import gzip
-            fh = gzip.open(fname)
-        else:
-            fh = file(fname)
-    elif hasattr(fname, 'seek'):
-        fh = fname
-    else:
-        raise ValueError('fname must be a string or file handle')
-    X = []
-
-    dtype = multiarray.dtype(dtype)
-    defconv = _getconv(dtype)
-    converterseq = None
-    if converters is None:
-        converters = {}
-        if dtype.names is not None:
-            converterseq = [_getconv(dtype.fields[name][0]) \
-                            for name in dtype.names]
-
-    for i,line in enumerate(fh):
-        if i<skiprows: continue
-        line = line[:line.find(comments)].strip()
-        if not len(line): continue
-        vals = line.split(delimiter)
-        if converterseq is None:
-            converterseq = [converters.get(j,defconv) \
-                            for j in xrange(len(vals))]
-        if usecols is not None:
-            row = [converterseq[j](vals[j]) for j in usecols]
-        else:
-            row = [converterseq[j](val) for j,val in enumerate(vals)]
-        if dtype.names is not None:
-            row = tuple(row)
-        X.append(row)
-
-    X = array(X, dtype)
-    r,c = X.shape
-    if r==1 or c==1:
-        X.shape = max([r,c]),
-    if unpack: return X.T
-    else:  return X
-
-
-# adjust so that fmt can change across columns if desired.
-
-def savetxt(fname, X, fmt='%.18e',delimiter=' '):
-    """
-    Save the data in X to file fname using fmt string to convert the
-    data to strings
-
-    fname can be a filename or a file handle.  If the filename ends in .gz,
-    the file is automatically saved in compressed gzip format.  The load()
-    command understands gzipped files transparently.
-
-    Example usage:
-
-    save('test.out', X)         # X is an array
-    save('test1.out', (x,y,z))  # x,y,z equal sized 1D arrays
-    save('test2.out', x)        # x is 1D
-    save('test3.out', x, fmt='%1.4e')  # use exponential notation
-
-    delimiter is used to separate the fields, eg delimiter ',' for
-    comma-separated values
-    """
-
-    if _string_like(fname):
-        if fname.endswith('.gz'):
-            import gzip
-            fh = gzip.open(fname,'wb')
-        else:
-            fh = file(fname,'w')
-    elif hasattr(fname, 'seek'):
-        fh = fname
-    else:
-        raise ValueError('fname must be a string or file handle')
-
-
-    X = asarray(X)
-    origShape = None
-    if len(X.shape)==1:
-        origShape = X.shape
-        X.shape = len(X), 1
-    for row in X:
-        fh.write(delimiter.join([fmt%val for val in row]) + '\n')
-
-    if origShape is not None:
-        X.shape = origShape
-
-
-
-
-
-
-
 # These are all essentially abbreviations
 # These might wind up in a special abbreviations module
 



From numpy-svn at scipy.org  Thu Feb 28 02:06:35 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 28 Feb 2008 01:06:35 -0600 (CST)
Subject: [Numpy-svn] r4833 - trunk/numpy/core
Message-ID: <20080228070635.7854C39C2DF@new.scipy.org>

Author: rkern
Date: 2008-02-28 01:06:24 -0600 (Thu, 28 Feb 2008)
New Revision: 4833

Modified:
   trunk/numpy/core/numeric.py
Log:
Omit loadtxt and savetxt from __all__

Modified: trunk/numpy/core/numeric.py
===================================================================
--- trunk/numpy/core/numeric.py	2008-02-28 06:42:48 UTC (rev 4832)
+++ trunk/numpy/core/numeric.py	2008-02-28 07:06:24 UTC (rev 4833)
@@ -12,7 +12,7 @@
            'array_repr', 'array_str', 'set_string_function',
            'little_endian', 'require',
            'fromiter', 'array_equal', 'array_equiv',
-           'indices', 'fromfunction', 'loadtxt', 'savetxt',
+           'indices', 'fromfunction', 
            'load', 'loads', 'isscalar', 'binary_repr', 'base_repr',
            'ones', 'identity', 'allclose', 'compare_chararrays', 'putmask',
            'seterr', 'geterr', 'setbufsize', 'getbufsize',



From numpy-svn at scipy.org  Thu Feb 28 11:07:59 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Thu, 28 Feb 2008 10:07:59 -0600 (CST)
Subject: [Numpy-svn] r4834 - trunk/numpy/fft
Message-ID: <20080228160759.D990939C0AD@new.scipy.org>

Author: oliphant
Date: 2008-02-28 10:07:59 -0600 (Thu, 28 Feb 2008)
New Revision: 4834

Modified:
   trunk/numpy/fft/helper.py
Log:
Try to speed up fftfreq a bit.

Modified: trunk/numpy/fft/helper.py
===================================================================
--- trunk/numpy/fft/helper.py	2008-02-28 07:06:24 UTC (rev 4833)
+++ trunk/numpy/fft/helper.py	2008-02-28 16:07:59 UTC (rev 4834)
@@ -6,8 +6,7 @@
 __all__ = ['fftshift','ifftshift','fftfreq']
 
 from numpy.core import asarray, concatenate, arange, take, \
-    integer
-from numpy import hstack
+    integer, empty
 import types
 
 def fftshift(x,axes=None):
@@ -63,4 +62,12 @@
       f = [0,1,...,(n-1)/2,-(n-1)/2,...,-1]/(d*n)   if n is odd
     """
     assert isinstance(n,types.IntType) or isinstance(n, integer)
-    return hstack((arange(0,(n-1)/2 + 1), arange(-(n/2),0))) / (n*d)
+    val = 1.0/(n*d)
+    results = empty(n, int)
+    N = (n-1)//2 + 1
+    p1 = arange(0,N,dtype=int)
+    results[:N] = p1
+    p2 = arange(-(n//2),0,dtype=int)
+    results[N:] = p2
+    return results * val
+    #return hstack((arange(0,(n-1)/2 + 1), arange(-(n/2),0))) / (n*d)



From numpy-svn at scipy.org  Fri Feb 29 01:35:49 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 29 Feb 2008 00:35:49 -0600 (CST)
Subject: [Numpy-svn] r4835 - trunk/numpy
Message-ID: <20080229063549.8E8AB39C0CE@new.scipy.org>

Author: oliphant
Date: 2008-02-29 00:35:47 -0600 (Fri, 29 Feb 2008)
New Revision: 4835

Modified:
   trunk/numpy/__init__.py
Log:
Alter NumPy docstring to remove ad and give a litte more info.

Modified: trunk/numpy/__init__.py
===================================================================
--- trunk/numpy/__init__.py	2008-02-28 16:07:59 UTC (rev 4834)
+++ trunk/numpy/__init__.py	2008-02-29 06:35:47 UTC (rev 4835)
@@ -1,19 +1,14 @@
 """
 NumPy
 ==========
+Provides 
+   1) An array object of arbitrary homogeneous items
+   2) Fast mathematical operations over arrays
+   3) Linear Algebra, Fourier Transforms, Random Number Generation
 
-You can support the development of NumPy and SciPy by purchasing
-the book "Guide to NumPy" at
-
-  http://www.trelgol.com
-
-It is being distributed for a fee until Oct. 2010 to
-cover some of the costs of development.  After the restriction period
-it will also be freely available.
-
 Documentation is available in the docstrings and at
 
-http://www.scipy.org.
+http://www.scipy.org
 """
 
 # We first need to detect if we're being called as part of the numpy setup



From numpy-svn at scipy.org  Fri Feb 29 16:21:05 2008
From: numpy-svn at scipy.org (numpy-svn at scipy.org)
Date: Fri, 29 Feb 2008 15:21:05 -0600 (CST)
Subject: [Numpy-svn] r4836 - in trunk/numpy/core: . code_generators
Message-ID: <20080229212105.90A6F39C042@new.scipy.org>

Author: rkern
Date: 2008-02-29 15:21:04 -0600 (Fri, 29 Feb 2008)
New Revision: 4836

Modified:
   trunk/numpy/core/code_generators/generate_umath.py
   trunk/numpy/core/numerictypes.py
Log:
Fix #643. This doesn't resolve *all* of the issues of working within a Turkish locale, but this will work around the bug that the OLPC project found.

Modified: trunk/numpy/core/code_generators/generate_umath.py
===================================================================
--- trunk/numpy/core/code_generators/generate_umath.py	2008-02-29 06:35:47 UTC (rev 4835)
+++ trunk/numpy/core/code_generators/generate_umath.py	2008-02-29 21:21:04 UTC (rev 4836)
@@ -562,6 +562,39 @@
 # 2) fill in functions and data in InitOperators
 # 3) add function.
 
+# String-handling utilities to avoid locale-dependence.
+
+import string
+UPPER_TABLE = string.maketrans(string.ascii_lowercase, string.ascii_uppercase)
+
+def english_upper(s):
+    """ Apply English case rules to convert ASCII strings to all upper case.
+
+    This is an internal utility function to replace calls to str.upper() such
+    that we can avoid changing behavior with changing locales. In particular,
+    Turkish has distinct dotted and dotless variants of the Latin letter "I" in
+    both lowercase and uppercase. Thus, "i".upper() != "I" in a "tr" locale.
+
+    Parameters
+    ----------
+    s : str
+
+    Returns
+    -------
+    uppered : str
+
+    Examples
+    --------
+    >>> from numpy.lib.utils import english_upper
+    >>> english_upper('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_')
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
+    >>> english_upper('')
+    ''
+    """
+    uppered = s.translate(UPPER_TABLE)
+    return uppered
+
+
 def make_arrays(funcdict):
     # functions array contains an entry for every type implemented
     #   NULL should be placed where PyUfunc_ style function will be filled in later
@@ -606,11 +639,11 @@
                 sub += 1
             else:
                 datalist.append('(void *)NULL');
-                tname = chartoname[t.type].upper()
+                tname = english_upper(chartoname[t.type])
                 funclist.append('%s_%s' % (tname, name))
 
             for x in t.in_ + t.out:
-                siglist.append('PyArray_%s' % (chartoname[x].upper(),))
+                siglist.append('PyArray_%s' % (english_upper(chartoname[x]),))
 
             k += 1
 

Modified: trunk/numpy/core/numerictypes.py
===================================================================
--- trunk/numpy/core/numerictypes.py	2008-02-29 06:35:47 UTC (rev 4835)
+++ trunk/numpy/core/numerictypes.py	2008-02-29 21:21:04 UTC (rev 4836)
@@ -87,6 +87,98 @@
 # as numerictypes.bool, etc.
 from __builtin__ import bool, int, long, float, complex, object, unicode, str
 
+
+# String-handling utilities to avoid locale-dependence.
+
+import string
+LOWER_TABLE = string.maketrans(string.ascii_uppercase, string.ascii_lowercase)
+UPPER_TABLE = string.maketrans(string.ascii_lowercase, string.ascii_uppercase)
+
+def english_lower(s):
+    """ Apply English case rules to convert ASCII strings to all lower case.
+
+    This is an internal utility function to replace calls to str.lower() such
+    that we can avoid changing behavior with changing locales. In particular,
+    Turkish has distinct dotted and dotless variants of the Latin letter "I" in
+    both lowercase and uppercase. Thus, "I".lower() != "i" in a "tr" locale.
+
+    Parameters
+    ----------
+    s : str
+
+    Returns
+    -------
+    lowered : str
+
+    Examples
+    --------
+    >>> from numpy.lib.utils import english_lower
+    >>> english_lower('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_')
+    'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789_'
+    >>> english_upper('')
+    ''
+    """
+    lowered = s.translate(LOWER_TABLE)
+    return lowered
+
+def english_upper(s):
+    """ Apply English case rules to convert ASCII strings to all upper case.
+
+    This is an internal utility function to replace calls to str.upper() such
+    that we can avoid changing behavior with changing locales. In particular,
+    Turkish has distinct dotted and dotless variants of the Latin letter "I" in
+    both lowercase and uppercase. Thus, "i".upper() != "I" in a "tr" locale.
+
+    Parameters
+    ----------
+    s : str
+
+    Returns
+    -------
+    uppered : str
+
+    Examples
+    --------
+    >>> from numpy.lib.utils import english_upper
+    >>> english_upper('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_')
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
+    >>> english_upper('')
+    ''
+    """
+    uppered = s.translate(UPPER_TABLE)
+    return uppered
+
+def english_capitalize(s):
+    """ Apply English case rules to convert the first character of an ASCII
+    string to upper case.
+
+    This is an internal utility function to replace calls to str.capitalize()
+    such that we can avoid changing behavior with changing locales.
+
+    Parameters
+    ----------
+    s : str
+
+    Returns
+    -------
+    capitalized : str
+
+    Examples
+    --------
+    >>> from numpy.lib.utils import english_capitalize
+    >>> english_capitalize('int8')
+    'Int8'
+    >>> english_capitalize('Int8')
+    'Int8'
+    >>> english_capitalize('')
+    ''
+    """
+    if s:
+        return english_upper(s[0]) + s[1:]
+    else:
+        return s
+
+
 sctypeDict = {}      # Contains all leaf-node scalar types with aliases
 sctypeNA = {}        # Contails all leaf-node types -> numarray type equivalences
 allTypes = {}      # Collect the types we will add to the module here
@@ -114,7 +206,7 @@
             newname = name[:-1]
         else:
             newname = name
-        info = typeinfo[newname.upper()]
+        info = typeinfo[english_upper(newname)]
         assert(info[-1] == obj)  # sanity check
         bits = info[2]
 
@@ -149,7 +241,7 @@
 
 def _add_types():
     for a in typeinfo.keys():
-        name = a.lower()
+        name = english_lower(a)
         if isinstance(typeinfo[a], tuple):
             typeobj = typeinfo[a][-1]
 
@@ -165,7 +257,7 @@
 
 def _add_aliases():
     for a in typeinfo.keys():
-        name = a.lower()
+        name = english_lower(a)
         if not isinstance(typeinfo[a], tuple):
             continue
         typeobj = typeinfo[a][-1]
@@ -179,12 +271,12 @@
                 allTypes[myname] = typeobj
                 sctypeDict[myname] = typeobj
                 if base == 'complex':
-                    na_name = '%s%d' % (base.capitalize(), bit/2)
+                    na_name = '%s%d' % (english_capitalize(base), bit/2)
                 elif base == 'bool':
-                    na_name = base.capitalize()
+                    na_name = english_capitalize(base)
                     sctypeDict[na_name] = typeobj
                 else:
-                    na_name = "%s%d" % (base.capitalize(), bit)
+                    na_name = "%s%d" % (english_capitalize(base), bit)
                     sctypeDict[na_name] = typeobj
                 sctypeNA[na_name] = typeobj
                 sctypeDict[na_name] = typeobj