Fix whitespace to conform to Python 3000 convention.

1 files changed, 1436 insertions, 1437 deletions

diff --git a/numpy/core/src/arraymethods.c b/numpy/core/src/arraymethods.c
index 3a1b0c37d..9c56e6459 100644
--- a/numpy/core/src/arraymethods.c
+++ b/numpy/core/src/arraymethods.c
@@ -1,321 +1,320 @@
-
 /* Should only be used if x is known to be an nd-array */
 #define _ARET(x) PyArray_Return((PyArrayObject *)(x))
 
 static PyObject *
 array_take(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int dimension=MAX_DIMS;
-	PyObject *indices;
-        PyArrayObject *out=NULL;
-        NPY_CLIPMODE mode=NPY_RAISE;
-	static char *kwlist[] = {"indices", "axis", "out", "mode", NULL};
+    int dimension=MAX_DIMS;
+    PyObject *indices;
+    PyArrayObject *out=NULL;
+    NPY_CLIPMODE mode=NPY_RAISE;
+    static char *kwlist[] = {"indices", "axis", "out", "mode", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&O&", kwlist,
-					 &indices, PyArray_AxisConverter,
-					 &dimension,
-                                         PyArray_OutputConverter,
-                                         &out,
-                                         PyArray_ClipmodeConverter,
-                                         &mode))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&O&", kwlist,
+                                     &indices, PyArray_AxisConverter,
+                                     &dimension,
+                                     PyArray_OutputConverter,
+                                     &out,
+                                     PyArray_ClipmodeConverter,
+                                     &mode))
+        return NULL;
 
-	return _ARET(PyArray_TakeFrom(self, indices, dimension, out, mode));
+    return _ARET(PyArray_TakeFrom(self, indices, dimension, out, mode));
 }
 
 static PyObject *
 array_fill(PyArrayObject *self, PyObject *args)
 {
-	PyObject *obj;
-	if (!PyArg_ParseTuple(args, "O", &obj))
-		return NULL;
-	if (PyArray_FillWithScalar(self, obj) < 0) return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyObject *obj;
+    if (!PyArg_ParseTuple(args, "O", &obj))
+        return NULL;
+    if (PyArray_FillWithScalar(self, obj) < 0) return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 array_put(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *indices, *values;
-        NPY_CLIPMODE mode=NPY_RAISE;
-	static char *kwlist[] = {"indices", "values", "mode", NULL};
+    PyObject *indices, *values;
+    NPY_CLIPMODE mode=NPY_RAISE;
+    static char *kwlist[] = {"indices", "values", "mode", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O&", kwlist,
-					 &indices, &values,
-                                         PyArray_ClipmodeConverter,
-                                         &mode))
-		return NULL;
-	return PyArray_PutTo(self, values, indices, mode);
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O&", kwlist,
+                                     &indices, &values,
+                                     PyArray_ClipmodeConverter,
+                                     &mode))
+        return NULL;
+    return PyArray_PutTo(self, values, indices, mode);
 }
 
 static PyObject *
 array_reshape(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-        PyArray_Dims newshape;
-        PyObject *ret;
-	PyArray_ORDER order=PyArray_CORDER;
-	int n;
-
-	if (kwds != NULL) {
-		PyObject *ref;
-		ref = PyDict_GetItemString(kwds, "order");
-                if (ref == NULL) {
-                        PyErr_SetString(PyExc_TypeError, 
-                                        "invalid keyword argument");
-                        return NULL;
-                }
-		if ((PyArray_OrderConverter(ref, &order) == PY_FAIL))
-			return NULL;
-	}
-
-	n = PyTuple_Size(args);
-	if (n <= 1) {
-                if (PyTuple_GET_ITEM(args, 0) == Py_None)
-                        return PyArray_View(self, NULL, NULL);
-		if (!PyArg_ParseTuple(args, "O&", PyArray_IntpConverter,
-				      &newshape)) return NULL;
-	}
-        else {
-		if (!PyArray_IntpConverter(args, &newshape)) {
-			if (!PyErr_Occurred()) {
-				PyErr_SetString(PyExc_TypeError,
-						"invalid shape");
-			}
-			goto fail;
-		}
-	}
-	ret = PyArray_Newshape(self, &newshape, order);
-	PyDimMem_FREE(newshape.ptr);
-        return ret;
+    PyArray_Dims newshape;
+    PyObject *ret;
+    PyArray_ORDER order=PyArray_CORDER;
+    int n;
+
+    if (kwds != NULL) {
+        PyObject *ref;
+        ref = PyDict_GetItemString(kwds, "order");
+        if (ref == NULL) {
+            PyErr_SetString(PyExc_TypeError,
+                            "invalid keyword argument");
+            return NULL;
+        }
+        if ((PyArray_OrderConverter(ref, &order) == PY_FAIL))
+            return NULL;
+    }
+
+    n = PyTuple_Size(args);
+    if (n <= 1) {
+        if (PyTuple_GET_ITEM(args, 0) == Py_None)
+            return PyArray_View(self, NULL, NULL);
+        if (!PyArg_ParseTuple(args, "O&", PyArray_IntpConverter,
+                              &newshape)) return NULL;
+    }
+    else {
+        if (!PyArray_IntpConverter(args, &newshape)) {
+            if (!PyErr_Occurred()) {
+                PyErr_SetString(PyExc_TypeError,
+                                "invalid shape");
+            }
+            goto fail;
+        }
+    }
+    ret = PyArray_Newshape(self, &newshape, order);
+    PyDimMem_FREE(newshape.ptr);
+    return ret;
 
  fail:
-	PyDimMem_FREE(newshape.ptr);
-	return NULL;
+    PyDimMem_FREE(newshape.ptr);
+    return NULL;
 }
 
 static PyObject *
 array_squeeze(PyArrayObject *self, PyObject *args)
 {
-        if (!PyArg_ParseTuple(args, "")) return NULL;
-        return PyArray_Squeeze(self);
+    if (!PyArg_ParseTuple(args, "")) return NULL;
+    return PyArray_Squeeze(self);
 }
 
 static PyObject *
 array_view(PyArrayObject *self, PyObject *args)
 {
-	PyObject *otype=NULL;
-        PyArray_Descr *type=NULL;
+    PyObject *otype=NULL;
+    PyArray_Descr *type=NULL;
 
-	if (!PyArg_ParseTuple(args, "|O", &otype)) return NULL;
+    if (!PyArg_ParseTuple(args, "|O", &otype)) return NULL;
 
-	if (otype) {
-		if (PyType_Check(otype) &&			\
-		    PyType_IsSubtype((PyTypeObject *)otype,
-				     &PyArray_Type)) {
-			return PyArray_View(self, NULL,
-                                            (PyTypeObject *)otype);
-                }
-		else {
-			if (PyArray_DescrConverter(otype, &type) == PY_FAIL)
-				return NULL;
-		}
-	}
-	return PyArray_View(self, type, NULL);
+    if (otype) {
+        if (PyType_Check(otype) &&                      \
+            PyType_IsSubtype((PyTypeObject *)otype,
+                             &PyArray_Type)) {
+            return PyArray_View(self, NULL,
+                                (PyTypeObject *)otype);
+        }
+        else {
+            if (PyArray_DescrConverter(otype, &type) == PY_FAIL)
+                return NULL;
+        }
+    }
+    return PyArray_View(self, type, NULL);
 }
 
 static PyObject *
 array_argmax(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis,
-                                         PyArray_OutputConverter,
-                                         &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis,
+                                     PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return _ARET(PyArray_ArgMax(self, axis, out));
+    return _ARET(PyArray_ArgMax(self, axis, out));
 }
 
 static PyObject *
 array_argmin(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis,
-                                         PyArray_OutputConverter,
-                                         &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis,
+                                     PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return _ARET(PyArray_ArgMin(self, axis, out));
+    return _ARET(PyArray_ArgMin(self, axis, out));
 }
 
 static PyObject *
 array_max(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis,
-                                         PyArray_OutputConverter,
-                                         &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis,
+                                     PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return PyArray_Max(self, axis, out);
+    return PyArray_Max(self, axis, out);
 }
 
 static PyObject *
 array_ptp(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis,
-                                         PyArray_OutputConverter,
-                                         &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis,
+                                     PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return PyArray_Ptp(self, axis, out);
+    return PyArray_Ptp(self, axis, out);
 }
 
 
 static PyObject *
 array_min(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis,
-                                         PyArray_OutputConverter,
-                                         &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis,
+                                     PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return PyArray_Min(self, axis, out);
+    return PyArray_Min(self, axis, out);
 }
 
 static PyObject *
 array_swapaxes(PyArrayObject *self, PyObject *args)
 {
-	int axis1, axis2;
+    int axis1, axis2;
 
-	if (!PyArg_ParseTuple(args, "ii", &axis1, &axis2)) return NULL;
+    if (!PyArg_ParseTuple(args, "ii", &axis1, &axis2)) return NULL;
 
-	return PyArray_SwapAxes(self, axis1, axis2);
+    return PyArray_SwapAxes(self, axis1, axis2);
 }
 
 
 /* steals typed reference */
 /*OBJECT_API
- Get a subset of bytes from each element of the array
+  Get a subset of bytes from each element of the array
 */
 static PyObject *
 PyArray_GetField(PyArrayObject *self, PyArray_Descr *typed, int offset)
 {
-	PyObject *ret=NULL;
-
-	if (offset < 0 || (offset + typed->elsize) > self->descr->elsize) {
-		PyErr_Format(PyExc_ValueError,
-			     "Need 0 <= offset <= %d for requested type "  \
-			     "but received offset = %d",
-			     self->descr->elsize-typed->elsize, offset);
-		Py_DECREF(typed);
-		return NULL;
-	}
-	ret = PyArray_NewFromDescr(self->ob_type,
-				   typed,
-				   self->nd, self->dimensions,
-				   self->strides,
-				   self->data + offset,
-				   self->flags, (PyObject *)self);
-	if (ret == NULL) return NULL;
-	Py_INCREF(self);
-	((PyArrayObject *)ret)->base = (PyObject *)self;
-
-	PyArray_UpdateFlags((PyArrayObject *)ret, UPDATE_ALL);
-	return ret;
+    PyObject *ret=NULL;
+
+    if (offset < 0 || (offset + typed->elsize) > self->descr->elsize) {
+        PyErr_Format(PyExc_ValueError,
+                     "Need 0 <= offset <= %d for requested type "  \
+                     "but received offset = %d",
+                     self->descr->elsize-typed->elsize, offset);
+        Py_DECREF(typed);
+        return NULL;
+    }
+    ret = PyArray_NewFromDescr(self->ob_type,
+                               typed,
+                               self->nd, self->dimensions,
+                               self->strides,
+                               self->data + offset,
+                               self->flags, (PyObject *)self);
+    if (ret == NULL) return NULL;
+    Py_INCREF(self);
+    ((PyArrayObject *)ret)->base = (PyObject *)self;
+
+    PyArray_UpdateFlags((PyArrayObject *)ret, UPDATE_ALL);
+    return ret;
 }
 
 static PyObject *
 array_getfield(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
 
-        PyArray_Descr *dtype;
-	int offset = 0;
-	static char *kwlist[] = {"dtype", "offset", 0};
+    PyArray_Descr *dtype;
+    int offset = 0;
+    static char *kwlist[] = {"dtype", "offset", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|i", kwlist,
-					 PyArray_DescrConverter,
-					 &dtype, &offset)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|i", kwlist,
+                                     PyArray_DescrConverter,
+                                     &dtype, &offset)) return NULL;
 
-	return PyArray_GetField(self, dtype, offset);
+    return PyArray_GetField(self, dtype, offset);
 }
 
 
 /*OBJECT_API
- Set a subset of bytes from each element of the array
+  Set a subset of bytes from each element of the array
 */
 static int
 PyArray_SetField(PyArrayObject *self, PyArray_Descr *dtype,
-		 int offset, PyObject *val)
+                 int offset, PyObject *val)
 {
-	PyObject *ret=NULL;
-	int retval = 0;
-
-	if (offset < 0 || (offset + dtype->elsize) > self->descr->elsize) {
-		PyErr_Format(PyExc_ValueError,
-			     "Need 0 <= offset <= %d for requested type "  \
-			     "but received offset = %d",
-			     self->descr->elsize-dtype->elsize, offset);
-		Py_DECREF(dtype);
-		return -1;
-	}
-	ret = PyArray_NewFromDescr(self->ob_type,
-				   dtype, self->nd, self->dimensions,
-				   self->strides, self->data + offset,
-				   self->flags, (PyObject *)self);
-	if (ret == NULL) return -1;
-	Py_INCREF(self);
-	((PyArrayObject *)ret)->base = (PyObject *)self;
-
-	PyArray_UpdateFlags((PyArrayObject *)ret, UPDATE_ALL);
-	retval = PyArray_CopyObject((PyArrayObject *)ret, val);
-	Py_DECREF(ret);
-	return retval;
+    PyObject *ret=NULL;
+    int retval = 0;
+
+    if (offset < 0 || (offset + dtype->elsize) > self->descr->elsize) {
+        PyErr_Format(PyExc_ValueError,
+                     "Need 0 <= offset <= %d for requested type "  \
+                     "but received offset = %d",
+                     self->descr->elsize-dtype->elsize, offset);
+        Py_DECREF(dtype);
+        return -1;
+    }
+    ret = PyArray_NewFromDescr(self->ob_type,
+                               dtype, self->nd, self->dimensions,
+                               self->strides, self->data + offset,
+                               self->flags, (PyObject *)self);
+    if (ret == NULL) return -1;
+    Py_INCREF(self);
+    ((PyArrayObject *)ret)->base = (PyObject *)self;
+
+    PyArray_UpdateFlags((PyArrayObject *)ret, UPDATE_ALL);
+    retval = PyArray_CopyObject((PyArrayObject *)ret, val);
+    Py_DECREF(ret);
+    return retval;
 }
 
 static PyObject *
 array_setfield(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-        PyArray_Descr *dtype;
-	int offset = 0;
-	PyObject *value;
-	static char *kwlist[] = {"value", "dtype", "offset", 0};
+    PyArray_Descr *dtype;
+    int offset = 0;
+    PyObject *value;
+    static char *kwlist[] = {"value", "dtype", "offset", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&|i", kwlist,
-					 &value, PyArray_DescrConverter,
-					 &dtype, &offset)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&|i", kwlist,
+                                     &value, PyArray_DescrConverter,
+                                     &dtype, &offset)) return NULL;
 
