Remove methods marked as obsolete from Converter class.

Author: wo80

CSparse/Converter.cs

@@ -7,29 +7,16 @@ namespace CSparse
     /// <summary>
     /// Converter for different types of storages.
     /// </summary>
-    public static class Converter
+    internal static class Converter
     {
-        /// <summary>
-        /// Convert a coordinate storage to compressed sparse column (CSC) format.
-        /// </summary>
-        /// <param name="storage">Coordinate storage.</param>
-        /// <param name="cleanup">Remove and sum duplicate entries.</param>
-        /// <returns>Compressed sparse column storage.</returns>
-        [Obsolete("Will be removed in future versions. Use SparseMatrix.OfIndexed(...) instead.")]
-        public static CompressedColumnStorage<T> ToCompressedColumnStorage<T>(CoordinateStorage<T> storage,
-            bool cleanup = true) where T : struct, IEquatable<T>, IFormattable
-        {
-            return ToCompressedColumnStorage_(storage, cleanup);
-        }
-
         /// <summary>
         /// Convert a coordinate storage to compressed sparse column (CSC) format.
         /// </summary>
         /// <param name="storage">Coordinate storage.</param>
         /// <param name="cleanup">Remove and sum duplicate entries.</param>
         /// <param name="inplace">Do the conversion in place (re-using the coordinate storage arrays).</param>
         /// <returns>Compressed sparse column storage.</returns>
-        internal static CompressedColumnStorage<T> ToCompressedColumnStorage_<T>(CoordinateStorage<T> storage,
+        public static CompressedColumnStorage<T> ToCompressedColumnStorage<T>(CoordinateStorage<T> storage,
                 bool cleanup = true, bool inplace = false) where T : struct, IEquatable<T>, IFormattable
         {
             int nrows = storage.RowCount;
@@ -110,7 +97,7 @@ internal static CompressedColumnStorage<T> ToCompressedColumnStorage_<T>(Coordin
         /// <remarks>
         /// On return, the coordinate storage input arrays contain the compressed sparse
         /// column data structure for the resulting matrix. The <paramref name="work"/>
-        /// array contains a copy of the column pointer.
+        /// array contains a copy of the column pointers.
         /// 
         /// The entries of the output matrix are not sorted (the row indices in each
         /// column are not in increasing order).
@@ -193,15 +180,8 @@ private static void ConvertInPlace<T>(int columns, int nz, T[] values, int[] row
         /// </summary>
         /// <param name="array">2D array storage.</param>
         /// <returns>Coordinate storage.</returns>
-        [Obsolete("Will be removed in future versions. Use SparseMatrix.OfArray(...) instead.")]
         public static CoordinateStorage<T> FromDenseArray<T>(T[,] array)
             where T : struct, IEquatable<T>, IFormattable
-        {
-            return FromDenseArray_(array);
-        }
-
-        internal static CoordinateStorage<T> FromDenseArray_<T>(T[,] array)
-            where T : struct, IEquatable<T>, IFormattable
         {
             int rowCount = array.GetLength(0);
             int columnCount = array.GetLength(1);
@@ -219,48 +199,15 @@ internal static CoordinateStorage<T> FromDenseArray_<T>(T[,] array)
             return storage;
         }
 
-        /// <summary>
-        /// Convert a jagged array to compressed sparse column (CSC) format.
-        /// </summary>
-        /// <param name="array">Jagged array storage.</param>
-        /// <returns>Compressed sparse column storage.</returns>
-        [Obsolete("Will be removed in future versions. Use SparseMatrix.OfJaggedArray(...) instead.")]
-        public static CompressedColumnStorage<T> ToCompressedColumnStorage<T>(T[][] array)
-            where T : struct, IEquatable<T>, IFormattable
-        {
-            int nrows = array.Length;
-            int ncols = array[0].Length;
-
-            var storage = new CoordinateStorage<T>(nrows, ncols, nrows);
-
-            for (int i = 0; i < nrows; i++)
-            {
-                for (int j = 0; j < ncols; j++)
-                {
-                    storage.At(i, j, array[i][j]);
-                }
-            }
-
-            return ToCompressedColumnStorage_<T>(storage, false);
-        }
-
-
         /// <summary>
         /// Convert a column major array to coordinate storage.
         /// </summary>
         /// <param name="array">Column major array storage.</param>
         /// <param name="rowCount">Number of rows.</param>
         /// <param name="columnCount">Number of columns.</param>
         /// <returns>Coordinate storage.</returns>
-        [Obsolete("Will be removed in future versions. Use SparseMatrix.OfColumnMajor(...) instead.")]
         public static CoordinateStorage<T> FromColumnMajorArray<T>(T[] array, int rowCount, int columnCount)
             where T : struct, IEquatable<T>, IFormattable
-        {
-            return FromColumnMajorArray_(array, rowCount, columnCount);
-        }
-
-        internal static CoordinateStorage<T> FromColumnMajorArray_<T>(T[] array, int rowCount, int columnCount)
-            where T : struct, IEquatable<T>, IFormattable
         {
             var storage = new CoordinateStorage<T>(rowCount, columnCount, Math.Max(rowCount, columnCount));
 
@@ -281,15 +228,8 @@ internal static CoordinateStorage<T> FromColumnMajorArray_<T>(T[] array, int row
         /// <param name="array">jagged array storage.</param>
         /// <returns>Coordinate storage.</returns>
         /// <remarks>All rows of the array are assumed to be equal in length</remarks>
-        [Obsolete("Will be removed in future versions. Use SparseMatrix.OfColumnMajor(...) instead.")]
         public static CoordinateStorage<T> FromJaggedArray<T>(T[][] array)
             where T : struct, IEquatable<T>, IFormattable
-        {
-            return FromJaggedArray_(array);
-        }
-
-        internal static CoordinateStorage<T> FromJaggedArray_<T>(T[][] array)
-            where T : struct, IEquatable<T>, IFormattable
         {
             int rowCount = array.Length;
             int columnCount = array[0].Length;
@@ -314,15 +254,8 @@ internal static CoordinateStorage<T> FromJaggedArray_<T>(T[][] array)
         /// <param name="rowCount">Number of rows.</param>
         /// <param name="columnCount">Number of columns.</param>
         /// <returns>Coordinate storage.</returns>
-        [Obsolete("Will be removed in future versions. Use SparseMatrix.OfRowMajor(...) instead.")]
         public static CoordinateStorage<T> FromRowMajorArray<T>(T[] array, int rowCount, int columnCount)
             where T : struct, IEquatable<T>, IFormattable
-        {
-            return FromRowMajorArray_(array, rowCount, columnCount);
-        }
-
-        internal static CoordinateStorage<T> FromRowMajorArray_<T>(T[] array, int rowCount, int columnCount)
-            where T : struct, IEquatable<T>, IFormattable
         {
             var storage = new CoordinateStorage<T>(rowCount, columnCount, Math.Max(rowCount, columnCount));
 
@@ -344,15 +277,8 @@ internal static CoordinateStorage<T> FromRowMajorArray_<T>(T[] array, int rowCou
         /// <param name="rowCount">Number of rows.</param>
         /// <param name="columnCount">Number of columns.</param>
         /// <returns>Coordinate storage.</returns>
-        [Obsolete("Will be removed in future versions. Use SparseMatrix.OfIndexed(...) instead.")]
         public static CoordinateStorage<T> FromEnumerable<T>(IEnumerable<Tuple<int, int, T>> enumerable, int rowCount, int columnCount)
             where T : struct, IEquatable<T>, IFormattable
-        {
-            return FromEnumerable_(enumerable, rowCount, columnCount);
-        }
-
-        internal static CoordinateStorage<T> FromEnumerable_<T>(IEnumerable<Tuple<int, int, T>> enumerable, int rowCount, int columnCount)
-            where T : struct, IEquatable<T>, IFormattable
         {
             var storage = new CoordinateStorage<T>(rowCount, columnCount, Math.Max(rowCount, columnCount));
 

CSparse/Storage/CompressedColumnStorage.cs

@@ -110,67 +110,67 @@ public CompressedColumnStorage(int rowCount, int columnCount, T[] values, int[]
         /// </summary>
         public static CompressedColumnStorage<T> OfMatrix(Matrix<T> matrix)
         {
-            var c = Converter.FromEnumerable_<T>(matrix.EnumerateIndexed(), matrix.RowCount, matrix.ColumnCount);
+            var c = Converter.FromEnumerable<T>(matrix.EnumerateIndexed(), matrix.RowCount, matrix.ColumnCount);
 
-            return Converter.ToCompressedColumnStorage_(c);
+            return Converter.ToCompressedColumnStorage(c);
         }
 
         /// <summary>
         /// Create a new sparse matrix as a copy of the given two-dimensional array.
         /// </summary>
         public static CompressedColumnStorage<T> OfArray(T[,] array)
         {
-            var c = Converter.FromDenseArray_(array);
+            var c = Converter.FromDenseArray(array);
 
-            return Converter.ToCompressedColumnStorage_(c);
+            return Converter.ToCompressedColumnStorage(c);
         }
 
         /// <summary>
         /// Create a new sparse matrix as a copy of the given two-dimensional array.
         /// </summary>
         public static CompressedColumnStorage<T> OfJaggedArray(T[][] array)
         {
-            var c = Converter.FromJaggedArray_(array);
+            var c = Converter.FromJaggedArray(array);
 
-            return Converter.ToCompressedColumnStorage_(c);
+            return Converter.ToCompressedColumnStorage(c);
         }
 
         /// <summary>
         /// Create a new sparse matrix as a copy of the given coordinate storage.
         /// </summary>
         public static CompressedColumnStorage<T> OfIndexed(CoordinateStorage<T> coordinateStorage, bool inplace = false)
         {
-            return Converter.ToCompressedColumnStorage_(coordinateStorage, true, inplace);
+            return Converter.ToCompressedColumnStorage(coordinateStorage, true, inplace);
         }
 
         /// <summary>
         /// Create a new sparse matrix as a copy of the given indexed enumerable.
         /// </summary>
         public static CompressedColumnStorage<T> OfIndexed(int rows, int columns, IEnumerable<Tuple<int, int, T>> enumerable)
         {
-            var c = Converter.FromEnumerable_<T>(enumerable, rows, columns);
+            var c = Converter.FromEnumerable<T>(enumerable, rows, columns);
 
-            return Converter.ToCompressedColumnStorage_(c);
+            return Converter.ToCompressedColumnStorage(c);
         }
 
         /// <summary>
         /// Create a new sparse matrix as a copy of the given array (row-major).
         /// </summary>
         public static CompressedColumnStorage<T> OfRowMajor(int rows, int columns, T[] rowMajor)
         {
-            var c = Converter.FromRowMajorArray_<T>(rowMajor, rows, columns);
+            var c = Converter.FromRowMajorArray<T>(rowMajor, rows, columns);
 
-            return Converter.ToCompressedColumnStorage_(c);
+            return Converter.ToCompressedColumnStorage(c);
         }
 
         /// <summary>
         /// Create a new sparse matrix as a copy of the given array (column-major).
         /// </summary>
         public static CompressedColumnStorage<T> OfColumnMajor(int rows, int columns, T[] columnMajor)
         {
-            var c = Converter.FromColumnMajorArray_<T>(columnMajor, rows, columns);
+            var c = Converter.FromColumnMajorArray<T>(columnMajor, rows, columns);
 
-            return Converter.ToCompressedColumnStorage_(c);
+            return Converter.ToCompressedColumnStorage(c);
         }
 
         /// <summary>