Add a helper method to validate the storage of a sparse matrix.

Author: wo80

CSparse.Tests/HelperTest.cs

@@ -1,6 +1,7 @@
 
 namespace CSparse.Tests
 {
+    using CSparse.Double;
     using NUnit.Framework;
 
     using C = System.Numerics.Complex;
@@ -33,5 +34,36 @@ public void TestTrimStorage()
             Assert.That(A.RowIndices.Length, Is.EqualTo(0));
             Assert.That(A.Values.Length, Is.EqualTo(0));
         }
+
+        [Test]
+        public void TestValidateStorage()
+        {
+            var ap = new int[] { 0, 3, 6 };
+            var ai = new int[] { 0, 1, 2, 0, 1, 2 };
+            var ax = new double[] { 0, 0, 0, 0, 0, 0 };
+
+            var A = new SparseMatrix(3, 2, ax, ai, ap);
+
+            Assert.That(Helper.ValidateStorage(A), Is.True);
+
+            // Change order of column pointers.
+            ap[1] = 6; ap[2] = 3;
+
+            Assert.That(Helper.ValidateStorage(A), Is.False);
+
+            // Revert change to column pointers.
+            ap[1] = 3; ap[2] = 6;
+
+            // Row index larger than number of rows.
+            ai[2] = 3;
+
+            Assert.That(Helper.ValidateStorage(A), Is.False);
+
+            // Change order of row indices.
+            ai[1] = 2; ai[2] = 1;
+
+            Assert.That(Helper.ValidateStorage(A), Is.True);
+            Assert.That(Helper.ValidateStorage(A, true), Is.False);
+        }
     }
 }

CSparse/Helper.cs

@@ -31,6 +31,52 @@ public static int CumulativeSum(int[] sum, int[] counts, int size)
             return nz;
         }
 
+        /// <summary>
+        /// Validate the structure of the <see cref="CompressedColumnStorage{T}"/>.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="storage">The storage to validate.</param>
+        /// <param name="strict">If true, row indices have to be ordered and no duplicate indices are allowed (default = <c>false</c>).</param>
+        /// <returns>Returns true if the structure of the storage is valid.</returns>
+        public static bool ValidateStorage<T>(CompressedColumnStorage<T> storage, bool strict = false)
+            where T : struct, IEquatable<T>, IFormattable
+        {
+            int rows = storage.RowCount;
+            int columns = storage.ColumnCount;
+
+            var ap = storage.ColumnPointers;
+            var ai = storage.RowIndices;
+
+            for (int i = 0; i < columns; i++)
+            {
+                int j = ap[i];
+                int end = ap[i + 1];
+
+                // Check if column pointers are in ascending order.
+                if (j > end)
+                {
+                    return false;
+                }
+
+                for (; j < end; j++)
+                {
+                    // Check if row indices are within bounds.
+                    if (ai[j] < 0 || ai[j] >= rows)
+                    {
+                        return false;
+                    }
+
+                    // Check if row indices are in order.
+                    if (strict && ai[j] >= ai[j + 1])
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
         /// <summary>
         /// Trim row indices and values array of the storage to the exact size (non-zeros count).
         /// </summary>