-	if (PyArray_SetField(self, dtype, offset, value) < 0)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (PyArray_SetField(self, dtype, offset, value) < 0)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 /* This doesn't change the descriptor just the actual data...
@@ -325,80 +324,80 @@ array_setfield(PyArrayObject *self, PyObject *args, PyObject *kwds)
 static PyObject *
 PyArray_Byteswap(PyArrayObject *self, Bool inplace)
 {
-        PyArrayObject *ret;
-	intp size;
-	PyArray_CopySwapNFunc *copyswapn;
-	PyArrayIterObject *it;
-
-        copyswapn = self->descr->f->copyswapn;
-	if (inplace) {
-                if (!PyArray_ISWRITEABLE(self)) {
-                        PyErr_SetString(PyExc_RuntimeError,
-                                        "Cannot byte-swap in-place on a " \
-                                        "read-only array");
-                        return NULL;
-                }
-		size = PyArray_SIZE(self);
-		if (PyArray_ISONESEGMENT(self)) {
-			copyswapn(self->data, self->descr->elsize, NULL, -1, size, 1, self);
-		}
-		else { /* Use iterator */
-                        int axis = -1;
-                        intp stride;
-			it = (PyArrayIterObject *)                      \
-				PyArray_IterAllButAxis((PyObject *)self, &axis);
-                        stride = self->strides[axis];
-                        size = self->dimensions[axis];
-			while (it->index < it->size) {
-                                copyswapn(it->dataptr, stride, NULL, -1, size, 1, self);
-				PyArray_ITER_NEXT(it);
-			}
-			Py_DECREF(it);
-		}
-
-		Py_INCREF(self);
-		return (PyObject *)self;
-	}
-	else {
-                PyObject *new;
-		if ((ret = (PyArrayObject *)PyArray_NewCopy(self,-1)) == NULL)
-			return NULL;
-                new = PyArray_Byteswap(ret, TRUE);
-                Py_DECREF(new);
-		return (PyObject *)ret;
-	}
+    PyArrayObject *ret;
+    intp size;
+    PyArray_CopySwapNFunc *copyswapn;
+    PyArrayIterObject *it;
+
+    copyswapn = self->descr->f->copyswapn;
+    if (inplace) {
+        if (!PyArray_ISWRITEABLE(self)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "Cannot byte-swap in-place on a " \
+                            "read-only array");
+            return NULL;
+        }
+        size = PyArray_SIZE(self);
+        if (PyArray_ISONESEGMENT(self)) {
+            copyswapn(self->data, self->descr->elsize, NULL, -1, size, 1, self);
+        }
+        else { /* Use iterator */
+            int axis = -1;
+            intp stride;
+            it = (PyArrayIterObject *)                      \
+                PyArray_IterAllButAxis((PyObject *)self, &axis);
+            stride = self->strides[axis];
+            size = self->dimensions[axis];
+            while (it->index < it->size) {
+                copyswapn(it->dataptr, stride, NULL, -1, size, 1, self);
+                PyArray_ITER_NEXT(it);
+            }
+            Py_DECREF(it);
+        }
+
+        Py_INCREF(self);
+        return (PyObject *)self;
+    }
+    else {
+        PyObject *new;
+        if ((ret = (PyArrayObject *)PyArray_NewCopy(self,-1)) == NULL)
+            return NULL;
+        new = PyArray_Byteswap(ret, TRUE);
+        Py_DECREF(new);
+        return (PyObject *)ret;
+    }
 }
 
 
 static PyObject *
 array_byteswap(PyArrayObject *self, PyObject *args)
 {
-	Bool inplace=FALSE;
+    Bool inplace=FALSE;
 
-	if (!PyArg_ParseTuple(args, "|O&", PyArray_BoolConverter, &inplace))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "|O&", PyArray_BoolConverter, &inplace))
+        return NULL;
 
-	return PyArray_Byteswap(self, inplace);
+    return PyArray_Byteswap(self, inplace);
 }
 
 static PyObject *
 array_tolist(PyArrayObject *self, PyObject *args)
 {
-        if (!PyArg_ParseTuple(args, "")) return NULL;
-        return PyArray_ToList(self);
+    if (!PyArg_ParseTuple(args, "")) return NULL;
+    return PyArray_ToList(self);
 }
 
 
 static PyObject *
 array_tostring(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	NPY_ORDER order=NPY_CORDER;
-	static char *kwlist[] = {"order", NULL};
+    NPY_ORDER order=NPY_CORDER;
+    static char *kwlist[] = {"order", NULL};
 
-        if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
-					 PyArray_OrderConverter,
-					 &order)) return NULL;
-        return PyArray_ToString(self, order);
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
+                                     PyArray_OrderConverter,
+                                     &order)) return NULL;
+    return PyArray_ToString(self, order);
 }
 
 
