# sprand

sparse random matrix

## Calling Sequence

    sp=sprand(nrows,ncols,density [,typ])

## Arguments

nrows

  integer (number of rows)

ncols

  integer (number of columns)

density

  filling coefficient (density)

typ

  character string, `"uniform"` (default) or `"normal"`

sp

  sparse matrix

## Description

`sp=sprand(nrows,ncols,density)` returns a sparse matrix `sp` with `nrows` rows, `ncols` columns and approximately `density*nrows*ncols` non-zero entries.

The `density` parameter is expected to be in the `[0,1]` interval. If not, it is automatically projected into this interval. Therefore, using a density which is lower than 0 or greater than 1 will generate neither an error, nor a warning: the formula `density=max(min(density,1),0)` is used.

If `typ="uniform"` uniformly distributed values on [0,1] are generated. If `typ="normal"` normally distributed values are generated (mean=0 and standard deviation=1).

The entries of the output matrix are computed from the given distribution function `typ`. The indices of the non-zeros entries are computed randomly, so that the average number of nonzeros is equal to `density`. The actual indices values are computed from the exponential distribution function, where the parameter of the distribution function is computed accordingly.

## Examples

In the following example, we generate a 100x1000 sparse matrix with approximate density 0.001, i.e. with approximately 100*1000*0.001=100 nonzero entries.

    // The entries of the matrix are uniform.
    W=sprand(100,1000,0.001);
    // The entries of the matrix are normal.
    W=sprand(100,1000,0.001,"normal");

In the following script, we check that the entries of the matrix have the expected distribution. We use the spget function in order to get the nonzero entries. Then we compute the min, mean and max of the entries and compare them with the limit values.

    typ = "normal";
    // typ = "uniform";
    nrows = 1000;
    ncols = 2000;
    density = 1/100;
    s=sprand(nrows,ncols,density,typ);
    nnzs=nnz(s);
    [ij,v]=spget(s);
    [%inf -%inf 0 %inf 1] // Limit values for "normal"
    [nnzs min(v) mean(v) max(v) variance(v)]
    [%inf 0 0.5 1 1/12] // Limit values for "uniform"

In the following script, we check that the entry indices, which are also chosen at random, have the correct distribution. We generate `kmax` sparse random matrices with uniform distribution. For each matrix, we consider the indices of the nonzero entries which were generated, i.e. we see if the event `Aij = {the entry (i,j) is nonzero}` occurred for each `i` and `j`, for `i=1,2,...,nrows` and `j=1,2,...,ncols`. The matrix `C(i,j)` stores the number of times that the event `Aij` occurred. The matrix `R(k)` stores the actual density of the try number `k`, where `k=1,2,...,kmax`.

        kmax = 1000;
        ncols=10;
        nrows=15;
        density=0.01;
        typ="uniform";
        C=zeros(nrows,ncols);
        R=[];
        for k=1:kmax
          M=sprand(nrows,ncols,density,typ);
          NZ=find(M<>0);
          NZratio = size(NZ,"*")/(nrows*ncols);
          R=[R NZratio];
          C(NZ)=C(NZ)+1;
        end

Now that this algorithm has been performed (which may require some time), we can compute elementary statistics to check that the algorithm performed well.

      // The expectation of A_ij is
      density * kmax
      // Compare this with the actual events :
      C
      // The average number should be close to the expectation.
      [density*kmax mean(C)]
      // The density should be close to expected density
      [density mean(R)]

## See Also

- sparse
- full
- rand
- speye