Main Content

MATLAB^{®} never creates sparse matrices automatically. Instead, you must determine if a matrix contains
a large enough percentage of zeros to benefit from sparse techniques.

The *density* of a matrix is the number of nonzero elements divided
by the total number of matrix elements. For matrix `M`

, this would
be

nnz(M) / prod(size(M));

nnz(M) / numel(M);

Matrices with very low density are often good candidates for use of the sparse format.

You can convert a full matrix to sparse storage using the `sparse`

function with a single argument.

For example:

A = [ 0 0 0 5 0 2 0 0 1 3 0 0 0 0 4 0]; S = sparse(A)

S = (3,1) 1 (2,2) 2 (3,2) 3 (4,3) 4 (1,4) 5

The printed output lists the nonzero elements of `S`

, together with
their row and column indices. The elements are sorted by columns, reflecting the internal
data structure.

You can convert a sparse matrix to full storage using the `full`

function, provided the matrix order is not too large. For example, ```
A =
full(S)
```

reverses the example conversion.

Converting a full matrix to sparse storage is not the most frequent way of generating sparse matrices. If the order of a matrix is small enough that full storage is possible, then conversion to sparse storage rarely offers significant savings.

You can create a sparse matrix from a list of nonzero elements using the
`sparse`

function with five arguments.

S = sparse(i,j,s,m,n)

`i`

and `j`

are vectors of row and column indices,
respectively, for the nonzero elements of the matrix. `s`

is a vector of
nonzero values whose indices are specified by the corresponding `(i,j)`

pairs. `m`

is the row dimension of the resulting matrix, and
`n`

is the column dimension.

The matrix `S`

of the previous example can be generated directly
with

S = sparse([3 2 3 4 1],[1 2 2 3 4],[1 2 3 4 5],4,4)

S = (3,1) 1 (2,2) 2 (3,2) 3 (4,3) 4 (1,4) 5

The `sparse`

command has a number of alternate forms. The example
above uses a form that sets the maximum number of nonzero elements in the matrix to
`length(s)`

. If desired, you can append a sixth argument that specifies
a larger maximum, allowing you to add nonzero elements later without reallocating the
sparse matrix.

The matrix representation of the second difference operator is a good example of a sparse matrix. It is a tridiagonal matrix with -2s on the diagonal and 1s on the super- and subdiagonal. There are many ways to generate it—here's one possibility.

n = 5; D = sparse(1:n,1:n,-2*ones(1,n),n,n); E = sparse(2:n,1:n-1,ones(1,n-1),n,n); S = E+D+E'

S = (1,1) -2 (2,1) 1 (1,2) 1 (2,2) -2 (3,2) 1 (2,3) 1 (3,3) -2 (4,3) 1 (3,4) 1 (4,4) -2 (5,4) 1 (4,5) 1 (5,5) -2

Now `F = full(S)`

displays the corresponding full matrix.

F = full(S)

F = -2 1 0 0 0 1 -2 1 0 0 0 1 -2 1 0 0 0 1 -2 1 0 0 0 1 -2

Creating sparse matrices based on their diagonal elements is a common operation, so
the function `spdiags`

handles this task. Its syntax
is

S = spdiags(B,d,m,n)

To create an output matrix `S`

of size
*m*-by-*n* with elements on `p`

diagonals:

`B`

is a matrix of size`min(m,n)`

-by-*p*. The columns of`B`

are the values to populate the diagonals of`S`

.`d`

is a vector of length`p`

whose integer elements specify which diagonals of`S`

to populate.

That is, the elements in column `j`

of `B`

fill the
diagonal specified by element `j`

of `d`

.

**Note**

If a column of `B`

is longer than the diagonal it's replacing,
super-diagonals are taken from the lower part of the column of `B`

, and
sub-diagonals are taken from the upper part of the column of
`B`

.

As an example, consider the matrix `B`

and the vector
`d`

.

B = [ 41 11 0 52 22 0 63 33 13 74 44 24 ]; d = [-3 0 2];

Use these matrices to create a 7-by-4 sparse matrix `A`

:

A = spdiags(B,d,7,4)

A = (1,1) 11 (4,1) 41 (2,2) 22 (5,2) 52 (1,3) 13 (3,3) 33 (6,3) 63 (2,4) 24 (4,4) 44 (7,4) 74

In its full form, `A`

looks like this:

full(A)

ans = 11 0 13 0 0 22 0 24 0 0 33 0 41 0 0 44 0 52 0 0 0 0 63 0 0 0 0 74

`spdiags`

can also extract diagonal elements from a sparse matrix, or
replace matrix diagonal elements with new values. Type `help`

`spdiags`

for details.

You can import sparse matrices from computations outside the MATLAB environment.
Use the `spconvert`

function
in conjunction with the `load`

command to import
text files containing lists of indices and nonzero elements. For example,
consider a three-column text file `T.dat`

whose first
column is a list of row indices, second column is a list of column
indices, and third column is a list of nonzero values. These statements
load `T.dat`

into MATLAB and convert it into
a sparse matrix `S`

:

```
load T.dat
S = spconvert(T)
```

The `save`

and `load`

commands can also process sparse
matrices stored as binary data in MAT-files.