@@ -408,264 +407,264 @@ array_tostring(PyArrayObject *self, PyObject *args, PyObject *kwds)
 static PyObject *
 array_tofile(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int ret;
-        PyObject *file;
-	FILE *fd;
-        char *sep="";
-	char *format="";
-	static char *kwlist[] = {"file", "sep", "format", NULL};
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|ss", kwlist,
-                                         &file, &sep, &format)) return NULL;
-
-	if (PyString_Check(file) || PyUnicode_Check(file)) {
-		file = PyObject_CallFunction((PyObject *)&PyFile_Type,
-					     "Os", file, "wb");
-		if (file==NULL) return NULL;
-	}
-	else {
-		Py_INCREF(file);
-	}
-	fd = PyFile_AsFile(file);
-	if (fd == NULL) {
-		PyErr_SetString(PyExc_IOError, "first argument must be a " \
-				"string or open file");
-		Py_DECREF(file);
-		return NULL;
-	}
-	ret = PyArray_ToFile(self, fd, sep, format);
-	Py_DECREF(file);
-	if (ret < 0) return NULL;
-        Py_INCREF(Py_None);
-        return Py_None;
+    int ret;
+    PyObject *file;
+    FILE *fd;
+    char *sep="";
+    char *format="";
+    static char *kwlist[] = {"file", "sep", "format", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|ss", kwlist,
+                                     &file, &sep, &format)) return NULL;
+
+    if (PyString_Check(file) || PyUnicode_Check(file)) {
+        file = PyObject_CallFunction((PyObject *)&PyFile_Type,
+                                     "Os", file, "wb");
+        if (file==NULL) return NULL;
+    }
+    else {
+        Py_INCREF(file);
+    }
+    fd = PyFile_AsFile(file);
+    if (fd == NULL) {
+        PyErr_SetString(PyExc_IOError, "first argument must be a " \
+                        "string or open file");
+        Py_DECREF(file);
+        return NULL;
+    }
+    ret = PyArray_ToFile(self, fd, sep, format);
+    Py_DECREF(file);
+    if (ret < 0) return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
 static PyObject *
 array_toscalar(PyArrayObject *self, PyObject *args) {
-        int n, nd;
-        n = PyTuple_GET_SIZE(args);
-        
-        if (n==1) {
-                PyObject *obj;
-                obj = PyTuple_GET_ITEM(args, 0);
-                if (PyTuple_Check(obj)) {
-                        args = obj;
-                        n = PyTuple_GET_SIZE(args);
-                }
+    int n, nd;
+    n = PyTuple_GET_SIZE(args);
+
+    if (n==1) {
+        PyObject *obj;
+        obj = PyTuple_GET_ITEM(args, 0);
+        if (PyTuple_Check(obj)) {
+            args = obj;
+            n = PyTuple_GET_SIZE(args);
         }
-        
-        if (n==0) {
-                if (self->nd == 0 || PyArray_SIZE(self) == 1)
-                        return self->descr->f->getitem(self->data, self);
-                else {
-                        PyErr_SetString(PyExc_ValueError, 
-                                        "can only convert an array "    \
-                                        " of size 1 to a Python scalar");
-                        return NULL;
-                }
+    }
+
+    if (n==0) {
+        if (self->nd == 0 || PyArray_SIZE(self) == 1)
+            return self->descr->f->getitem(self->data, self);
+        else {
+            PyErr_SetString(PyExc_ValueError,
+                            "can only convert an array "    \
+                            " of size 1 to a Python scalar");
+            return NULL;
         }
-        else if (n != self->nd && (n > 1 || self->nd==0)) {
-                PyErr_SetString(PyExc_ValueError, 
-                                "incorrect number of indices for "      \
-                                "array");
-                return NULL;
+    }
+    else if (n != self->nd && (n > 1 || self->nd==0)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "incorrect number of indices for "      \
+                        "array");
+        return NULL;
+    }
+    else if (n==1) { /* allows for flat getting as well as 1-d case */
+        intp value, loc, index, factor;
+        intp factors[MAX_DIMS];
+        value = PyArray_PyIntAsIntp(PyTuple_GET_ITEM(args, 0));
+        if (error_converting(value)) {
+            PyErr_SetString(PyExc_ValueError, "invalid integer");
+            return NULL;
         }
-        else if (n==1) { /* allows for flat getting as well as 1-d case */
-                intp value, loc, index, factor;
-                intp factors[MAX_DIMS];
-                value = PyArray_PyIntAsIntp(PyTuple_GET_ITEM(args, 0));
-                if (error_converting(value)) {
-                        PyErr_SetString(PyExc_ValueError, "invalid integer");
-                        return NULL;
-                }
-                factor = PyArray_SIZE(self);
-                if (value < 0) value += factor;
-                if ((value >= factor) || (value < 0)) {
-                        PyErr_SetString(PyExc_ValueError, 
-                                        "index out of bounds");
-                        return NULL;
-                }
-                if (self->nd == 1) {
-                        value *= self->strides[0];
-                        return self->descr->f->getitem(self->data + value,
-                                                       self);
-                }
-                nd = self->nd;
-                factor = 1;
-                while (nd--) {
-                        factors[nd] = factor;
-                        factor *= self->dimensions[nd];
-                }
-                loc = 0;
-                for (nd=0; nd < self->nd; nd++) {
-                        index = value / factors[nd];
-                        value = value % factors[nd];
-                        loc += self->strides[nd]*index;
-                }
-                
-                return self->descr->f->getitem(self->data + loc,
-                                               self);
-                
+        factor = PyArray_SIZE(self);
+        if (value < 0) value += factor;
+        if ((value >= factor) || (value < 0)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "index out of bounds");
+            return NULL;
         }
-        else {
-                intp loc, index[MAX_DIMS];
-                nd = PyArray_IntpFromSequence(args, index, MAX_DIMS);
-                if (nd < n) return NULL;
-                loc = 0;
-                while (nd--) {
-                        if (index[nd] < 0) 
-                                index[nd] += self->dimensions[nd];
-                        if (index[nd] < 0 || 
-                            index[nd] >= self->dimensions[nd]) {
-                                PyErr_SetString(PyExc_ValueError, 
-                                                "index out of bounds");
-                                return NULL;
-                        }
-                        loc += self->strides[nd]*index[nd];
-                }
-                return self->descr->f->getitem(self->data + loc, self);
+        if (self->nd == 1) {
+            value *= self->strides[0];
+            return self->descr->f->getitem(self->data + value,
+                                           self);
+        }
+        nd = self->nd;
+        factor = 1;
+        while (nd--) {
+            factors[nd] = factor;
+            factor *= self->dimensions[nd];
+        }
+        loc = 0;
+        for (nd=0; nd < self->nd; nd++) {
+            index = value / factors[nd];
+            value = value % factors[nd];
+            loc += self->strides[nd]*index;
+        }
+
+        return self->descr->f->getitem(self->data + loc,
+                                       self);
+
+    }
+    else {
+        intp loc, index[MAX_DIMS];
+        nd = PyArray_IntpFromSequence(args, index, MAX_DIMS);
+        if (nd < n) return NULL;
+        loc = 0;
+        while (nd--) {
+            if (index[nd] < 0)
+                index[nd] += self->dimensions[nd];
+            if (index[nd] < 0 ||
+                index[nd] >= self->dimensions[nd]) {
+                PyErr_SetString(PyExc_ValueError,
+                                "index out of bounds");
+                return NULL;
+            }
+            loc += self->strides[nd]*index[nd];
         }
+        return self->descr->f->getitem(self->data + loc, self);
+    }
 }
 
 static PyObject *
 array_setscalar(PyArrayObject *self, PyObject *args) {
-        int n, nd;
-        int ret = -1;
-        PyObject *obj;
-        n = PyTuple_GET_SIZE(args)-1;
-        
-        if (n < 0) {
-                PyErr_SetString(PyExc_ValueError, 
-                                "itemset must have at least one argument");
-                return NULL;
+    int n, nd;
+    int ret = -1;
+    PyObject *obj;
+    n = PyTuple_GET_SIZE(args)-1;
+
+    if (n < 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "itemset must have at least one argument");
+        return NULL;
+    }
+    obj = PyTuple_GET_ITEM(args, n);
+    if (n==0) {
+        if (self->nd == 0 || PyArray_SIZE(self) == 1) {
+            ret = self->descr->f->setitem(obj, self->data, self);
         }
-        obj = PyTuple_GET_ITEM(args, n);
-        if (n==0) {
-                if (self->nd == 0 || PyArray_SIZE(self) == 1) {
-                        ret = self->descr->f->setitem(obj, self->data, self);
-                }                
-                else {
-                        PyErr_SetString(PyExc_ValueError, 
-                                        "can only place a scalar for an "
-                                        " array of size 1");
-                        return NULL;
-                }
+        else {
+            PyErr_SetString(PyExc_ValueError,
+                            "can only place a scalar for an "
+                            " array of size 1");
+            return NULL;
         }
-        else if (n != self->nd && (n > 1 || self->nd==0)) {
-                PyErr_SetString(PyExc_ValueError, 
-                                "incorrect number of indices for "      \
-                                "array");
-                return NULL;
+    }
+    else if (n != self->nd && (n > 1 || self->nd==0)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "incorrect number of indices for "      \
+                        "array");
+        return NULL;
+    }
+    else if (n==1) { /* allows for flat setting as well as 1-d case */
+        intp value, loc, index, factor;
+        intp factors[MAX_DIMS];
+        PyObject *indobj;
+
+        indobj = PyTuple_GET_ITEM(args, 0);
+        if (PyTuple_Check(indobj)) {
+            PyObject *res;
+            PyObject *newargs;
+            PyObject *tmp;
+            int i, nn;
+            nn = PyTuple_GET_SIZE(indobj);
+            newargs = PyTuple_New(nn+1);
+            Py_INCREF(obj);
+            for (i=0; i<nn; i++) {
+                tmp = PyTuple_GET_ITEM(indobj, i);
+                Py_INCREF(tmp);
+                PyTuple_SET_ITEM(newargs, i, tmp);
+            }
+            PyTuple_SET_ITEM(newargs, nn, obj);
+            /* Call with a converted set of arguments */
+            res = array_setscalar(self, newargs);
+            Py_DECREF(newargs);
+            return res;
         }
-        else if (n==1) { /* allows for flat setting as well as 1-d case */
-                intp value, loc, index, factor;
-                intp factors[MAX_DIMS];
-                PyObject *indobj;
-
-                indobj = PyTuple_GET_ITEM(args, 0);
-                if (PyTuple_Check(indobj)) {
-                        PyObject *res;
-                        PyObject *newargs;
-                        PyObject *tmp;
-                        int i, nn;
-                        nn = PyTuple_GET_SIZE(indobj);
-                        newargs = PyTuple_New(nn+1);
-                        Py_INCREF(obj);
-                        for (i=0; i<nn; i++) {
-                                tmp = PyTuple_GET_ITEM(indobj, i);
-                                Py_INCREF(tmp);
-                                PyTuple_SET_ITEM(newargs, i, tmp);
-                        }
-                        PyTuple_SET_ITEM(newargs, nn, obj);
-                        /* Call with a converted set of arguments */
-                        res = array_setscalar(self, newargs);
-                        Py_DECREF(newargs);
-                        return res;
-                }
-                value = PyArray_PyIntAsIntp(indobj);
-                if (error_converting(value)) {
-                        PyErr_SetString(PyExc_ValueError, "invalid integer");
-                        return NULL;
-                }
-                if (value >= PyArray_SIZE(self)) {
-                        PyErr_SetString(PyExc_ValueError, 
-                                        "index out of bounds");
-                        return NULL;
-                }
-                if (self->nd == 1) {
-                        value *= self->strides[0];
-                        ret = self->descr->f->setitem(obj, self->data + value, 
-                                                      self);
-                        goto finish;
-                }
-                nd = self->nd;
-                factor = 1;
-                while (nd--) {
-                        factors[nd] = factor;
-                        factor *= self->dimensions[nd];
-                }
-                loc = 0;
-                for (nd=0; nd < self->nd; nd++) {
-                        index = value / factors[nd];
-                        value = value % factors[nd];
-                        loc += self->strides[nd]*index;
-                }
-                
-                ret = self->descr->f->setitem(obj, self->data + loc, self);
+        value = PyArray_PyIntAsIntp(indobj);
+        if (error_converting(value)) {
+            PyErr_SetString(PyExc_ValueError, "invalid integer");
+            return NULL;
         }
-        else {
-                intp loc, index[MAX_DIMS];
-                PyObject *tupargs;
-                tupargs = PyTuple_GetSlice(args, 0, n);
-                nd = PyArray_IntpFromSequence(tupargs, index, MAX_DIMS);
-                Py_DECREF(tupargs);
-                if (nd < n) return NULL;
-                loc = 0;
-                while (nd--) {
-                        if (index[nd] < 0) 
-                                index[nd] += self->dimensions[nd];
-                        if (index[nd] < 0 || 
-                            index[nd] >= self->dimensions[nd]) {
-                                PyErr_SetString(PyExc_ValueError, 
-                                                "index out of bounds");
-                                return NULL;
-                        }
-                        loc += self->strides[nd]*index[nd];
-                }
-                ret = self->descr->f->setitem(obj, self->data + loc, self);
+        if (value >= PyArray_SIZE(self)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "index out of bounds");
+            return NULL;
+        }
+        if (self->nd == 1) {
+            value *= self->strides[0];
+            ret = self->descr->f->setitem(obj, self->data + value,
+                                          self);
+            goto finish;
+        }
+        nd = self->nd;
+        factor = 1;
+        while (nd--) {
+            factors[nd] = factor;
+            factor *= self->dimensions[nd];
         }
+        loc = 0;
+        for (nd=0; nd < self->nd; nd++) {
+            index = value / factors[nd];
+            value = value % factors[nd];
+            loc += self->strides[nd]*index;
+        }
+
+        ret = self->descr->f->setitem(obj, self->data + loc, self);
+    }
+    else {
+        intp loc, index[MAX_DIMS];
+        PyObject *tupargs;
+        tupargs = PyTuple_GetSlice(args, 0, n);
+        nd = PyArray_IntpFromSequence(tupargs, index, MAX_DIMS);
+        Py_DECREF(tupargs);
+        if (nd < n) return NULL;
+        loc = 0;
+        while (nd--) {
+            if (index[nd] < 0)
+                index[nd] += self->dimensions[nd];
+            if (index[nd] < 0 ||
+                index[nd] >= self->dimensions[nd]) {
+                PyErr_SetString(PyExc_ValueError,
+                                "index out of bounds");
+                return NULL;
+            }
+            loc += self->strides[nd]*index[nd];
+        }
+        ret = self->descr->f->setitem(obj, self->data + loc, self);
+    }
 
  finish:
-        if (ret < 0) return NULL;
-        Py_INCREF(Py_None);
-        return Py_None;
+    if (ret < 0) return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
 static PyObject *
 array_cast(PyArrayObject *self, PyObject *args)
 {
-	PyArray_Descr *descr=NULL;
-	PyObject *obj;
-
-        if (!PyArg_ParseTuple(args, "O&", PyArray_DescrConverter,
-			      &descr)) return NULL;
-
-	if (descr == self->descr) {
-		obj = _ARET(PyArray_NewCopy(self,NPY_ANYORDER));
-		Py_XDECREF(descr);
-		return obj;
-	}
-	if (descr->names != NULL) {
-                int flags;
-                flags = NPY_FORCECAST;
-                if (PyArray_ISFORTRAN(self)) {
-                        flags |= NPY_FORTRAN;
-                }
-		return PyArray_FromArray(self, descr, flags);
-	}
-	return PyArray_CastToType(self, descr, PyArray_ISFORTRAN(self));
+    PyArray_Descr *descr=NULL;
+    PyObject *obj;
+
+    if (!PyArg_ParseTuple(args, "O&", PyArray_DescrConverter,
+                          &descr)) return NULL;
+
+    if (descr == self->descr) {
+        obj = _ARET(PyArray_NewCopy(self,NPY_ANYORDER));
+        Py_XDECREF(descr);
+        return obj;
+    }
+    if (descr->names != NULL) {
+        int flags;
+        flags = NPY_FORCECAST;
+        if (PyArray_ISFORTRAN(self)) {
+            flags |= NPY_FORTRAN;
+        }
+        return PyArray_FromArray(self, descr, flags);
+    }
+    return PyArray_CastToType(self, descr, PyArray_ISFORTRAN(self));
 }
 
 /* default sub-type implementation */
@@ -674,321 +673,321 @@ array_cast(PyArrayObject *self, PyObject *args)
 static PyObject *
 array_wraparray(PyArrayObject *self, PyObject *args)
 {
-	PyObject *arr;
-	PyObject *ret;
-
-	if (PyTuple_Size(args) < 1) {
-		PyErr_SetString(PyExc_TypeError,
-				"only accepts 1 argument");
-		return NULL;
-	}
-	arr = PyTuple_GET_ITEM(args, 0);
-	if (!PyArray_Check(arr)) {
-		PyErr_SetString(PyExc_TypeError,
-				"can only be called with ndarray object");
-		return NULL;
-	}
-
-	Py_INCREF(PyArray_DESCR(arr));
-	ret = PyArray_NewFromDescr(self->ob_type,
-				   PyArray_DESCR(arr),
-				   PyArray_NDIM(arr),
-				   PyArray_DIMS(arr),
-				   PyArray_STRIDES(arr), PyArray_DATA(arr),
-				   PyArray_FLAGS(arr), (PyObject *)self);
-	if (ret == NULL) return NULL;
-	Py_INCREF(arr);
-	PyArray_BASE(ret) = arr;
-	return ret;
+    PyObject *arr;
+    PyObject *ret;
+
+    if (PyTuple_Size(args) < 1) {
+        PyErr_SetString(PyExc_TypeError,
+                        "only accepts 1 argument");
+        return NULL;
+    }
+    arr = PyTuple_GET_ITEM(args, 0);
+    if (!PyArray_Check(arr)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "can only be called with ndarray object");
+        return NULL;
+    }
+
+    Py_INCREF(PyArray_DESCR(arr));
+    ret = PyArray_NewFromDescr(self->ob_type,
+                               PyArray_DESCR(arr),
+                               PyArray_NDIM(arr),
+                               PyArray_DIMS(arr),
+                               PyArray_STRIDES(arr), PyArray_DATA(arr),
+                               PyArray_FLAGS(arr), (PyObject *)self);
+    if (ret == NULL) return NULL;
+    Py_INCREF(arr);
+    PyArray_BASE(ret) = arr;
+    return ret;
 }
 
 
 static PyObject *
 array_getarray(PyArrayObject *self, PyObject *args)
 {
-	PyArray_Descr *newtype=NULL;
-	PyObject *ret;
-
-	if (!PyArg_ParseTuple(args, "|O&", PyArray_DescrConverter,
-			      &newtype)) return NULL;
-
-	/* convert to PyArray_Type */
-	if (!PyArray_CheckExact(self)) {
-		PyObject *new;
-		PyTypeObject *subtype = &PyArray_Type;
-
-		if (!PyType_IsSubtype(self->ob_type, &PyArray_Type)) {
-			subtype = &PyArray_Type;
-		}
-
-		Py_INCREF(PyArray_DESCR(self));
-		new = PyArray_NewFromDescr(subtype,
-					   PyArray_DESCR(self),
-					   PyArray_NDIM(self),
-					   PyArray_DIMS(self),
-					   PyArray_STRIDES(self),
-					   PyArray_DATA(self),
-					   PyArray_FLAGS(self), NULL);
-		if (new == NULL) return NULL;
-		Py_INCREF(self);
-		PyArray_BASE(new) = (PyObject *)self;
-		self = (PyArrayObject *)new;
-	}
-	else {
-		Py_INCREF(self);
-	}
-
-	if ((newtype == NULL) || \
-	    PyArray_EquivTypes(self->descr, newtype)) {
-		return (PyObject *)self;
-	}
-	else {
-		ret = PyArray_CastToType(self, newtype, 0);
-		Py_DECREF(self);
-		return ret;
-	}
+    PyArray_Descr *newtype=NULL;
+    PyObject *ret;
+
+    if (!PyArg_ParseTuple(args, "|O&", PyArray_DescrConverter,
+                          &newtype)) return NULL;
+
+    /* convert to PyArray_Type */
+    if (!PyArray_CheckExact(self)) {
+        PyObject *new;
+        PyTypeObject *subtype = &PyArray_Type;
+
+        if (!PyType_IsSubtype(self->ob_type, &PyArray_Type)) {
+            subtype = &PyArray_Type;
+        }
+
+        Py_INCREF(PyArray_DESCR(self));
+        new = PyArray_NewFromDescr(subtype,
+                                   PyArray_DESCR(self),
+                                   PyArray_NDIM(self),
+                                   PyArray_DIMS(self),
+                                   PyArray_STRIDES(self),
+                                   PyArray_DATA(self),
+                                   PyArray_FLAGS(self), NULL);
+        if (new == NULL) return NULL;
+        Py_INCREF(self);
+        PyArray_BASE(new) = (PyObject *)self;
+        self = (PyArrayObject *)new;
+    }
+    else {
+        Py_INCREF(self);
+    }
+
+    if ((newtype == NULL) || \
+        PyArray_EquivTypes(self->descr, newtype)) {
+        return (PyObject *)self;
+    }
+    else {
+        ret = PyArray_CastToType(self, newtype, 0);
+        Py_DECREF(self);
+        return ret;
+    }
 }
 
 
 static PyObject *
 array_copy(PyArrayObject *self, PyObject *args)
 {
-	PyArray_ORDER fortran=PyArray_CORDER;
-        if (!PyArg_ParseTuple(args, "|O&", PyArray_OrderConverter,
-			      &fortran)) return NULL;
+    PyArray_ORDER fortran=PyArray_CORDER;
+    if (!PyArg_ParseTuple(args, "|O&", PyArray_OrderConverter,
+                          &fortran)) return NULL;
 
-        return PyArray_NewCopy(self, fortran);
+    return PyArray_NewCopy(self, fortran);
 }
 
 
 static PyObject *
 array_resize(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-        PyArray_Dims newshape;
-        PyObject *ret;
-	int n;
-	int refcheck = 1;
-	PyArray_ORDER fortran=PyArray_ANYORDER;
-
-	if (kwds != NULL) {
-		PyObject *ref;
-		ref = PyDict_GetItemString(kwds, "refcheck");
-		if (ref) {
-			refcheck = PyInt_AsLong(ref);
-			if (refcheck==-1 && PyErr_Occurred()) {
-				return NULL;
-			}
-		}
-		ref = PyDict_GetItemString(kwds, "order");
-		if (ref != NULL ||
-		    (PyArray_OrderConverter(ref, &fortran) == PY_FAIL))
-			return NULL;
-	}
-	n = PyTuple_Size(args);
-	if (n <= 1) {
-                if (PyTuple_GET_ITEM(args, 0) == Py_None) {
-                        Py_INCREF(Py_None);
-                        return Py_None;
-                }
-		if (!PyArg_ParseTuple(args, "O&", PyArray_IntpConverter,
-				      &newshape)) return NULL;
-	}
-        else {
-		if (!PyArray_IntpConverter(args, &newshape)) {
-			if (!PyErr_Occurred()) {
-				PyErr_SetString(PyExc_TypeError,
-						"invalid shape");
-			}
-			return NULL;
-		}
-	}
-	ret = PyArray_Resize(self, &newshape, refcheck, fortran);
-        PyDimMem_FREE(newshape.ptr);
-        if (ret == NULL) return NULL;
-	Py_DECREF(ret);
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyArray_Dims newshape;
+    PyObject *ret;
+    int n;
+    int refcheck = 1;
+    PyArray_ORDER fortran=PyArray_ANYORDER;
+
+    if (kwds != NULL) {
+        PyObject *ref;
+        ref = PyDict_GetItemString(kwds, "refcheck");
+        if (ref) {
+            refcheck = PyInt_AsLong(ref);
+            if (refcheck==-1 && PyErr_Occurred()) {
+                return NULL;
+            }
+        }
+        ref = PyDict_GetItemString(kwds, "order");
+        if (ref != NULL ||
+            (PyArray_OrderConverter(ref, &fortran) == PY_FAIL))
+            return NULL;
+    }
+    n = PyTuple_Size(args);
+    if (n <= 1) {
+        if (PyTuple_GET_ITEM(args, 0) == Py_None) {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+        if (!PyArg_ParseTuple(args, "O&", PyArray_IntpConverter,
+                              &newshape)) return NULL;
+    }
+    else {
+        if (!PyArray_IntpConverter(args, &newshape)) {
+            if (!PyErr_Occurred()) {
+                PyErr_SetString(PyExc_TypeError,
+                                "invalid shape");
+            }
+            return NULL;
+        }
+    }
+    ret = PyArray_Resize(self, &newshape, refcheck, fortran);
+    PyDimMem_FREE(newshape.ptr);
+    if (ret == NULL) return NULL;
+    Py_DECREF(ret);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 array_repeat(PyArrayObject *self, PyObject *args, PyObject *kwds) {
-	PyObject *repeats;
-	int axis=MAX_DIMS;
-	static char *kwlist[] = {"repeats", "axis", NULL};
+    PyObject *repeats;
+    int axis=MAX_DIMS;
+    static char *kwlist[] = {"repeats", "axis", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&", kwlist,
-					 &repeats, PyArray_AxisConverter,
-					 &axis)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&", kwlist,
+                                     &repeats, PyArray_AxisConverter,
+                                     &axis)) return NULL;
 
-	return _ARET(PyArray_Repeat(self, repeats, axis));
+    return _ARET(PyArray_Repeat(self, repeats, axis));
 }
 
 static PyObject *
 array_choose(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *choices;
-	int n;
-        PyArrayObject *out=NULL;
-        NPY_CLIPMODE clipmode=NPY_RAISE;
-
-	n = PyTuple_Size(args);
-	if (n <= 1) {
-		if (!PyArg_ParseTuple(args, "O", &choices))
-			return NULL;
-	}
-        else {
-		choices = args;
-	}
-        if (kwds && PyDict_Check(kwds)) {
-                if (PyArray_OutputConverter(PyDict_GetItemString(kwds,
-                                                                 "out"),
-                                            &out) == PY_FAIL)
-                        return NULL;
-                if (PyArray_ClipmodeConverter(PyDict_GetItemString(kwds,
-                                                                   "mode"),
-                                              &clipmode) == PY_FAIL)
-                        return NULL;
-        }
+    PyObject *choices;
+    int n;
+    PyArrayObject *out=NULL;
+    NPY_CLIPMODE clipmode=NPY_RAISE;
+
+    n = PyTuple_Size(args);
+    if (n <= 1) {
+        if (!PyArg_ParseTuple(args, "O", &choices))
+            return NULL;
+    }
+    else {
+        choices = args;
+    }
+    if (kwds && PyDict_Check(kwds)) {
+        if (PyArray_OutputConverter(PyDict_GetItemString(kwds,
+                                                         "out"),
+                                    &out) == PY_FAIL)
+            return NULL;
+        if (PyArray_ClipmodeConverter(PyDict_GetItemString(kwds,
+                                                           "mode"),
+                                      &clipmode) == PY_FAIL)
+            return NULL;
+    }
 
-	return _ARET(PyArray_Choose(self, choices, out, clipmode));
+    return _ARET(PyArray_Choose(self, choices, out, clipmode));
 }
 
 static PyObject *
 array_sort(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=-1;
-	int val;
-	PyArray_SORTKIND which=PyArray_QUICKSORT;
-        PyObject *order=NULL;
-        PyArray_Descr *saved=NULL;
-        PyArray_Descr *newd;
-        static char *kwlist[] = {"axis", "kind", "order", NULL};
-        
-        if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&O", kwlist, &axis,
-                                         PyArray_SortkindConverter, &which,
-                                         &order))
-                return NULL;
-
-        if (order == Py_None) order = NULL;
-        if (order != NULL) {
-                PyObject *new_name;
-                PyObject *_numpy_internal;
-                saved = self->descr;
-                if (saved->names == NULL) {
-                        PyErr_SetString(PyExc_ValueError, "Cannot specify " \
-                                        "order when the array has no fields.");
-                        return NULL;
-                }
-                _numpy_internal = PyImport_ImportModule("numpy.core._internal");
-                if (_numpy_internal == NULL) return NULL;
-                new_name = PyObject_CallMethod(_numpy_internal, "_newnames",
-                                               "OO", saved, order);
-                Py_DECREF(_numpy_internal);
-                if (new_name == NULL) return NULL;
-                newd = PyArray_DescrNew(saved);
-                newd->names = new_name;
-                self->descr = newd;
-        }
-
-        val = PyArray_Sort(self, axis, which);
-        if (order != NULL) {
-                Py_XDECREF(self->descr);
-                self->descr = saved;
+    int axis=-1;
+    int val;
+    PyArray_SORTKIND which=PyArray_QUICKSORT;
+    PyObject *order=NULL;
+    PyArray_Descr *saved=NULL;
+    PyArray_Descr *newd;
+    static char *kwlist[] = {"axis", "kind", "order", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&O", kwlist, &axis,
+                                     PyArray_SortkindConverter, &which,
+                                     &order))
+        return NULL;
+
+    if (order == Py_None) order = NULL;
+    if (order != NULL) {
+        PyObject *new_name;
+        PyObject *_numpy_internal;
+        saved = self->descr;
+        if (saved->names == NULL) {
+            PyErr_SetString(PyExc_ValueError, "Cannot specify " \
+                            "order when the array has no fields.");
+            return NULL;
         }
-        if (val < 0) return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+        _numpy_internal = PyImport_ImportModule("numpy.core._internal");
+        if (_numpy_internal == NULL) return NULL;
+        new_name = PyObject_CallMethod(_numpy_internal, "_newnames",
+                                       "OO", saved, order);
+        Py_DECREF(_numpy_internal);
+        if (new_name == NULL) return NULL;
+        newd = PyArray_DescrNew(saved);
+        newd->names = new_name;
+        self->descr = newd;
+    }
+
+    val = PyArray_Sort(self, axis, which);
+    if (order != NULL) {
+        Py_XDECREF(self->descr);
+        self->descr = saved;
+    }
+    if (val < 0) return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 array_argsort(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=-1;
-	PyArray_SORTKIND which=PyArray_QUICKSORT;
-        PyObject *order=NULL, *res;
-        PyArray_Descr *newd, *saved=NULL;
-	static char *kwlist[] = {"axis", "kind", "order", NULL};
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O", kwlist, 
-                                         PyArray_AxisConverter, &axis,
-					 PyArray_SortkindConverter, &which,
-                                         &order))
-		return NULL;
-
-        if (order == Py_None) order = NULL;
-        if (order != NULL) {
-                PyObject *new_name;
-                PyObject *_numpy_internal;
-                saved = self->descr;
-                if (saved->names == NULL) {
-                        PyErr_SetString(PyExc_ValueError, "Cannot specify " \
-                                        "order when the array has no fields.");
-                        return NULL;
-                }
-                _numpy_internal = PyImport_ImportModule("numpy.core._internal");
-                if (_numpy_internal == NULL) return NULL;
-                new_name = PyObject_CallMethod(_numpy_internal, "_newnames",
-                                               "OO", saved, order);
-                Py_DECREF(_numpy_internal);
-                if (new_name == NULL) return NULL;
-                newd = PyArray_DescrNew(saved);
-                newd->names = new_name;
-                self->descr = newd;
-        }
-
-        res = PyArray_ArgSort(self, axis, which);
-        if (order != NULL) {
-                Py_XDECREF(self->descr);
-                self->descr = saved;
+    int axis=-1;
+    PyArray_SORTKIND which=PyArray_QUICKSORT;
+    PyObject *order=NULL, *res;
+    PyArray_Descr *newd, *saved=NULL;
+    static char *kwlist[] = {"axis", "kind", "order", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O", kwlist,
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_SortkindConverter, &which,
+                                     &order))
+        return NULL;
+
+    if (order == Py_None) order = NULL;
+    if (order != NULL) {
+        PyObject *new_name;
+        PyObject *_numpy_internal;
+        saved = self->descr;
+        if (saved->names == NULL) {
+            PyErr_SetString(PyExc_ValueError, "Cannot specify " \
+                            "order when the array has no fields.");
+            return NULL;
         }
-        return _ARET(res);
+        _numpy_internal = PyImport_ImportModule("numpy.core._internal");
+        if (_numpy_internal == NULL) return NULL;
+        new_name = PyObject_CallMethod(_numpy_internal, "_newnames",
+                                       "OO", saved, order);
+        Py_DECREF(_numpy_internal);
+        if (new_name == NULL) return NULL;
+        newd = PyArray_DescrNew(saved);
+        newd->names = new_name;
+        self->descr = newd;
+    }
+
+    res = PyArray_ArgSort(self, axis, which);
+    if (order != NULL) {
+        Py_XDECREF(self->descr);
+        self->descr = saved;
+    }
+    return _ARET(res);
 }
 
 static PyObject *
 array_searchsorted(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-        static char *kwlist[] = {"keys", "side", NULL};
-	PyObject *keys;
-        NPY_SEARCHSIDE side = NPY_SEARCHLEFT;
+    static char *kwlist[] = {"keys", "side", NULL};
+    PyObject *keys;
+    NPY_SEARCHSIDE side = NPY_SEARCHLEFT;
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:searchsorted",
-                                         kwlist, &keys,
-                                         PyArray_SearchsideConverter, &side))
-                return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:searchsorted",
+                                     kwlist, &keys,
+                                     PyArray_SearchsideConverter, &side))
+        return NULL;
 
