Fix coordinate storage in-place conversion.

Author: wo80

CSparse.Tests/Double/SparseMatrixTest.cs

@@ -506,6 +506,34 @@ public void TestOfIndexed_Coo(int rows, int columns)
             Assert.IsNull(coo.ColumnIndices);
         }
 
+        [Test]
+        public void TestOfIndexed_Coo_InPlace()
+        {
+            // rows > columns
+
+            var coo = new CoordinateStorage<double>(10, 5, 3);
+
+            coo.At(0, 0, 1.0);
+            coo.At(1, 1, 1.0);
+            coo.At(4, 4, 1.0);
+
+            var A = SparseMatrix.OfIndexed(coo, true);
+
+            Assert.AreEqual(3, A.NonZerosCount);
+
+            // rows < columns
+
+            coo = new CoordinateStorage<double>(5, 10, 3);
+
+            coo.At(0, 0, 1.0);
+            coo.At(1, 1, 1.0);
+            coo.At(4, 4, 1.0);
+
+            A = SparseMatrix.OfIndexed(coo, true);
+
+            Assert.AreEqual(3, A.NonZerosCount);
+        }
+
         [Test]
         public void TestOfIndexed_Empty()
         {

CSparse/CSparse.csproj

@@ -11,19 +11,19 @@
     <Company />
     <Copyright>Copyright Christian Woltering © 2012-2020</Copyright>
     <Authors>Christian Woltering</Authors>
-    <AssemblyVersion>3.4.7.0</AssemblyVersion>
-    <FileVersion>3.4.7.0</FileVersion>
+    <AssemblyVersion>3.4.9.0</AssemblyVersion>
+    <FileVersion>3.4.9.0</FileVersion>
     <PackageTags>math sparse matrix lu cholesky qr decomposition factorization </PackageTags>
-    <Version>3.4.7</Version>
+    <Version>3.4.9</Version>
     <AssemblyName>CSparse</AssemblyName>
     <RootNamespace>CSparse</RootNamespace>
     <PackageLicenseExpression>LGPL-2.1-only</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/wo80/CSparse.NET</PackageProjectUrl>
     <RepositoryUrl>https://github.com/wo80/CSparse.NET</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <PackageReleaseNotes>* BREAKING: make SparseLDL constructor private (use static create methods instead).
-* Add complex version of SparseLDL.
-* Add matrix.EnumerateIndexed(action) overload.</PackageReleaseNotes>
+    <PackageReleaseNotes>Coordinate storage improvements:
+* Add constructor that uses existing arrays for storage.
+* Convert to sparse matrix in place.</PackageReleaseNotes>
   </PropertyGroup>
 
   <ItemGroup>

CSparse/Converter.cs

@@ -35,23 +35,25 @@ internal static CompressedColumnStorage<T> ToCompressedColumnStorage_<T>(Coordin
             int nrows = storage.RowCount;
             int ncols = storage.ColumnCount;
 
-            var values = storage.Values;
-            var rowind = storage.RowIndices;
-            var colind = storage.ColumnIndices;
+            int nz = storage.NonZerosCount;
 
             var result = CompressedColumnStorage<T>.Create(nrows, ncols);
 
-            int nz = storage.NonZerosCount;
+            var ap = result.ColumnPointers = new int[ncols + 1];
 
-            if (inplace)
+            if (nz == 0)
             {
-                var work = new int[ncols + 1];
+                return result;
+            }
 
-                ConvertInPlace(ncols, nz, values, rowind, colind, work);
+            var values = storage.Values;
+            var rowind = storage.RowIndices;
+            var colind = storage.ColumnIndices;
 
-                Array.Copy(colind, work, ncols + 1);
+            if (inplace)
+            {
+                ConvertInPlace(ncols, nz, values, rowind, colind, ap);
 
-                result.ColumnPointers = work;
                 result.RowIndices = rowind;
                 result.Values = values;
 
@@ -60,7 +62,6 @@ internal static CompressedColumnStorage<T> ToCompressedColumnStorage_<T>(Coordin
             }
             else
             {
-                var columnPointers = new int[ncols + 1];
                 var columnCounts = new int[ncols];
 
                 for (int k = 0; k < nz; k++)
@@ -70,21 +71,20 @@ internal static CompressedColumnStorage<T> ToCompressedColumnStorage_<T>(Coordin
                 }
 
                 // Get column pointers
-                int valueCount = Helper.CumulativeSum(columnPointers, columnCounts, ncols);
+                int valueCount = Helper.CumulativeSum(ap, columnCounts, ncols);
 
-                var rowIndices = new int[valueCount];
-                var storageValues = new T[valueCount];
+                var ai = new int[valueCount];
+                var ax = new T[valueCount];
 
                 for (int k = 0; k < nz; k++)
                 {
                     int p = columnCounts[colind[k]]++;
-                    rowIndices[p] = rowind[k];
-                    storageValues[p] = values[k];
+                    ai[p] = rowind[k];
+                    ax[p] = values[k];
                 }
 
-                result.RowIndices = rowIndices;
-                result.ColumnPointers = columnPointers;
-                result.Values = storageValues;
+                result.RowIndices = ai;
+                result.Values = ax;
             }
 
             Helper.SortIndices(result);
@@ -182,10 +182,13 @@ private static void ConvertInPlace<T>(int columns, int nz, T[] values, int[] row
                 // Restart chasing.
             }
 
-            colind[0] = 0;
+            // Fix column pointers.
+            for (i = columns - 1; i > 0; i--)
+            {
+                work[i] = work[i - 1];
+            }
 
-            // Copy column pointers.
-            Array.Copy(work, 0, colind, 1, columns);
+            work[0] = 0;
         }
 
         /// <summary>