//public abstract SparseColumnStorage<T> Permute(int[] perm, int[] qperm = null, bool symbolic = false); /// <summary> /// Permutes a sparse matrix, C = PAQ. /// </summary> /// <param name="pinv">Permutation vector of length m.</param> /// <param name="q">Permutation vector of length n.</param> /// <param name="result">Permuted matrix, C = PAQ.</param> public virtual void Permute(int[] pinv, int[] q, SymbolicColumnStorage result) { int i, j, k, nz = 0; int n = this.columnCount; int[] ap = this.ColumnPointers; int[] ai = this.RowIndices; // Allocate memory if needed. if (result.ColumnPointers == null) { result.ColumnPointers = new int[ap.Length]; result.RowIndices = new int[ai.Length]; } int[] cp = result.ColumnPointers; int[] ci = result.RowIndices; for (k = 0; k < n; k++) { cp[k] = nz; // column k of C is column q[k] of A j = q != null ? (q[k]) : k; for (i = ap[j]; i < ap[j + 1]; i++) { ci[nz++] = pinv != null ? (pinv[ai[i]]) : ai[i]; } } // Finalize the last column of result matrix. cp[n] = nz; }
public SymbolicColumnStorage Clone() { int m = this.RowCount; int n = this.ColumnCount; int nnz = this.NonZerosCount; var result = new SymbolicColumnStorage(m, n, nnz, true); Buffer.BlockCopy(this.ColumnPointers, 0, result.ColumnPointers, 0, (n + 1) * Constants.SizeOfInt); Buffer.BlockCopy(this.RowIndices, 0, result.RowIndices, 0, nnz * Constants.SizeOfInt); return(result); }
/// <summary> /// Sparse matrix multiplication, C = A*B /// </summary> /// <param name="other">column-compressed matrix</param> /// <returns>C = A*B</returns> public SymbolicColumnStorage Multiply(SymbolicColumnStorage other) { int p, j, nz = 0; if (this.columnCount != other.rowCount) { throw new ArgumentException(); } int m = this.rowCount; int n = other.columnCount; int anz = this.NonZerosCount; int bnz = other.NonZerosCount; var bp = other.ColumnPointers; var bi = other.RowIndices; var result = new SymbolicColumnStorage(m, n, 0, false); var cp = new int[n + 1]; var ci = new int[2 * Math.Max(anz, bnz)]; int[] work = new int[m]; for (j = 0; j < n; j++) { if (nz + m > ci.Length) { Array.Resize(ref ci, 2 * ci.Length + m); } // Column j of C starts here cp[j] = nz; for (p = bp[j]; p < bp[j + 1]; p++) { nz = this.Scatter(bi[p], work, j + 1, ci, nz); } } cp[n] = nz; // Remove extra space from C Array.Resize(ref ci, nz); result.ColumnPointers = cp; result.RowIndices = ci; return(result); }
/// <summary> /// Symbolic sum C = A + B /// </summary> /// <param name="other">column-compressed matrix</param> /// <returns>Sum C = A + B</returns> public SymbolicColumnStorage Add(SymbolicColumnStorage other) { int j, nz = 0; // check inputs if (rowCount != other.rowCount || columnCount != other.columnCount) { throw new ArgumentException(); } int m = rowCount; int n = other.columnCount; var bi = other.ColumnPointers; int anz = ColumnPointers[columnCount]; int bnz = bi[n]; // Workspace var w = new int[m]; // Allocate result: (anz + bnz) is an upper bound var cp = new int[bi.Length]; var ci = new int[anz + bnz]; for (j = 0; j < n; j++) { // Column j of result starts here cp[j] = nz; nz = this.Scatter(j, w, j + 1, ci, nz); // A(:,j) nz = other.Scatter(j, w, j + 1, ci, nz); // B(:,j) } // Finalize the last column cp[n] = nz; // Remove extra space Array.Resize(ref ci, nz); var result = new SymbolicColumnStorage(m, n, 0, false); result.ColumnPointers = cp; result.RowIndices = ci; return(result); }
internal static SymbolicColumnStorage Create <T>(CompressedColumnStorage <T> mat, bool allocate = true) where T : struct, IEquatable <T>, IFormattable { int m = mat.RowCount; int n = mat.ColumnCount; int nnz = mat.NonZerosCount; var result = new SymbolicColumnStorage(m, n, nnz, allocate); if (allocate) { Buffer.BlockCopy(mat.ColumnPointers, 0, result.ColumnPointers, 0, (n + 1) * Constants.SizeOfInt); Buffer.BlockCopy(mat.RowIndices, 0, result.RowIndices, 0, nnz * Constants.SizeOfInt); } else { result.ColumnPointers = mat.ColumnPointers; result.RowIndices = mat.RowIndices; } return(result); }
/// <summary> /// Computes the transpose of a sparse matrix, C = A'; /// </summary> /// <returns>Transposed matrix, C = A'</returns> public virtual SymbolicColumnStorage Transpose() { int j, k, p; int m = this.RowCount; int n = this.ColumnCount; var result = new SymbolicColumnStorage(n, m, 0, false); var ci = new int[m + 1]; var cj = new int[RowIndices.Length]; int[] w = new int[rowCount]; for (p = 0; p < ColumnPointers[columnCount]; p++) { // Row counts. w[RowIndices[p]]++; } // Column pointers. Helper.CumulativeSum(ci, w, rowCount); for (j = 0; j < columnCount; j++) { for (p = ColumnPointers[j]; p < ColumnPointers[j + 1]; p++) { k = w[RowIndices[p]]++; // Place A(i,j) as entry C(j,i) cj[k] = j; } } result.ColumnPointers = ci; result.RowIndices = cj; return(result); }