-	return _ARET(PyArray_SearchSorted(self, keys, side));
+    return _ARET(PyArray_SearchSorted(self, keys, side));
 }
 
 static void
 _deepcopy_call(char *iptr, char *optr, PyArray_Descr *dtype,
-	       PyObject *deepcopy, PyObject *visit)
+               PyObject *deepcopy, PyObject *visit)
 {
-	if (!PyDataType_REFCHK(dtype)) return;
-	else if (PyDescr_HASFIELDS(dtype)) {
-                PyObject *key, *value, *title=NULL;
-                PyArray_Descr *new;
-                int offset;
-                Py_ssize_t pos=0;
-                while (PyDict_Next(dtype->fields, &pos, &key, &value)) {
- 			if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
-					      &title)) return;
-                        _deepcopy_call(iptr + offset, optr + offset, new,
-				       deepcopy, visit);
-                }
+    if (!PyDataType_REFCHK(dtype)) return;
+    else if (PyDescr_HASFIELDS(dtype)) {
+        PyObject *key, *value, *title=NULL;
+        PyArray_Descr *new;
+        int offset;
+        Py_ssize_t pos=0;
+        while (PyDict_Next(dtype->fields, &pos, &key, &value)) {
+            if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
+                                  &title)) return;
+            _deepcopy_call(iptr + offset, optr + offset, new,
+                           deepcopy, visit);
         }
