using System; using MathNet.Numerics.Properties; namespace MathNet.Numerics.LinearAlgebra.Storage { internal class SparseCompressedRowMatrixStorage where T : struct, IEquatable, IFormattable { // [ruegg] public fields are OK here public readonly int RowCount; public readonly int ColumnCount; readonly T _zero; /// /// The array containing the row indices of the existing rows. Element "j" of the array gives the index of the /// element in the array that is first non-zero element in a row "j" /// public readonly int[] RowPointers; /// /// An array containing the column indices of the non-zero values. Element "I" of the array /// is the number of the column in matrix that contains the I-th value in the array. /// public int[] ColumnIndices; /// /// Array that contains the non-zero elements of matrix. Values of the non-zero elements of matrix are mapped into the values /// array using the row-major storage mapping described in a compressed sparse row (CSR) format. /// public T[] Values; /// /// Gets the number of non zero elements in the matrix. /// /// The number of non zero elements. public int ValueCount; internal SparseCompressedRowMatrixStorage(int rows, int columns, T zero) { RowCount = rows; ColumnCount = columns; _zero = zero; RowPointers = new int[rows]; ColumnIndices = new int[0]; Values = new T[0]; ValueCount = 0; } public T this[int row, int column] { get { return GetValueAt(row, column); } set { SetValueAt(row, column, value); } } public void Clear() { ValueCount = 0; Array.Clear(RowPointers, 0, RowPointers.Length); } /// /// Retrieves the requested element without range checking. /// /// /// The row of the element. /// /// /// The column of the element. /// /// /// The requested element. /// public T GetValueAt(int row, int column) { var index = FindItem(row, column); return index >= 0 ? Values[index] : _zero; } /// /// Created this method because we cannot call "virtual At" in constructor of the class, but we need to do it /// /// The row of the element. /// The column of the element. /// The value to set the element to. /// WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks public void SetValueAt(int row, int column, T value) { var index = FindItem(row, column); if (index >= 0) { // Non-zero item found in matrix if (_zero.Equals(value)) { // Delete existing item DeleteItemByIndex(index, row); } else { // Update item Values[index] = value; } } else { // Item not found. Add new value if (_zero.Equals(value)) { return; } index = ~index; // Check if the storage needs to be increased if ((ValueCount == Values.Length) && (ValueCount < ((long)RowCount * ColumnCount))) { // Value array is completely full so we increase the size // Determine the increase in size. We will not grow beyond the size of the matrix var size = Math.Min(Values.Length + GrowthSize(), (long)RowCount * ColumnCount); if (size > int.MaxValue) { throw new NotSupportedException(Resources.TooManyElements); } Array.Resize(ref Values, (int)size); Array.Resize(ref ColumnIndices, (int)size); } // Move all values (with an position larger than index) in the value array to the next position // move all values (with an position larger than index) in the columIndices array to the next position for (var i = ValueCount - 1; i > index - 1; i--) { Values[i + 1] = Values[i]; ColumnIndices[i + 1] = ColumnIndices[i]; } // Add the value and the column index Values[index] = value; ColumnIndices[index] = column; // increase the number of non-zero numbers by one ValueCount += 1; // add 1 to all the row indices for rows bigger than rowIndex // so that they point to the correct part of the value array again. for (var i = row + 1; i < RowPointers.Length; i++) { RowPointers[i] += 1; } } } /// /// Delete value from internal storage /// /// Index of value in nonZeroValues array /// Row number of matrix /// WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks private void DeleteItemByIndex(int itemIndex, int row) { // Move all values (with an position larger than index) in the value array to the previous position // move all values (with an position larger than index) in the columIndices array to the previous position for (var i = itemIndex + 1; i < ValueCount; i++) { Values[i - 1] = Values[i]; ColumnIndices[i - 1] = ColumnIndices[i]; } // Decrease value in Row for (var i = row + 1; i < RowPointers.Length; i++) { RowPointers[i] -= 1; } ValueCount -= 1; // Check if the storage needs to be shrink. This is reasonable to do if // there are a lot of non-zero elements and storage is two times bigger if ((ValueCount > 1024) && (ValueCount < Values.Length / 2)) { Array.Resize(ref Values, ValueCount); Array.Resize(ref ColumnIndices, ValueCount); } } /// /// Find item Index in nonZeroValues array /// /// Matrix row index /// Matrix column index /// Item index /// WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks public int FindItem(int row, int column) { // Determin bounds in columnIndices array where this item should be searched (using rowIndex) var startIndex = RowPointers[row]; var endIndex = row < RowPointers.Length - 1 ? RowPointers[row + 1] : ValueCount; return Array.BinarySearch(ColumnIndices, startIndex, endIndex - startIndex, column); } /// /// Calculates the amount with which to grow the storage array's if they need to be /// increased in size. /// /// The amount grown. private int GrowthSize() { int delta; if (Values.Length > 1024) { delta = Values.Length / 4; } else { if (Values.Length > 256) { delta = 512; } else { delta = Values.Length > 64 ? 128 : 32; } } return delta; } } }