## Constructing Sparse Matrices

### Creating Sparse Matrices

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));`
or
`nnz(M) / numel(M);`

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

#### Converting Full to Sparse

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.

#### Creating Sparse Matrices Directly

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 from Their Diagonal Elements

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.

### Importing Sparse Matrices

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.