-        else {
-		PyObject **itemp, **otemp;
-		PyObject *res;
-		itemp = (PyObject **)iptr;
-		otemp = (PyObject **)optr;
-		Py_XINCREF(*itemp);
-		/* call deepcopy on this argument */
-		res = PyObject_CallFunctionObjArgs(deepcopy,
-						   *itemp, visit, NULL);
-		Py_XDECREF(*itemp);
-		Py_XDECREF(*otemp);
-		*otemp = res;
-	}
+    }
+    else {
+        PyObject **itemp, **otemp;
+        PyObject *res;
+        itemp = (PyObject **)iptr;
+        otemp = (PyObject **)optr;
+        Py_XINCREF(*itemp);
+        /* call deepcopy on this argument */
+        res = PyObject_CallFunctionObjArgs(deepcopy,
+                                           *itemp, visit, NULL);
+        Py_XDECREF(*itemp);
+        Py_XDECREF(*otemp);
+        *otemp = res;
+    }
 
 }
 
@@ -996,148 +995,148 @@ _deepcopy_call(char *iptr, char *optr, PyArray_Descr *dtype,
 static PyObject *
 array_deepcopy(PyArrayObject *self, PyObject *args)
 {
-        PyObject* visit;
-	char *optr;
-        PyArrayIterObject *it;
-        PyObject *copy, *ret, *deepcopy;
-
-        if (!PyArg_ParseTuple(args, "O", &visit)) return NULL;
-        ret = PyArray_Copy(self);
-        if (PyDataType_REFCHK(self->descr)) {
-                copy = PyImport_ImportModule("copy");
-                if (copy == NULL) return NULL;
-                deepcopy = PyObject_GetAttrString(copy, "deepcopy");
-                Py_DECREF(copy);
-                if (deepcopy == NULL) return NULL;
-                it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
-                if (it == NULL) {Py_DECREF(deepcopy); return NULL;}
-                optr = PyArray_DATA(ret);
-                while(it->index < it->size) {
-			_deepcopy_call(it->dataptr, optr, self->descr,
-				       deepcopy, visit);
-			optr += self->descr->elsize;
-                        PyArray_ITER_NEXT(it);
-                }
-                Py_DECREF(deepcopy);
-                Py_DECREF(it);
+    PyObject* visit;
+    char *optr;
+    PyArrayIterObject *it;
+    PyObject *copy, *ret, *deepcopy;
+
+    if (!PyArg_ParseTuple(args, "O", &visit)) return NULL;
+    ret = PyArray_Copy(self);
+    if (PyDataType_REFCHK(self->descr)) {
+        copy = PyImport_ImportModule("copy");
+        if (copy == NULL) return NULL;
+        deepcopy = PyObject_GetAttrString(copy, "deepcopy");
+        Py_DECREF(copy);
+        if (deepcopy == NULL) return NULL;
+        it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
+        if (it == NULL) {Py_DECREF(deepcopy); return NULL;}
+        optr = PyArray_DATA(ret);
+        while(it->index < it->size) {
+            _deepcopy_call(it->dataptr, optr, self->descr,
+                           deepcopy, visit);
+            optr += self->descr->elsize;
+            PyArray_ITER_NEXT(it);
         }
-        return _ARET(ret);
+        Py_DECREF(deepcopy);
+        Py_DECREF(it);
+    }
+    return _ARET(ret);
 }
 
 /* Convert Array to flat list (using getitem) */
 static PyObject *
 _getlist_pkl(PyArrayObject *self)
 {
-	PyObject *theobject;
-	PyArrayIterObject *iter=NULL;
-	PyObject *list;
-	PyArray_GetItemFunc *getitem;
-
-	getitem = self->descr->f->getitem;
-	iter = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
-	if (iter == NULL) return NULL;
-	list = PyList_New(iter->size);
-	if (list == NULL) {Py_DECREF(iter); return NULL;}
-	while (iter->index < iter->size) {
-		theobject = getitem(iter->dataptr, self);
-		PyList_SET_ITEM(list, (int) iter->index, theobject);
-		PyArray_ITER_NEXT(iter);
-	}
-	Py_DECREF(iter);
-	return list;
+    PyObject *theobject;
+    PyArrayIterObject *iter=NULL;
+    PyObject *list;
+    PyArray_GetItemFunc *getitem;
+
+    getitem = self->descr->f->getitem;
+    iter = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
+    if (iter == NULL) return NULL;
+    list = PyList_New(iter->size);
+    if (list == NULL) {Py_DECREF(iter); return NULL;}
+    while (iter->index < iter->size) {
+        theobject = getitem(iter->dataptr, self);
+        PyList_SET_ITEM(list, (int) iter->index, theobject);
+        PyArray_ITER_NEXT(iter);
+    }
+    Py_DECREF(iter);
+    return list;
 }
 
 static int
 _setlist_pkl(PyArrayObject *self, PyObject *list)
 {
-	PyObject *theobject;
-	PyArrayIterObject *iter=NULL;
-	PyArray_SetItemFunc *setitem;
+    PyObject *theobject;
+    PyArrayIterObject *iter=NULL;
+    PyArray_SetItemFunc *setitem;
 
-	setitem = self->descr->f->setitem;
-	iter = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
-	if (iter == NULL) return -1;
-	while(iter->index < iter->size) {
-		theobject = PyList_GET_ITEM(list, (int) iter->index);
-		setitem(theobject, iter->dataptr, self);
-		PyArray_ITER_NEXT(iter);
-	}
-	Py_XDECREF(iter);
-	return 0;
+    setitem = self->descr->f->setitem;
+    iter = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
+    if (iter == NULL) return -1;
+    while(iter->index < iter->size) {
+        theobject = PyList_GET_ITEM(list, (int) iter->index);
+        setitem(theobject, iter->dataptr, self);
+        PyArray_ITER_NEXT(iter);
+    }
+    Py_XDECREF(iter);
+    return 0;
 }
 
 
 static PyObject *
 array_reduce(PyArrayObject *self, PyObject *args)
 {
-        /* version number of this pickle type. Increment if we need to
-           change the format. Be sure to handle the old versions in
-           array_setstate. */
-        const int version = 1;
-	PyObject *ret=NULL, *state=NULL, *obj=NULL, *mod=NULL;
-	PyObject *mybool, *thestr=NULL;
-	PyArray_Descr *descr;
-
-	/* Return a tuple of (callable object, arguments, object's state) */
-	/*  We will put everything in the object's state, so that on UnPickle
-	    it can use the string object as memory without a copy */
-
-	ret = PyTuple_New(3);
-	if (ret == NULL) return NULL;
-	mod = PyImport_ImportModule("numpy.core.multiarray");
-	if (mod == NULL) {Py_DECREF(ret); return NULL;}
-	obj = PyObject_GetAttrString(mod, "_reconstruct");
-	Py_DECREF(mod);
-	PyTuple_SET_ITEM(ret, 0, obj);
-	PyTuple_SET_ITEM(ret, 1,
-			 Py_BuildValue("ONc",
-				       (PyObject *)self->ob_type,
-				       Py_BuildValue("(N)",
-						     PyInt_FromLong(0)),
-				       /* dummy data-type */
-				       'b'));
-
-	/* Now fill in object's state.  This is a tuple with
-	   5 arguments
-
-           1) an integer with the pickle version.
-	   2) a Tuple giving the shape
-	   3) a PyArray_Descr Object (with correct bytorder set)
-	   4) a Bool stating if Fortran or not
-	   5) a Python object representing the data (a string, or
-	        a list or any user-defined object).
-
-	   Notice because Python does not describe a mechanism to write
-	   raw data to the pickle, this performs a copy to a string first
-	*/
-
-	state = PyTuple_New(5);
-	if (state == NULL) {
-		Py_DECREF(ret); return NULL;
-	}
-        PyTuple_SET_ITEM(state, 0, PyInt_FromLong(version));
-	PyTuple_SET_ITEM(state, 1, PyObject_GetAttrString((PyObject *)self,
-							  "shape"));
-	descr = self->descr;
-	Py_INCREF(descr);
-	PyTuple_SET_ITEM(state, 2, (PyObject *)descr);
-	mybool = (PyArray_ISFORTRAN(self) ? Py_True : Py_False);
-	Py_INCREF(mybool);
-	PyTuple_SET_ITEM(state, 3, mybool);
-	if (PyDataType_FLAGCHK(self->descr, NPY_LIST_PICKLE)) {
-		thestr = _getlist_pkl(self);
-	}
-	else {
-                thestr = PyArray_ToString(self, NPY_ANYORDER);
-	}
-	if (thestr == NULL) {
-		Py_DECREF(ret);
-		Py_DECREF(state);
-		return NULL;
-	}
-	PyTuple_SET_ITEM(state, 4, thestr);
-	PyTuple_SET_ITEM(ret, 2, state);
-	return ret;
+    /* version number of this pickle type. Increment if we need to
+       change the format. Be sure to handle the old versions in
+       array_setstate. */
+    const int version = 1;
+    PyObject *ret=NULL, *state=NULL, *obj=NULL, *mod=NULL;
+    PyObject *mybool, *thestr=NULL;
+    PyArray_Descr *descr;
+
+    /* Return a tuple of (callable object, arguments, object's state) */
+    /*  We will put everything in the object's state, so that on UnPickle
+        it can use the string object as memory without a copy */
+
+    ret = PyTuple_New(3);
+    if (ret == NULL) return NULL;
+    mod = PyImport_ImportModule("numpy.core.multiarray");
+    if (mod == NULL) {Py_DECREF(ret); return NULL;}
+    obj = PyObject_GetAttrString(mod, "_reconstruct");
+    Py_DECREF(mod);
+    PyTuple_SET_ITEM(ret, 0, obj);
+    PyTuple_SET_ITEM(ret, 1,
+                     Py_BuildValue("ONc",
+                                   (PyObject *)self->ob_type,
+                                   Py_BuildValue("(N)",
+                                                 PyInt_FromLong(0)),
+                                   /* dummy data-type */
+                                   'b'));
+
+    /* Now fill in object's state.  This is a tuple with
+       5 arguments
+
+       1) an integer with the pickle version.
+       2) a Tuple giving the shape
+       3) a PyArray_Descr Object (with correct bytorder set)
+       4) a Bool stating if Fortran or not
+       5) a Python object representing the data (a string, or
+       a list or any user-defined object).
+
+       Notice because Python does not describe a mechanism to write
+       raw data to the pickle, this performs a copy to a string first
+    */
+
+    state = PyTuple_New(5);
+    if (state == NULL) {
+        Py_DECREF(ret); return NULL;
+    }
+    PyTuple_SET_ITEM(state, 0, PyInt_FromLong(version));
+    PyTuple_SET_ITEM(state, 1, PyObject_GetAttrString((PyObject *)self,
+                                                      "shape"));
+    descr = self->descr;
+    Py_INCREF(descr);
+    PyTuple_SET_ITEM(state, 2, (PyObject *)descr);
+    mybool = (PyArray_ISFORTRAN(self) ? Py_True : Py_False);
+    Py_INCREF(mybool);
+    PyTuple_SET_ITEM(state, 3, mybool);
+    if (PyDataType_FLAGCHK(self->descr, NPY_LIST_PICKLE)) {
+        thestr = _getlist_pkl(self);
+    }
+    else {
+        thestr = PyArray_ToString(self, NPY_ANYORDER);
+    }
+    if (thestr == NULL) {
+        Py_DECREF(ret);
+        Py_DECREF(state);
+        return NULL;
+    }
+    PyTuple_SET_ITEM(state, 4, thestr);
+    PyTuple_SET_ITEM(ret, 2, state);
+    return ret;
 }
 
 
@@ -1151,275 +1150,275 @@ static PyArray_Descr * _array_typedescr_fromstr(char *);
 static PyObject *
 array_setstate(PyArrayObject *self, PyObject *args)
 {
-	PyObject *shape;
-	PyArray_Descr *typecode;
-        int version = 1;
-	int fortran;
-	PyObject *rawdata;
-	char *datastr;
-	Py_ssize_t len;
-	intp size, dimensions[MAX_DIMS];
-	int nd;
-
-	/* This will free any memory associated with a and
-	   use the string in setstate as the (writeable) memory.
-	*/
-	if (!PyArg_ParseTuple(args, "(iO!O!iO)", &version, &PyTuple_Type,
-			      &shape, &PyArrayDescr_Type, &typecode,
-			      &fortran, &rawdata)) {
-            PyErr_Clear();
-            version = 0;
-	    if (!PyArg_ParseTuple(args, "(O!O!iO)", &PyTuple_Type,
-			      &shape, &PyArrayDescr_Type, &typecode,
-			      &fortran, &rawdata)) {
-		return NULL;
-            }
+    PyObject *shape;
+    PyArray_Descr *typecode;
+    int version = 1;
+    int fortran;
+    PyObject *rawdata;
+    char *datastr;
+    Py_ssize_t len;
+    intp size, dimensions[MAX_DIMS];
+    int nd;
+
+    /* This will free any memory associated with a and
+       use the string in setstate as the (writeable) memory.
+    */
+    if (!PyArg_ParseTuple(args, "(iO!O!iO)", &version, &PyTuple_Type,
+                          &shape, &PyArrayDescr_Type, &typecode,
+                          &fortran, &rawdata)) {
+        PyErr_Clear();
+        version = 0;
+        if (!PyArg_ParseTuple(args, "(O!O!iO)", &PyTuple_Type,
+                              &shape, &PyArrayDescr_Type, &typecode,
+                              &fortran, &rawdata)) {
+            return NULL;
         }
-
-        /* If we ever need another pickle format, increment the version
-           number. But we should still be able to handle the old versions.
-           We've only got one right now. */
-        if (version != 1 && version != 0) {
-            PyErr_Format(PyExc_ValueError,
-                         "can't handle version %d of numpy.ndarray pickle",
-                         version);
+    }
+
+    /* If we ever need another pickle format, increment the version
+       number. But we should still be able to handle the old versions.
+       We've only got one right now. */
+    if (version != 1 && version != 0) {
+        PyErr_Format(PyExc_ValueError,
+                     "can't handle version %d of numpy.ndarray pickle",
+                     version);
+        return NULL;
+    }
+
+    Py_XDECREF(self->descr);
+    self->descr = typecode;
+    Py_INCREF(typecode);
+    nd = PyArray_IntpFromSequence(shape, dimensions, MAX_DIMS);
+    if (nd < 0) return NULL;
+    size = PyArray_MultiplyList(dimensions, nd);
+    if (self->descr->elsize == 0) {
+        PyErr_SetString(PyExc_ValueError, "Invalid data-type size.");
+        return NULL;
+    }
+    if (size < 0 || size > MAX_INTP / self->descr->elsize) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    if (PyDataType_FLAGCHK(typecode, NPY_LIST_PICKLE)) {
+        if (!PyList_Check(rawdata)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "object pickle not returning list");
             return NULL;
         }
-
-	Py_XDECREF(self->descr);
-	self->descr = typecode;
-	Py_INCREF(typecode);
-	nd = PyArray_IntpFromSequence(shape, dimensions, MAX_DIMS);
-	if (nd < 0) return NULL;
-	size = PyArray_MultiplyList(dimensions, nd);
-	if (self->descr->elsize == 0) {
-		PyErr_SetString(PyExc_ValueError, "Invalid data-type size.");
-		return NULL;
-	}
-	if (size < 0 || size > MAX_INTP / self->descr->elsize) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-
-	if (PyDataType_FLAGCHK(typecode, NPY_LIST_PICKLE)) {
-		if (!PyList_Check(rawdata)) {
-			PyErr_SetString(PyExc_TypeError,
-					"object pickle not returning list");
-			return NULL;
-		}
-	}
-	else {
-		if (!PyString_Check(rawdata)) {
-			PyErr_SetString(PyExc_TypeError,
-					"pickle not returning string");
-			return NULL;
-		}
-
-		if (PyString_AsStringAndSize(rawdata, &datastr, &len))
-			return NULL;
-
-		if ((len != (self->descr->elsize * size))) {
-			PyErr_SetString(PyExc_ValueError,
-					"buffer size does not"	\
-					" match array size");
-			return NULL;
-		}
-	}
-
-        if ((self->flags & OWNDATA)) {
-		if (self->data != NULL)
-			PyDataMem_FREE(self->data);
-		self->flags &= ~OWNDATA;
+    }
+    else {
+        if (!PyString_Check(rawdata)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "pickle not returning string");
+            return NULL;
         }
-	Py_XDECREF(self->base);
 
-	self->flags &= ~UPDATEIFCOPY;
+        if (PyString_AsStringAndSize(rawdata, &datastr, &len))
+            return NULL;
 
-        if (self->dimensions != NULL) {
+        if ((len != (self->descr->elsize * size))) {
+            PyErr_SetString(PyExc_ValueError,
+                            "buffer size does not"  \
+                            " match array size");
+            return NULL;
+        }
+    }
+
+    if ((self->flags & OWNDATA)) {
+        if (self->data != NULL)
+            PyDataMem_FREE(self->data);
+        self->flags &= ~OWNDATA;
+    }
+    Py_XDECREF(self->base);
+
+    self->flags &= ~UPDATEIFCOPY;
+
+    if (self->dimensions != NULL) {
+        PyDimMem_FREE(self->dimensions);
+        self->dimensions = NULL;
+    }
+
+    self->flags = DEFAULT;
+
+    self->nd = nd;
+
+    if (nd > 0) {
+        self->dimensions = PyDimMem_NEW(nd * 2);
+        self->strides = self->dimensions + nd;
+        memcpy(self->dimensions, dimensions, sizeof(intp)*nd);
+        (void) _array_fill_strides(self->strides, dimensions, nd,
+                                   (size_t) self->descr->elsize,
+                                   (fortran ? FORTRAN : CONTIGUOUS),
+                                   &(self->flags));
+    }
+
+    if (!PyDataType_FLAGCHK(typecode, NPY_LIST_PICKLE)) {
+        int swap=!PyArray_ISNOTSWAPPED(self);
+        self->data = datastr;
+        if (!_IsAligned(self) || swap) {
+            intp num = PyArray_NBYTES(self);
+            self->data = PyDataMem_NEW(num);
+            if (self->data == NULL) {
+                self->nd = 0;
                 PyDimMem_FREE(self->dimensions);
-		self->dimensions = NULL;
-	}
-
-	self->flags = DEFAULT;
-
-	self->nd = nd;
-
-	if (nd > 0) {
-		self->dimensions = PyDimMem_NEW(nd * 2);
-		self->strides = self->dimensions + nd;
-		memcpy(self->dimensions, dimensions, sizeof(intp)*nd);
-		(void) _array_fill_strides(self->strides, dimensions, nd,
-					   (size_t) self->descr->elsize,
-                                           (fortran ? FORTRAN : CONTIGUOUS),
-					   &(self->flags));
-	}
-
-	if (!PyDataType_FLAGCHK(typecode, NPY_LIST_PICKLE)) {
-                int swap=!PyArray_ISNOTSWAPPED(self);
-		self->data = datastr;
-		if (!_IsAligned(self) || swap) {
-			intp num = PyArray_NBYTES(self);
-			self->data = PyDataMem_NEW(num);
-			if (self->data == NULL) {
-				self->nd = 0;
-				PyDimMem_FREE(self->dimensions);
-				return PyErr_NoMemory();
-			}
-                        if (swap) { /* byte-swap on pickle-read */
-				intp numels = num / self->descr->elsize;
-                                self->descr->f->copyswapn(self->data, self->descr->elsize,
-                                                          datastr, self->descr->elsize,
-                                                          numels, 1, self);
-				if (!PyArray_ISEXTENDED(self)) {
-					self->descr = PyArray_DescrFromType(self->descr->type_num);
-				}
-				else {
-					self->descr = PyArray_DescrNew(typecode);
-					if (self->descr->byteorder == PyArray_BIG)
-						self->descr->byteorder = PyArray_LITTLE;
-					else if (self->descr->byteorder == PyArray_LITTLE)
-						self->descr->byteorder = PyArray_BIG;
-				}
-				Py_DECREF(typecode);
-                        }
-                        else {
-                                memcpy(self->data, datastr, num);
-                        }
-			self->flags |= OWNDATA;
-			self->base = NULL;
-		}
-		else {
-			self->base = rawdata;
-			Py_INCREF(self->base);
-		}
-	}
-	else {
-		self->data = PyDataMem_NEW(PyArray_NBYTES(self));
-		if (self->data == NULL) {
-			self->nd = 0;
-			self->data = PyDataMem_NEW(self->descr->elsize);
-			if (self->dimensions) PyDimMem_FREE(self->dimensions);
-			return PyErr_NoMemory();
-		}
-		if (PyDataType_FLAGCHK(self->descr, NPY_NEEDS_INIT))
-                        memset(self->data, 0, PyArray_NBYTES(self));
-		self->flags |= OWNDATA;
-		self->base = NULL;
-		if (_setlist_pkl(self, rawdata) < 0)
-			return NULL;
-	}
-
-	PyArray_UpdateFlags(self, UPDATE_ALL);
-
-	Py_INCREF(Py_None);
-	return Py_None;
+                return PyErr_NoMemory();
+            }
+            if (swap) { /* byte-swap on pickle-read */
+                intp numels = num / self->descr->elsize;
+                self->descr->f->copyswapn(self->data, self->descr->elsize,
+                                          datastr, self->descr->elsize,
+                                          numels, 1, self);
+                if (!PyArray_ISEXTENDED(self)) {
+                    self->descr = PyArray_DescrFromType(self->descr->type_num);
+                }
+                else {
+                    self->descr = PyArray_DescrNew(typecode);
+                    if (self->descr->byteorder == PyArray_BIG)
+                        self->descr->byteorder = PyArray_LITTLE;
+                    else if (self->descr->byteorder == PyArray_LITTLE)
+                        self->descr->byteorder = PyArray_BIG;
+                }
+                Py_DECREF(typecode);
+            }
+            else {
+                memcpy(self->data, datastr, num);
+            }
+            self->flags |= OWNDATA;
+            self->base = NULL;
+        }
+        else {
+            self->base = rawdata;
+            Py_INCREF(self->base);
+        }
+    }
+    else {
+        self->data = PyDataMem_NEW(PyArray_NBYTES(self));
+        if (self->data == NULL) {
+            self->nd = 0;
+            self->data = PyDataMem_NEW(self->descr->elsize);
+            if (self->dimensions) PyDimMem_FREE(self->dimensions);
+            return PyErr_NoMemory();
+        }
+        if (PyDataType_FLAGCHK(self->descr, NPY_NEEDS_INIT))
+            memset(self->data, 0, PyArray_NBYTES(self));
+        self->flags |= OWNDATA;
+        self->base = NULL;
+        if (_setlist_pkl(self, rawdata) < 0)
+            return NULL;
+    }
+
+    PyArray_UpdateFlags(self, UPDATE_ALL);
+
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 /*OBJECT_API*/
 static int
 PyArray_Dump(PyObject *self, PyObject *file, int protocol)
 {
-	PyObject *cpick=NULL;
-	PyObject *ret;
-	if (protocol < 0) protocol = 2;
-
-	cpick = PyImport_ImportModule("cPickle");
-	if (cpick==NULL) return -1;
-
-	if PyString_Check(file) {
-		file = PyFile_FromString(PyString_AS_STRING(file), "wb");
-		if (file==NULL) return -1;
-	}
-	else Py_INCREF(file);
-	ret = PyObject_CallMethod(cpick, "dump", "OOi", self,
-				  file, protocol);
-	Py_XDECREF(ret);
-	Py_DECREF(file);
-	Py_DECREF(cpick);
-	if (PyErr_Occurred()) return -1;
-	return 0;
+    PyObject *cpick=NULL;
+    PyObject *ret;
+    if (protocol < 0) protocol = 2;
+
+    cpick = PyImport_ImportModule("cPickle");
+    if (cpick==NULL) return -1;
+
+    if PyString_Check(file) {
+            file = PyFile_FromString(PyString_AS_STRING(file), "wb");
+            if (file==NULL) return -1;
+        }
+    else Py_INCREF(file);
+    ret = PyObject_CallMethod(cpick, "dump", "OOi", self,
+                              file, protocol);
+    Py_XDECREF(ret);
+    Py_DECREF(file);
+    Py_DECREF(cpick);
+    if (PyErr_Occurred()) return -1;
+    return 0;
 }
 
 /*OBJECT_API*/
 static PyObject *
 PyArray_Dumps(PyObject *self, int protocol)
 {
-	PyObject *cpick=NULL;
-	PyObject *ret;
-	if (protocol < 0) protocol = 2;
+    PyObject *cpick=NULL;
+    PyObject *ret;
+    if (protocol < 0) protocol = 2;
 
-	cpick = PyImport_ImportModule("cPickle");
-	if (cpick==NULL) return NULL;
-	ret = PyObject_CallMethod(cpick, "dumps", "Oi", self, protocol);
-	Py_DECREF(cpick);
-	return ret;
+    cpick = PyImport_ImportModule("cPickle");
+    if (cpick==NULL) return NULL;
+    ret = PyObject_CallMethod(cpick, "dumps", "Oi", self, protocol);
+    Py_DECREF(cpick);
+    return ret;
 }
 
 
 static PyObject *
 array_dump(PyArrayObject *self, PyObject *args)
 {
-	PyObject *file=NULL;
-	int ret;
+    PyObject *file=NULL;
+    int ret;
 
-	if (!PyArg_ParseTuple(args, "O", &file))
-		return NULL;
-	ret = PyArray_Dump((PyObject *)self, file, 2);
-	if (ret < 0) return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, "O", &file))
+        return NULL;
+    ret = PyArray_Dump((PyObject *)self, file, 2);
+    if (ret < 0) return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
 static PyObject *
 array_dumps(PyArrayObject *self, PyObject *args)
 {
-	if (!PyArg_ParseTuple(args, ""))
-		return NULL;
-	return PyArray_Dumps((PyObject *)self, 2);
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+    return PyArray_Dumps((PyObject *)self, 2);
 }
 
 
 static PyObject *
 array_transpose(PyArrayObject *self, PyObject *args)
 {
-	PyObject *shape=Py_None;
-	int n;
-	PyArray_Dims permute;
-	PyObject *ret;
+    PyObject *shape=Py_None;
+    int n;
+    PyArray_Dims permute;
+    PyObject *ret;
 
-	n = PyTuple_Size(args);
-	if (n > 1) shape = args;
-	else if (n == 1) shape = PyTuple_GET_ITEM(args, 0);
+    n = PyTuple_Size(args);
+    if (n > 1) shape = args;
+    else if (n == 1) shape = PyTuple_GET_ITEM(args, 0);
 
-	if (shape == Py_None)
-		ret = PyArray_Transpose(self, NULL);
-	else {
-		if (!PyArray_IntpConverter(shape, &permute)) return NULL;
-		ret = PyArray_Transpose(self, &permute);
-		PyDimMem_FREE(permute.ptr);
-	}
+    if (shape == Py_None)
+        ret = PyArray_Transpose(self, NULL);
+    else {
+        if (!PyArray_IntpConverter(shape, &permute)) return NULL;
+        ret = PyArray_Transpose(self, &permute);
+        PyDimMem_FREE(permute.ptr);
+    }
 
-	return ret;
+    return ret;
 }
 
-/* Return typenumber from dtype2 unless it is NULL, then return 
+/* Return typenumber from dtype2 unless it is NULL, then return
    NPY_DOUBLE if dtype1->type_num is integer or bool
-   and dtype1->type_num otherwise. 
+   and dtype1->type_num otherwise.
 */
 static int
 _get_type_num_double(PyArray_Descr *dtype1, PyArray_Descr *dtype2)
 {
-        if (dtype2 != NULL)
-                return dtype2->type_num;
-        
-        /* For integer or bool data-types */
-        if (dtype1->type_num < NPY_FLOAT) {
-                return NPY_DOUBLE;
-        }
-        else {
-                return dtype1->type_num;
-        }
+    if (dtype2 != NULL)
+        return dtype2->type_num;
+
+    /* For integer or bool data-types */
+    if (dtype1->type_num < NPY_FLOAT) {
+        return NPY_DOUBLE;
+    }
+    else {
+        return dtype1->type_num;
+    }
 }
 
 #define _CHKTYPENUM(typ) ((typ) ? (typ)->type_num : PyArray_NOTYPE)
@@ -1427,218 +1426,218 @@ _get_type_num_double(PyArray_Descr *dtype1, PyArray_Descr *dtype2)
 static PyObject *
 array_mean(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-	PyArray_Descr *dtype=NULL;
-        PyArrayObject *out=NULL;
-        int num;
-	static char *kwlist[] = {"axis", "dtype", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArray_Descr *dtype=NULL;
+    PyArrayObject *out=NULL;
+    int num;
+    static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis, PyArray_DescrConverter2,
-					 &dtype,
-                                         PyArray_OutputConverter,
-                                         &out)) return NULL;        
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis, PyArray_DescrConverter2,
+                                     &dtype,
+                                     PyArray_OutputConverter,
+                                     &out)) return NULL;
 
-        num = _get_type_num_double(self->descr, dtype);
-	return PyArray_Mean(self, axis, num, out);
+    num = _get_type_num_double(self->descr, dtype);
+    return PyArray_Mean(self, axis, num, out);
 }
 
 static PyObject *
 array_sum(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-	PyArray_Descr *dtype=NULL;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "dtype", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArray_Descr *dtype=NULL;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis, PyArray_DescrConverter2,
-					 &dtype,
-                                         PyArray_OutputConverter,
-                                         &out)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis, PyArray_DescrConverter2,
+                                     &dtype,
+                                     PyArray_OutputConverter,
+                                     &out)) return NULL;
 
