Sparse¶

Sparse Linear Algebra Interface¶

LinearAlgebra.Sparse follows the same conventions and interface choices as the parent module, LinearAlgebra, with few exceptions. These exceptions are detailed below.

Sparse Domains

In Chapel, changes to the index set of a sparse array must be made directly on the sparse domain. When working with sparse arrays that will require index modification, it is necessary to maintain access to their sparse domains as well. As a result of this, the sparse linear algebra interface provides helper functions for creating both sparse domains and sparse arrays.

A common usage of this interface might look like this:

// Create an empty 3x3 CSR domain
var D = CSRDomain(3,3);

// Create a CSR matrix over this domain
var A = CSRMatrix(D, int);
// The above is equivalent to:
// var A: [D] int;

// Add indices to the sparse domain along the diagonal
D += (0,0);
D += (1,1);
D += (2,2);

// Set all nonzero indices to the value of 1
A = 1;

// A is now a 3x3 sparse identity matrix
writeln(A);

proc CSRDomain(rows)¶

Return an empty CSR domain over parent domain: {1..rows, 1..rows}

proc CSRDomain(rows, cols)

Return an empty CSR domain over parent domain: {1..rows, 1..cols}

proc CSRDomain(space: range)

Return an empty CSR domain over parent domain: {space, space}

proc CSRDomain(rowSpace: range, colSpace: range)

Return an empty CSR domain over parent domain: {rowSpace, colSpace}

proc CSRDomain(Dom: domain)

Return a CSR domain based on domain: Dom

If Dom is dense, it will be interpreted as the parent domain, and the domain returned will be empty.

If Dom is sparse (CSR), the domain returned will contain the same nonzeros as Dom

proc CSRMatrix(Dom: domain, type eltType = real)¶

Return a CSR matrix over domain: Dom

If Dom is dense, it will be interpreted as the parent domain, and the matrix returned will be empty.

If Dom is sparse (CSR), the matrix returned will contain the same nonzeros as Dom

proc CSRMatrix(A: [?Dom] ?Atype, type eltType = Atype)

Return a CSR matrix with domain and values of A

If A is dense, only the indices holding nonzero elements are added to the sparse matrix returned.

If A is sparse (CSR), the returned sparse matrix will be a copy of A casted to eltType

proc CSRMatrix(shape: 2*(int), data: [?nnzDom] ?eltType, indices: [nnzDom], indptr: [?indDom])

Return a CSR matrix constructed from internal representation:

• shape: bounding box dimensions
• data: non-zero element values
• indices: non-zero row pointers
• indptr: index pointers

proc CSRDomain(shape: 2*(int), indices: [?nnzDom], indptr: [?indDom])

Return a CSR domain constructed from internal representation

proc dot(A: [?Adom] ?eltType, B: [?Bdom] eltType)¶

Generic matrix multiplication, A and B can be a scalar, dense vector, or sparse matrix.

When A is a vector and B is a matrix, this function implicitly computes dot(transpose(A), B), which may not be as efficient as passing A and B in the reverse order.

proc _array.dot(A: [])¶

Compute the dot-product

proc _array.dot(a)

Compute the dot-product

proc pass1(ref A: [?ADom] ?eltType, ref B: [?BDom] eltType, ref indPtr)¶

Populate indPtr and total nnz (last element of indPtr)

proc pass2(ref A: [?ADom] ?eltType, ref B: [?BDom] eltType, ref indPtr, ref indices, ref data)¶

Populate indices and data

proc transpose(D: domain)¶

Transpose CSR domain

proc transpose(A: [?Adom] ?eltType)

Transpose CSR matrix

proc _array.T¶

Transpose CSR matrix

proc _array.plus(A)¶

Element-wise addition

proc _array.minus(A)¶

Element-wise subtraction

proc _array.times(A)¶

Element-wise multiplication

proc _array.elementDiv(A)¶

Element-wise division

proc eye(Dom, type eltType = real)¶

Return an identity matrix over sparse domain Dom