sparse: Add "order" and "out" arguments to todense() and toarray()

scipy/sparse/base.py

@@ -468,11 +468,67 @@ def getrow(self, i):
     #def __array__(self):
     #    return self.toarray()
 
-    def todense(self):
-        return np.asmatrix(self.toarray())
+    def todense(self, order=None, out=None):
+        """
+        Return a dense matrix representation of this matrix.
+
+        Parameters
+        ----------
+        order : {'C', 'F'}, optional
+            Whether to store multi-dimensional data in C (row-major)
+            or Fortran (column-major) order in memory. The default
+            is 'None', indicating the NumPy default of C-ordered.
+            Cannot be specified in conjunction with the `out`
+            argument.
+
+        out : ndarray, 2-dimensional, optional
+            If specified, uses this array (or `numpy.matrix`) as the
+            output buffer instead of allocating a new array to
+            return. The provided array must have the same shape and
+            dtype as the sparse matrix on which you are calling the
+            method.
+
+        Returns
+        -------
+        arr : numpy.matrix, 2-dimensional
+            A NumPy matrix object with the same shape and containing
+            the same data represented by the sparse matrix, with the
+            requested memory order. If `out` was passed and was an
+            array (rather than a `numpy.matrix`), it will be filled
+            with the appropriate values and returned wrapped in a
+            `numpy.matrix` object that shares the same memory.
+        """
+        return np.asmatrix(self.toarray(order=order, out=out))
+
+    def toarray(self, order=None, out=None):
+        """
+        Return a dense ndarray representation of this matrix.
 
-    def toarray(self):
-        return self.tocoo().toarray()
+        Parameters
+        ----------
+        order : {'C', 'F'}, optional
+            Whether to store multi-dimensional data in C (row-major)
+            or Fortran (column-major) order in memory. The default
+            is 'None', indicating the NumPy default of C-ordered.
+            Cannot be specified in conjunction with the `out`
+            argument.
+
+        out : ndarray, 2-dimensional, optional
+            If specified, uses this array as the output buffer
+            instead of allocating a new array to return. The provided
+            array must have the same shape and dtype as the sparse
+            matrix on which you are calling the method.
+
+        Returns
+        -------
+        arr : ndarray, 2-dimensional
+            An array with the same shape and containing the same
+            data represented by the sparse matrix, with the requested
+            memory order. If `out` was passed, the same object is
+            returned after being modified in-place to contain the
+            appropriate values.
+        """
+        return self.tocoo().toarray(order=order, out=out)
 
     def todok(self):
         return self.tocoo().todok()
@@ -556,6 +612,19 @@ def setdiag(self, values, k=0):
             for i,v in enumerate(values[:max_index]):
                 self[i, i + k] = v
 
+    def _process_toarray_args(self, order, out):
+        if out is not None:
+            if order is not None:
+                raise ValueError('order cannot be specified if out '
+                                 'is not None')
+            if out.shape != self.shape or out.dtype != self.dtype:
+                raise ValueError('out array must be same dtype and shape as '
+                                 'sparse matrix')
+            out[...] = 0.
+            return out
+        else:
+            return np.zeros(self.shape, dtype=self.dtype, order=order)
+
 
 def isspmatrix(x):
     return isinstance(x, spmatrix)

scipy/sparse/compressed.py

@@ -554,8 +554,9 @@ def tocoo(self,copy=True):
         from coo import coo_matrix
         return coo_matrix((data,(row,col)), self.shape)
 
-    def toarray(self):
-        return self.tocoo(copy=False).toarray()
+    def toarray(self, order=None, out=None):
+        """See the docstring for `spmatrix.toarray`."""
+        return self.tocoo(copy=False).toarray(order=order, out=out)
 
     ##############################################################
     # methods that examine or modify the internal data structure #

scipy/sparse/coo.py

@@ -230,10 +230,13 @@ def transpose(self, copy=False):
         M,N = self.shape
         return coo_matrix((self.data, (self.col, self.row)), shape=(N,M), copy=copy)
 
-    def toarray(self):
-        B = np.zeros(self.shape, dtype=self.dtype)
+    def toarray(self, order=None, out=None):
+        """See the docstring for `spmatrix.toarray`."""
+        B = self._process_toarray_args(order, out)
+        fortran = int(B.flags.f_contiguous)
         M,N = self.shape
-        coo_todense(M, N, self.nnz, self.row, self.col, self.data, B.ravel())
+        coo_todense(M, N, self.nnz, self.row, self.col, self.data,
+                    B.ravel(order='A'), fortran)
         return B
 
     def tocsc(self):

scipy/sparse/dok.py

@@ -540,8 +540,9 @@ def tocsc(self):
         """ Return a copy of this matrix in Compressed Sparse Column format"""
         return self.tocoo().tocsc()
 
-    def toarray(self):
-        return self.tocoo().toarray()
+    def toarray(self, order=None, out=None):
+        """See the docstring for `spmatrix.toarray`."""
+        return self.tocoo().toarray(order=order, out=out)
 
     def resize(self, shape):
         """ Resize the matrix in-place to dimensions given by 'shape'.

scipy/sparse/lil.py

@@ -431,8 +431,9 @@ def reshape(self,shape):
                 new[new_r,new_c] = self[i,j]
         return new
 
-    def toarray(self):
-        d = np.zeros(self.shape, dtype=self.dtype)
+    def toarray(self, order=None, out=None):
+        """See the docstring for `spmatrix.toarray`."""
+        d = self._process_toarray_args(order, out)
         for i, row in enumerate(self.rows):
             for pos, j in enumerate(row):
                 d[i, j] = self.data[i][pos]

scipy/sparse/sparsetools/coo.h

@@ -109,10 +109,18 @@ void coo_todense(const I n_row,
                  const I Ai[],
                  const I Aj[],
                  const T Ax[],
-                       T Bx[])
+                       T Bx[],
+		 int fortran)
 {
-    for(I n = 0; n < nnz; n++){
-        Bx[ n_col * Ai[n] + Aj[n] ] += Ax[n];
+    if (!fortran) {
+        for(I n = 0; n < nnz; n++){
+            Bx[ n_col * Ai[n] + Aj[n] ] += Ax[n];
+        }
+    }
+    else {
+        for(I n = 0; n < nnz; n++){
+            Bx[ n_row * Aj[n] + Ai[n] ] += Ax[n];
+        }
     }
 }