-	return PyArray_Sum(self, axis, _CHKTYPENUM(dtype), out);
+    return PyArray_Sum(self, axis, _CHKTYPENUM(dtype), out);
 }
 
 
 static PyObject *
 array_cumsum(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-	PyArray_Descr *dtype=NULL;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "dtype", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArray_Descr *dtype=NULL;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis, PyArray_DescrConverter2,
-					 &dtype,
-                                         PyArray_OutputConverter,
-                                         &out)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis, PyArray_DescrConverter2,
+                                     &dtype,
+                                     PyArray_OutputConverter,
+                                     &out)) return NULL;
 
-	return PyArray_CumSum(self, axis, _CHKTYPENUM(dtype), out);
+    return PyArray_CumSum(self, axis, _CHKTYPENUM(dtype), out);
 }
 
 static PyObject *
 array_prod(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-	PyArray_Descr *dtype=NULL;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "dtype", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArray_Descr *dtype=NULL;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis, PyArray_DescrConverter2,
-					 &dtype,
-                                         PyArray_OutputConverter,
-                                         &out)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis, PyArray_DescrConverter2,
+                                     &dtype,
+                                     PyArray_OutputConverter,
+                                     &out)) return NULL;
 
-	return PyArray_Prod(self, axis, _CHKTYPENUM(dtype), out);
+    return PyArray_Prod(self, axis, _CHKTYPENUM(dtype), out);
 }
 
 static PyObject *
 array_cumprod(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-	PyArray_Descr *dtype=NULL;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "dtype", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArray_Descr *dtype=NULL;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis, PyArray_DescrConverter2,
-					 &dtype,
-                                         PyArray_OutputConverter,
-                                         &out)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis, PyArray_DescrConverter2,
+                                     &dtype,
+                                     PyArray_OutputConverter,
+                                     &out)) return NULL;
 
