Note: This page has been translated by MathWorks. Click here to see

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

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`

.

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.