-	return PyArray_CumProd(self, axis, _CHKTYPENUM(dtype), out);
+    return PyArray_CumProd(self, axis, _CHKTYPENUM(dtype), out);
 }
 
 
 static PyObject *
 array_any(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis,
-                                         PyArray_OutputConverter,
-                                         &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis,
+                                     PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return PyArray_Any(self, axis, out);
+    return PyArray_Any(self, axis, out);
 }
 
 
 static PyObject *
 array_all(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"axis", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"axis", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis,
-                                         PyArray_OutputConverter,
-                                         &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis,
+                                     PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return PyArray_All(self, axis, out);
+    return PyArray_All(self, axis, out);
 }
 
 
 static PyObject *
 array_stddev(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-	PyArray_Descr *dtype=NULL;
-        PyArrayObject *out=NULL;
-        int num;
-	static char *kwlist[] = {"axis", "dtype", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArray_Descr *dtype=NULL;
+    PyArrayObject *out=NULL;
+    int num;
+    static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis, PyArray_DescrConverter2,
-					 &dtype,
-                                         PyArray_OutputConverter,
-                                         &out)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis, PyArray_DescrConverter2,
+                                     &dtype,
+                                     PyArray_OutputConverter,
+                                     &out)) return NULL;
 
-        num = _get_type_num_double(self->descr, dtype);
-        return PyArray_Std(self, axis, num, out, 0);
+    num = _get_type_num_double(self->descr, dtype);
+    return PyArray_Std(self, axis, num, out, 0);
 }
 
 
 static PyObject *
 array_variance(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-	PyArray_Descr *dtype=NULL;
-        PyArrayObject *out=NULL;
-        int num;
-	static char *kwlist[] = {"axis", "dtype", "out", NULL};
+    int axis=MAX_DIMS;
+    PyArray_Descr *dtype=NULL;
+    PyArrayObject *out=NULL;
+    int num;
+    static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-					 PyArray_AxisConverter,
-					 &axis, PyArray_DescrConverter2,
-					 &dtype,
-                                         PyArray_OutputConverter,
-                                         &out)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
+                                     PyArray_AxisConverter,
+                                     &axis, PyArray_DescrConverter2,
+                                     &dtype,
+                                     PyArray_OutputConverter,
+                                     &out)) return NULL;
 
-        num = _get_type_num_double(self->descr, dtype);
-	return PyArray_Std(self, axis, num, out, 1);
+    num = _get_type_num_double(self->descr, dtype);
+    return PyArray_Std(self, axis, num, out, 1);
 }
 
 
 static PyObject *
 array_compress(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis=MAX_DIMS;
-	PyObject *condition;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"condition", "axis", "out", NULL};
+    int axis=MAX_DIMS;
+    PyObject *condition;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"condition", "axis", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&", kwlist,
-					 &condition, PyArray_AxisConverter,
-					 &axis,
-                                         PyArray_OutputConverter,
-                                         &out)) return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&", kwlist,
+                                     &condition, PyArray_AxisConverter,
+                                     &axis,
+                                     PyArray_OutputConverter,
+                                     &out)) return NULL;
 
-	return _ARET(PyArray_Compress(self, condition, axis, out));
+    return _ARET(PyArray_Compress(self, condition, axis, out));
 }
 
 
 static PyObject *
 array_nonzero(PyArrayObject *self, PyObject *args)
 {
-	if (!PyArg_ParseTuple(args, "")) return NULL;
+    if (!PyArg_ParseTuple(args, "")) return NULL;
 
-	return PyArray_Nonzero(self);
+    return PyArray_Nonzero(self);
 }
 
 
 static PyObject *
 array_trace(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis1=0, axis2=1, offset=0;
-	PyArray_Descr *dtype=NULL;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"offset", "axis1", "axis2", "dtype", "out", NULL};
+    int axis1=0, axis2=1, offset=0;
+    PyArray_Descr *dtype=NULL;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"offset", "axis1", "axis2", "dtype", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiO&O&", kwlist,
-					 &offset, &axis1, &axis2,
-					 PyArray_DescrConverter2, &dtype,
-                                         PyArray_OutputConverter, &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiO&O&", kwlist,
+                                     &offset, &axis1, &axis2,
+                                     PyArray_DescrConverter2, &dtype,
+                                     PyArray_OutputConverter, &out))
+        return NULL;
 
-	return _ARET(PyArray_Trace(self, offset, axis1, axis2,
-				   _CHKTYPENUM(dtype), out));
+    return _ARET(PyArray_Trace(self, offset, axis1, axis2,
+                               _CHKTYPENUM(dtype), out));
 }
 
 #undef _CHKTYPENUM
@@ -1647,17 +1646,17 @@ array_trace(PyArrayObject *self, PyObject *args, PyObject *kwds)
 static PyObject *
 array_clip(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *min, *max;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"min", "max", "out", NULL};
+    PyObject *min, *max;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"min", "max", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O&", kwlist,
-					 &min, &max,
-                                         PyArray_OutputConverter,
-                                         &out))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O&", kwlist,
+                                     &min, &max,
+                                     PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return _ARET(PyArray_Clip(self, min, max, out));
+    return _ARET(PyArray_Clip(self, min, max, out));
 }
 
 
@@ -1665,66 +1664,66 @@ static PyObject *
 array_conjugate(PyArrayObject *self, PyObject *args)
 {
 
-        PyArrayObject *out=NULL;
-	if (!PyArg_ParseTuple(args, "|O&",
-                              PyArray_OutputConverter,
-                              &out)) return NULL;
+    PyArrayObject *out=NULL;
+    if (!PyArg_ParseTuple(args, "|O&",
+                          PyArray_OutputConverter,
+                          &out)) return NULL;
 
-	return PyArray_Conjugate(self, out);
+    return PyArray_Conjugate(self, out);
 }
 
 
 static PyObject *
 array_diagonal(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int axis1=0, axis2=1, offset=0;
-	static char *kwlist[] = {"offset", "axis1", "axis2", NULL};
+    int axis1=0, axis2=1, offset=0;
+    static char *kwlist[] = {"offset", "axis1", "axis2", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,
-					 &offset, &axis1, &axis2))
-		return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,
+                                     &offset, &axis1, &axis2))
+        return NULL;
 
-	return _ARET(PyArray_Diagonal(self, offset, axis1, axis2));
+    return _ARET(PyArray_Diagonal(self, offset, axis1, axis2));
 }
 
 
 static PyObject *
 array_flatten(PyArrayObject *self, PyObject *args)
 {
-	PyArray_ORDER fortran=PyArray_CORDER;
+    PyArray_ORDER fortran=PyArray_CORDER;
 
-	if (!PyArg_ParseTuple(args, "|O&", PyArray_OrderConverter,
-			      &fortran)) return NULL;
+    if (!PyArg_ParseTuple(args, "|O&", PyArray_OrderConverter,
+                          &fortran)) return NULL;
 
-	return PyArray_Flatten(self, fortran);
+    return PyArray_Flatten(self, fortran);
 }
 
 
 static PyObject *
 array_ravel(PyArrayObject *self, PyObject *args)
 {
-	PyArray_ORDER fortran=PyArray_CORDER;
+    PyArray_ORDER fortran=PyArray_CORDER;
 
-	if (!PyArg_ParseTuple(args, "|O&", PyArray_OrderConverter,
-			      &fortran)) return NULL;
+    if (!PyArg_ParseTuple(args, "|O&", PyArray_OrderConverter,
+                          &fortran)) return NULL;
 
-	return PyArray_Ravel(self, fortran);
+    return PyArray_Ravel(self, fortran);
 }
 
 
 static PyObject *
 array_round(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	int decimals = 0;
-        PyArrayObject *out=NULL;
-	static char *kwlist[] = {"decimals", "out", NULL};
+    int decimals = 0;
+    PyArrayObject *out=NULL;
+    static char *kwlist[] = {"decimals", "out", NULL};
 
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&", kwlist,
-					 &decimals, PyArray_OutputConverter,
-                                         &out))
-            return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&", kwlist,
+                                     &decimals, PyArray_OutputConverter,
+                                     &out))
+        return NULL;
 
-	return _ARET(PyArray_Round(self, decimals, out));
+    return _ARET(PyArray_Round(self, decimals, out));
 }
 
 
@@ -1735,205 +1734,205 @@ static Bool _IsWriteable(PyArrayObject *);
 static PyObject *
 array_setflags(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-	static char *kwlist[] = {"write", "align", "uic", NULL};
-	PyObject *write=Py_None;
-	PyObject *align=Py_None;
-	PyObject *uic=Py_None;
-	int flagback = self->flags;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist,
-					 &write, &align, &uic))
-		return NULL;
-
-	if (align != Py_None) {
-		if (PyObject_Not(align)) self->flags &= ~ALIGNED;
-		else if (_IsAligned(self)) self->flags |= ALIGNED;
-		else {
-			PyErr_SetString(PyExc_ValueError,
-					"cannot set aligned flag of mis-"\
-					"aligned array to True");
-			return NULL;
-		}
-	}
-
-	if (uic != Py_None) {
-                if (PyObject_IsTrue(uic)) {
-			self->flags = flagback;
-                        PyErr_SetString(PyExc_ValueError,
-                                        "cannot set UPDATEIFCOPY "       \
-                                        "flag to True");
-                        return NULL;
-                }
-                else {
-                        self->flags &= ~UPDATEIFCOPY;
-                        Py_XDECREF(self->base);
-                        self->base = NULL;
-                }
+    static char *kwlist[] = {"write", "align", "uic", NULL};
+    PyObject *write=Py_None;
+    PyObject *align=Py_None;
+    PyObject *uic=Py_None;
+    int flagback = self->flags;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist,
+                                     &write, &align, &uic))
+        return NULL;
+
+    if (align != Py_None) {
+        if (PyObject_Not(align)) self->flags &= ~ALIGNED;
+        else if (_IsAligned(self)) self->flags |= ALIGNED;
+        else {
+            PyErr_SetString(PyExc_ValueError,
+                            "cannot set aligned flag of mis-"\
+                            "aligned array to True");
+            return NULL;
         }
-
-        if (write != Py_None) {
-                if (PyObject_IsTrue(write))
-			if (_IsWriteable(self)) {
-				self->flags |= WRITEABLE;
-			}
-			else {
-				self->flags = flagback;
-				PyErr_SetString(PyExc_ValueError,
-						"cannot set WRITEABLE "	\
-						"flag to True of this "	\
-						"array");		\
-				return NULL;
-			}
-                else
-                        self->flags &= ~WRITEABLE;
+    }
+
+    if (uic != Py_None) {
+        if (PyObject_IsTrue(uic)) {
+            self->flags = flagback;
+            PyErr_SetString(PyExc_ValueError,
+                            "cannot set UPDATEIFCOPY "       \
+                            "flag to True");
+            return NULL;
+        }
+        else {
+            self->flags &= ~UPDATEIFCOPY;
+            Py_XDECREF(self->base);
+            self->base = NULL;
         }
+    }
+
+    if (write != Py_None) {
+        if (PyObject_IsTrue(write))
+            if (_IsWriteable(self)) {
+                self->flags |= WRITEABLE;
+            }
+            else {
+                self->flags = flagback;
+                PyErr_SetString(PyExc_ValueError,
+                                "cannot set WRITEABLE " \
+                                "flag to True of this " \
+                                "array");               \
+                return NULL;
+            }
+        else
+            self->flags &= ~WRITEABLE;
+    }
 
-        Py_INCREF(Py_None);
-        return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
 static PyObject *
 array_newbyteorder(PyArrayObject *self, PyObject *args)
 {
-	char endian = PyArray_SWAP;
-	PyArray_Descr *new;
+    char endian = PyArray_SWAP;
+    PyArray_Descr *new;
 
-	if (!PyArg_ParseTuple(args, "|O&", PyArray_ByteorderConverter,
-			      &endian)) return NULL;
+    if (!PyArg_ParseTuple(args, "|O&", PyArray_ByteorderConverter,
+                          &endian)) return NULL;
 
-	new = PyArray_DescrNewByteorder(self->descr, endian);
-	if (!new) return NULL;
-	return PyArray_View(self, new, NULL);
+    new = PyArray_DescrNewByteorder(self->descr, endian);
+    if (!new) return NULL;
+    return PyArray_View(self, new, NULL);
 
 }
 
 static PyMethodDef array_methods[] = {
 
-	/* for subtypes */
-	{"__array__", (PyCFunction)array_getarray,
-            METH_VARARGS, NULL},
-	{"__array_wrap__", (PyCFunction)array_wraparray,
-            METH_VARARGS, NULL},
-
-	/* for the copy module */
-        {"__copy__", (PyCFunction)array_copy,
-            METH_VARARGS, NULL},
-        {"__deepcopy__", (PyCFunction)array_deepcopy,
-            METH_VARARGS, NULL},
-
-        /* for Pickling */
-        {"__reduce__", (PyCFunction) array_reduce,
-            METH_VARARGS, NULL},
-	{"__setstate__", (PyCFunction) array_setstate,
-            METH_VARARGS, NULL},
-	{"dumps", (PyCFunction) array_dumps,
-            METH_VARARGS, NULL},
-	{"dump", (PyCFunction) array_dump,
-            METH_VARARGS, NULL},
-
-	/* Original and Extended methods added 2005 */
-        {"all", (PyCFunction)array_all,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"any", (PyCFunction)array_any,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"argmax", (PyCFunction)array_argmax,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"argmin", (PyCFunction)array_argmin,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"argsort", (PyCFunction)array_argsort,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-        {"astype", (PyCFunction)array_cast,
-            METH_VARARGS, NULL},
-        {"byteswap", (PyCFunction)array_byteswap,
-            METH_VARARGS, NULL},
-	{"choose", (PyCFunction)array_choose,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"clip", (PyCFunction)array_clip,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"compress", (PyCFunction)array_compress,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"conj", (PyCFunction)array_conjugate,
-	    METH_VARARGS, NULL},
-	{"conjugate", (PyCFunction)array_conjugate,
-	    METH_VARARGS, NULL},
-        {"copy", (PyCFunction)array_copy,
-            METH_VARARGS, NULL},
-	{"cumprod", (PyCFunction)array_cumprod,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"cumsum", (PyCFunction)array_cumsum,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"diagonal", (PyCFunction)array_diagonal,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"fill", (PyCFunction)array_fill,
-	    METH_VARARGS, NULL},
-	{"flatten", (PyCFunction)array_flatten,
-	    METH_VARARGS, NULL},
-	{"getfield", (PyCFunction)array_getfield,
-            METH_VARARGS | METH_KEYWORDS, NULL},
-        {"item", (PyCFunction)array_toscalar,
-            METH_VARARGS, NULL},
-        {"itemset", (PyCFunction) array_setscalar,
-            METH_VARARGS, NULL},
-	{"max", (PyCFunction)array_max,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"mean", (PyCFunction)array_mean,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"min", (PyCFunction)array_min,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"newbyteorder", (PyCFunction)array_newbyteorder,
-	    METH_VARARGS, NULL},
-	{"nonzero", (PyCFunction)array_nonzero,
-	    METH_VARARGS, NULL},
-	{"prod", (PyCFunction)array_prod,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"ptp", (PyCFunction)array_ptp,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"put",	(PyCFunction)array_put,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"ravel", (PyCFunction)array_ravel,
-	    METH_VARARGS, NULL},
-	{"repeat", (PyCFunction)array_repeat,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"reshape", (PyCFunction)array_reshape,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-        {"resize", (PyCFunction)array_resize,
-            METH_VARARGS | METH_KEYWORDS, NULL},
-	{"round", (PyCFunction)array_round,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"searchsorted", (PyCFunction)array_searchsorted,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"setfield", (PyCFunction)array_setfield,
-            METH_VARARGS | METH_KEYWORDS, NULL},
-	{"setflags", (PyCFunction)array_setflags,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"sort", (PyCFunction)array_sort,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"squeeze", (PyCFunction)array_squeeze,
-	    METH_VARARGS, NULL},
-	{"std", (PyCFunction)array_stddev,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"sum", (PyCFunction)array_sum,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"swapaxes", (PyCFunction)array_swapaxes,
-	    METH_VARARGS, NULL},
-	{"take", (PyCFunction)array_take,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"tofile", (PyCFunction)array_tofile,
-            METH_VARARGS | METH_KEYWORDS, NULL},
-        {"tolist", (PyCFunction)array_tolist,
-            METH_VARARGS, NULL},
-        {"tostring", (PyCFunction)array_tostring,
-            METH_VARARGS | METH_KEYWORDS, NULL},
-	{"trace", (PyCFunction)array_trace,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"transpose", (PyCFunction)array_transpose,
-	    METH_VARARGS, NULL},
-	{"var", (PyCFunction)array_variance,
-	    METH_VARARGS | METH_KEYWORDS, NULL},
-	{"view", (PyCFunction)array_view,
-	    METH_VARARGS, NULL},
-        {NULL,		NULL}		/* sentinel */
+    /* for subtypes */
+    {"__array__", (PyCFunction)array_getarray,
+         METH_VARARGS, NULL},
+    {"__array_wrap__", (PyCFunction)array_wraparray,
+         METH_VARARGS, NULL},
+
+    /* for the copy module */
+    {"__copy__", (PyCFunction)array_copy,
+         METH_VARARGS, NULL},
+    {"__deepcopy__", (PyCFunction)array_deepcopy,
+         METH_VARARGS, NULL},
+
+    /* for Pickling */
+    {"__reduce__", (PyCFunction) array_reduce,
+         METH_VARARGS, NULL},
+    {"__setstate__", (PyCFunction) array_setstate,
+         METH_VARARGS, NULL},
+    {"dumps", (PyCFunction) array_dumps,
+         METH_VARARGS, NULL},
+    {"dump", (PyCFunction) array_dump,
+         METH_VARARGS, NULL},
+
+    /* Original and Extended methods added 2005 */
+    {"all", (PyCFunction)array_all,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"any", (PyCFunction)array_any,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"argmax", (PyCFunction)array_argmax,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"argmin", (PyCFunction)array_argmin,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"argsort", (PyCFunction)array_argsort,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"astype", (PyCFunction)array_cast,
+         METH_VARARGS, NULL},
+    {"byteswap", (PyCFunction)array_byteswap,
+         METH_VARARGS, NULL},
+    {"choose", (PyCFunction)array_choose,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"clip", (PyCFunction)array_clip,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"compress", (PyCFunction)array_compress,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"conj", (PyCFunction)array_conjugate,
+         METH_VARARGS, NULL},
+    {"conjugate", (PyCFunction)array_conjugate,
+         METH_VARARGS, NULL},
+    {"copy", (PyCFunction)array_copy,
+         METH_VARARGS, NULL},
+    {"cumprod", (PyCFunction)array_cumprod,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"cumsum", (PyCFunction)array_cumsum,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"diagonal", (PyCFunction)array_diagonal,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"fill", (PyCFunction)array_fill,
+         METH_VARARGS, NULL},
+    {"flatten", (PyCFunction)array_flatten,
+         METH_VARARGS, NULL},
+    {"getfield", (PyCFunction)array_getfield,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"item", (PyCFunction)array_toscalar,
+         METH_VARARGS, NULL},
+    {"itemset", (PyCFunction) array_setscalar,
+         METH_VARARGS, NULL},
+    {"max", (PyCFunction)array_max,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"mean", (PyCFunction)array_mean,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"min", (PyCFunction)array_min,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"newbyteorder", (PyCFunction)array_newbyteorder,
+         METH_VARARGS, NULL},
+    {"nonzero", (PyCFunction)array_nonzero,
+         METH_VARARGS, NULL},
+    {"prod", (PyCFunction)array_prod,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"ptp", (PyCFunction)array_ptp,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"put", (PyCFunction)array_put,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"ravel", (PyCFunction)array_ravel,
+         METH_VARARGS, NULL},
+    {"repeat", (PyCFunction)array_repeat,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"reshape", (PyCFunction)array_reshape,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"resize", (PyCFunction)array_resize,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"round", (PyCFunction)array_round,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"searchsorted", (PyCFunction)array_searchsorted,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"setfield", (PyCFunction)array_setfield,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"setflags", (PyCFunction)array_setflags,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"sort", (PyCFunction)array_sort,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"squeeze", (PyCFunction)array_squeeze,
+         METH_VARARGS, NULL},
+    {"std", (PyCFunction)array_stddev,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"sum", (PyCFunction)array_sum,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"swapaxes", (PyCFunction)array_swapaxes,
+         METH_VARARGS, NULL},
+    {"take", (PyCFunction)array_take,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"tofile", (PyCFunction)array_tofile,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"tolist", (PyCFunction)array_tolist,
+         METH_VARARGS, NULL},
+    {"tostring", (PyCFunction)array_tostring,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"trace", (PyCFunction)array_trace,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"transpose", (PyCFunction)array_transpose,
+         METH_VARARGS, NULL},
+    {"var", (PyCFunction)array_variance,
+         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"view", (PyCFunction)array_view,
+         METH_VARARGS, NULL},
+    {NULL, NULL}           /* sentinel */
 };
 
 #undef _ARET