Cleanups

cdrnet · cdrnet · commit 67e4c8e04399 · 2021-05-24T14:39:59.000+02:00
diff --git a/src/Data.Matlab/Formatter.cs b/src/Data.Matlab/Formatter.cs
@@ -105,17 +105,17 @@ internal static MatlabMatrix FormatMatrix<T>(Matrix<T> matrix, string name)
         {
             if (matrix == null)
             {
-                throw new ArgumentNullException("matrix");
+                throw new ArgumentNullException(nameof(matrix));
             }
 
             if (string.IsNullOrEmpty(name))
             {
-                throw new ArgumentException("String parameter cannot be empty or null.", "name");
+                throw new ArgumentException("String parameter cannot be empty or null.", nameof(name));
             }
 
             if (name.IndexOf(' ') > -1)
             {
-                throw new ArgumentException(string.Format("Name cannot contain a space.name:  {0}", name), "name");
+                throw new ArgumentException($"Name cannot contain a space.name: {name}", nameof(name));
             }
 
             var dataType = typeof(T);
@@ -167,7 +167,7 @@ internal static MatlabMatrix FormatMatrix<T>(Matrix<T> matrix, string name)
                 writer.Write((byte)(sparse ? ArrayClass.Sparse : doublePrecision ? ArrayClass.Double : ArrayClass.Single));
                 writer.Write((byte)(complex ? ArrayFlags.Complex : 0));
                 writer.Write((short)0);
-                writer.Write((int)sparseNonZeroValues);
+                writer.Write(sparseNonZeroValues);
 
                 // Dimensions Array tag: data type + size (8 bytes)
                 writer.Write((int)DataType.Int32);
@@ -178,11 +178,10 @@ internal static MatlabMatrix FormatMatrix<T>(Matrix<T> matrix, string name)
                 writer.Write(matrix.ColumnCount);
 
                 // Array Name:
-                bool smallBlock;
                 var nameBytes = Encoding.ASCII.GetBytes(name);
-                WriteElementTag(writer, DataType.Int8, nameBytes.Length, out smallBlock);
+                WriteElementTag(writer, DataType.Int8, nameBytes.Length, out var isSmallBlock);
                 writer.Write(nameBytes);
-                PadElement(writer, nameBytes.Length, smallBlock);
+                PadElement(writer, nameBytes.Length, isSmallBlock);
 
                 if (sparse)
                 {
@@ -203,9 +202,8 @@ static void WriteDenseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool comp
         {
             int count = matrix.RowCount*matrix.ColumnCount;
 
-            bool smallBlock;
             int size = doublePrecision ? count*8 : count*4;
-            WriteElementTag(writer, doublePrecision ? DataType.Double : DataType.Single, size, out smallBlock);
+            WriteElementTag(writer, doublePrecision ? DataType.Double : DataType.Single, size, out var isSmallBlock);
 
             var data = ((DenseColumnMajorMatrixStorage<T>)matrix.Storage).Data;
 
@@ -219,14 +217,14 @@ static void WriteDenseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool comp
             }
             else if (doublePrecision)
             {
-                WriteComplexArray(writer, (Complex[])(object)data, data.Length, size, ref smallBlock);
+                WriteComplexArray(writer, (Complex[])(object)data, data.Length, size, ref isSmallBlock);
             }
             else
             {
-                WriteComplex32Array(writer, (Complex32[])(object)data, data.Length, size, ref smallBlock);
+                WriteComplex32Array(writer, (Complex32[])(object)data, data.Length, size, ref isSmallBlock);
             }
 
-            PadElement(writer, size, smallBlock);
+            PadElement(writer, size, isSmallBlock);
         }
 
         static void WriteSparseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool complex, bool doublePrecision)
@@ -235,32 +233,31 @@ static void WriteSparseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool com
             var transposed = matrix.Transpose();
             var storage = (SparseCompressedRowMatrixStorage<T>)transposed.Storage;
 
-            bool smallBlock;
             int nzcount = storage.ValueCount;
 
             // row data array
             var ir = storage.ColumnIndices;
-            WriteElementTag(writer, DataType.Int32, nzcount*4, out smallBlock);
+            WriteElementTag(writer, DataType.Int32, nzcount*4, out var isSmallBlock);
             for (var i = 0; i < nzcount; i++)
             {
                 writer.Write(ir[i]);
             }
 
-            PadElement(writer, nzcount*4, smallBlock);
+            PadElement(writer, nzcount*4, isSmallBlock);
 
             // column data array
             var jc = storage.RowPointers;
-            WriteElementTag(writer, DataType.Int32, jc.Length*4, out smallBlock);
+            WriteElementTag(writer, DataType.Int32, jc.Length*4, out isSmallBlock);
             for (var i = 0; i < jc.Length; i++)
             {
                 writer.Write(jc[i]);
             }
 
-            PadElement(writer, jc.Length*4, smallBlock);
+            PadElement(writer, jc.Length*4, isSmallBlock);
 
             // values
             int size = doublePrecision ? nzcount*8 : nzcount*4;
-            WriteElementTag(writer, doublePrecision ? DataType.Double : DataType.Single, size, out smallBlock);
+            WriteElementTag(writer, doublePrecision ? DataType.Double : DataType.Single, size, out isSmallBlock);
 
             if (doublePrecision && !complex)
             {
@@ -272,14 +269,14 @@ static void WriteSparseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool com
             }
             else if (doublePrecision)
             {
-                WriteComplexArray(writer, (Complex[])(object)storage.Values, nzcount, size, ref smallBlock);
+                WriteComplexArray(writer, (Complex[])(object)storage.Values, nzcount, size, ref isSmallBlock);
             }
             else
             {
-                WriteComplex32Array(writer, (Complex32[])(object)storage.Values, nzcount, size, ref smallBlock);
+                WriteComplex32Array(writer, (Complex32[])(object)storage.Values, nzcount, size, ref isSmallBlock);
             }
 
-            PadElement(writer, size, smallBlock);
+            PadElement(writer, size, isSmallBlock);
         }
 
         static void WriteDoubleArray(BinaryWriter writer, double[] data, int count)
@@ -348,7 +345,7 @@ static void WriteElementTag(BinaryWriter writer, DataType dataType, int size, ou
             }
         }
 
-        static void PadElement(BinaryWriter writer, int size, bool smallBlock, byte padValue = (byte)0)
+        static void PadElement(BinaryWriter writer, int size, bool smallBlock, byte padValue = 0)
         {
             var blockSize = smallBlock ? SmallBlockSize : LargeBlockSize;
             var offset = 0;
@@ -364,7 +361,7 @@ static void PadElement(BinaryWriter writer, int size, bool smallBlock, byte padV
             }
         }
 
-        static void Pad(BinaryWriter writer, int count, byte padValue = (byte)0)
+        static void Pad(BinaryWriter writer, int count, byte padValue = 0)
         {
             for (var i = 0; i < count; i++)
             {
diff --git a/src/Data.Matlab/Parser.cs b/src/Data.Matlab/Parser.cs
@@ -89,10 +89,7 @@ internal static List<MatlabMatrix> ParseFile(Stream stream)
                     // small format: size (2 bytes), type (2 bytes), data (4 bytes)
                     // long format: type (4 bytes), size (4 bytes), data (size, aligned to 8 bytes)
 
-                    DataType type;
-                    int size;
-                    bool smallBlock;
-                    ReadElementTag(reader, out type, out size, out smallBlock);
+                    ReadElementTag(reader, out var type, out var size, out var isSmallBlock);
 
                     // read element data of the size provided in the element header
                     // uncompress if compressed
@@ -105,7 +102,7 @@ internal static List<MatlabMatrix> ParseFile(Stream stream)
                     {
                         data = new byte[size];
                         reader.Read(data, 0, size);
-                        SkipElementPadding(reader, size, smallBlock);
+                        SkipElementPadding(reader, size, isSmallBlock);
                     }
 
                     if (type == DataType.Matrix)
@@ -169,12 +166,9 @@ internal static Matrix<T> ParseMatrix<T>(byte[] data)
                 var columns = reader.ReadInt32();
 
                 // Array name
-                DataType type;
-                int size;
-                bool smallBlock;
-                ReadElementTag(reader, out type, out size, out smallBlock);
+                ReadElementTag(reader, out _, out var size, out var isSmallBlock);
                 reader.BaseStream.Seek(size, SeekOrigin.Current);
-                SkipElementPadding(reader, size, smallBlock);
+                SkipElementPadding(reader, size, isSmallBlock);
 
                 // Data
                 switch (arrayClass)
@@ -209,12 +203,8 @@ static Matrix<T> PopulateDenseMatrix<T>(BinaryReader reader, bool complex, int r
             var count = rows*columns;
             var data = new T[count];
 
-            DataType type;
-            int size;
-            bool smallBlock;
-
             // read real part array
-            ReadElementTag(reader, out type, out size, out smallBlock);
+            ReadElementTag(reader, out var type, out var size, out var isSmallBlock);
 
             // direct copy if possible
             if ((type == DataType.Double && dataType == typeof(double)) || (type == DataType.Single && dataType == typeof(float)))
@@ -241,18 +231,18 @@ static Matrix<T> PopulateDenseMatrix<T>(BinaryReader reader, bool complex, int r
             }
             else if (dataType == typeof(Complex))
             {
-                PopulateComplexArray(reader, (Complex[])(object)data, complex, type, ref size, ref smallBlock);
+                PopulateComplexArray(reader, (Complex[])(object)data, complex, type, ref size, ref isSmallBlock);
             }
             else if (dataType == typeof(Complex32))
             {
-                PopulateComplex32Array(reader, (Complex32[])(object)data, complex, type, ref size, ref smallBlock);
+                PopulateComplex32Array(reader, (Complex32[])(object)data, complex, type, ref size, ref isSmallBlock);
             }
             else
             {
                 throw new NotSupportedException();
             }
 
-            SkipElementPadding(reader, size, smallBlock);
+            SkipElementPadding(reader, size, isSmallBlock);
             return Matrix<T>.Build.Dense(rows, columns, data);
         }
 
@@ -273,22 +263,18 @@ static Matrix<T> PopulateSparseMatrix<T>(BinaryReader reader, bool complex, int
             // MATLAB sparse matrices are actually stored as CSC, so just read the data and then transpose.
             var storage = matrix.Storage as SparseCompressedRowMatrixStorage<T>;
 
-            DataType type;
-            int size;
-            bool smallBlock;
-
             // populate the row data array
-            ReadElementTag(reader, out type, out size, out smallBlock);
+            ReadElementTag(reader, out var type, out var size, out var isSmallBlock);
             var ir = storage.ColumnIndices = new int[size/4];
             for (var i = 0; i < ir.Length; i++)
             {
                 ir[i] = reader.ReadInt32();
             }
 
-            SkipElementPadding(reader, size, smallBlock);
+            SkipElementPadding(reader, size, isSmallBlock);
 
             // populate the column data array
-            ReadElementTag(reader, out type, out size, out smallBlock);
+            ReadElementTag(reader, out type, out size, out isSmallBlock);
             var jc = storage.RowPointers;
             if (jc.Length != size/4)
             {
@@ -300,10 +286,10 @@ static Matrix<T> PopulateSparseMatrix<T>(BinaryReader reader, bool complex, int
                 jc[j] = reader.ReadInt32();
             }
 
-            SkipElementPadding(reader, size, smallBlock);
+            SkipElementPadding(reader, size, isSmallBlock);
 
             // populate the values
-            ReadElementTag(reader, out type, out size, out smallBlock);
+            ReadElementTag(reader, out type, out size, out isSmallBlock);
             var dataType = typeof(T);
             var data = storage.Values = new T[jc[columns]];
 
@@ -327,18 +313,18 @@ static Matrix<T> PopulateSparseMatrix<T>(BinaryReader reader, bool complex, int
             }
             else if (dataType == typeof(Complex))
             {
-                PopulateComplexArray(reader, (Complex[])(object)data, complex, type, ref size, ref smallBlock);
+                PopulateComplexArray(reader, (Complex[])(object)data, complex, type, ref size, ref isSmallBlock);
             }
             else if (dataType == typeof(Complex32))
             {
-                PopulateComplex32Array(reader, (Complex32[])(object)data, complex, type, ref size, ref smallBlock);
+                PopulateComplex32Array(reader, (Complex32[])(object)data, complex, type, ref size, ref isSmallBlock);
             }
             else
             {
                 throw new NotSupportedException();
             }
 
-            SkipElementPadding(reader, size, smallBlock);
+            SkipElementPadding(reader, size, isSmallBlock);
             return matrix.Transpose();
         }
 
diff --git a/src/Data.Text/DelimitedWriter.cs b/src/Data.Text/DelimitedWriter.cs
@@ -59,12 +59,12 @@ public static void Write<T>(TextWriter writer, Matrix<T> matrix, string delimite
         {
             if (matrix == null)
             {
-                throw new ArgumentNullException("matrix");
+                throw new ArgumentNullException(nameof(matrix));
             }
 
             if (writer == null)
             {
-                throw new ArgumentNullException("writer");
+                throw new ArgumentNullException(nameof(writer));
             }
 
             if (columnHeaders != null && columnHeaders.Count > 0)
diff --git a/src/Data.Text/MatrixMarketReader.cs b/src/Data.Text/MatrixMarketReader.cs
@@ -123,9 +123,7 @@ public static Vector<T> ReadVector<T>(Stream stream) where T : struct, IEquatabl
 
         public static Matrix<T> ReadMatrix<T>(TextReader reader) where T : struct, IEquatable<T>, IFormattable
         {
-            bool complex, sparse;
-            MatrixMarketSymmetry symmetry;
-            ExpectHeader(reader, true, out complex, out sparse, out symmetry);
+            ExpectHeader(reader, true, out var complex, out var sparse, out var symmetry);
 
             var parse = CreateValueParser<T>(complex);
 
@@ -200,9 +198,7 @@ public static Matrix<T> ReadMatrix<T>(TextReader reader) where T : struct, IEqua
         public static Vector<T> ReadVector<T>(TextReader reader)
             where T : struct, IEquatable<T>, IFormattable
         {
-            bool complex, sparse;
-            MatrixMarketSymmetry symmetry;
-            ExpectHeader(reader, false, out complex, out sparse, out symmetry);
+            ExpectHeader(reader, false, out var complex, out var sparse, out _);
 
             var parse = CreateValueParser<T>(complex);
 

Original file line number	Diff line number	Diff line change
`@@ -105,17 +105,17 @@ internal static MatlabMatrix FormatMatrix<T>(Matrix<T> matrix, string name)`
`105`	`105`	`{`
`106`	`106`	`if (matrix == null)`
`107`	`107`	`{`
`108`		`- throw new ArgumentNullException("matrix");`
	`108`	`+ throw new ArgumentNullException(nameof(matrix));`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`if (string.IsNullOrEmpty(name))`
`112`	`112`	`{`
`113`		`- throw new ArgumentException("String parameter cannot be empty or null.", "name");`
	`113`	`+ throw new ArgumentException("String parameter cannot be empty or null.", nameof(name));`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`if (name.IndexOf(' ') > -1)`
`117`	`117`	`{`
`118`		`- throw new ArgumentException(string.Format("Name cannot contain a space.name: {0}", name), "name");`
	`118`	`+ throw new ArgumentException($"Name cannot contain a space.name: {name}", nameof(name));`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`var dataType = typeof(T);`
`@@ -167,7 +167,7 @@ internal static MatlabMatrix FormatMatrix<T>(Matrix<T> matrix, string name)`
`167`	`167`	`writer.Write((byte)(sparse ? ArrayClass.Sparse : doublePrecision ? ArrayClass.Double : ArrayClass.Single));`
`168`	`168`	`writer.Write((byte)(complex ? ArrayFlags.Complex : 0));`
`169`	`169`	`writer.Write((short)0);`
`170`		`- writer.Write((int)sparseNonZeroValues);`
	`170`	`+ writer.Write(sparseNonZeroValues);`
`171`	`171`
`172`	`172`	`// Dimensions Array tag: data type + size (8 bytes)`
`173`	`173`	`writer.Write((int)DataType.Int32);`
`@@ -178,11 +178,10 @@ internal static MatlabMatrix FormatMatrix<T>(Matrix<T> matrix, string name)`
`178`	`178`	`writer.Write(matrix.ColumnCount);`
`179`	`179`
`180`	`180`	`// Array Name:`
`181`		`- bool smallBlock;`
`182`	`181`	`var nameBytes = Encoding.ASCII.GetBytes(name);`
`183`		`- WriteElementTag(writer, DataType.Int8, nameBytes.Length, out smallBlock);`
	`182`	`+ WriteElementTag(writer, DataType.Int8, nameBytes.Length, out var isSmallBlock);`
`184`	`183`	`writer.Write(nameBytes);`
`185`		`- PadElement(writer, nameBytes.Length, smallBlock);`
	`184`	`+ PadElement(writer, nameBytes.Length, isSmallBlock);`
`186`	`185`
`187`	`186`	`if (sparse)`
`188`	`187`	`{`
`@@ -203,9 +202,8 @@ static void WriteDenseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool comp`
`203`	`202`	`{`
`204`	`203`	`int count = matrix.RowCount*matrix.ColumnCount;`
`205`	`204`
`206`		`- bool smallBlock;`
`207`	`205`	`int size = doublePrecision ? count8 : count4;`
`208`		`- WriteElementTag(writer, doublePrecision ? DataType.Double : DataType.Single, size, out smallBlock);`
	`206`	`+ WriteElementTag(writer, doublePrecision ? DataType.Double : DataType.Single, size, out var isSmallBlock);`
`209`	`207`
`210`	`208`	`var data = ((DenseColumnMajorMatrixStorage<T>)matrix.Storage).Data;`
`211`	`209`
`@@ -219,14 +217,14 @@ static void WriteDenseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool comp`
`219`	`217`	`}`
`220`	`218`	`else if (doublePrecision)`
`221`	`219`	`{`
`222`		`- WriteComplexArray(writer, (Complex[])(object)data, data.Length, size, ref smallBlock);`
	`220`	`+ WriteComplexArray(writer, (Complex[])(object)data, data.Length, size, ref isSmallBlock);`
`223`	`221`	`}`
`224`	`222`	`else`
`225`	`223`	`{`
`226`		`- WriteComplex32Array(writer, (Complex32[])(object)data, data.Length, size, ref smallBlock);`
	`224`	`+ WriteComplex32Array(writer, (Complex32[])(object)data, data.Length, size, ref isSmallBlock);`
`227`	`225`	`}`
`228`	`226`
`229`		`- PadElement(writer, size, smallBlock);`
	`227`	`+ PadElement(writer, size, isSmallBlock);`
`230`	`228`	`}`
`231`	`229`
`232`	`230`	`static void WriteSparseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool complex, bool doublePrecision)`
`@@ -235,32 +233,31 @@ static void WriteSparseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool com`
`235`	`233`	`var transposed = matrix.Transpose();`
`236`	`234`	`var storage = (SparseCompressedRowMatrixStorage<T>)transposed.Storage;`
`237`	`235`
`238`		`- bool smallBlock;`
`239`	`236`	`int nzcount = storage.ValueCount;`
`240`	`237`
`241`	`238`	`// row data array`
`242`	`239`	`var ir = storage.ColumnIndices;`
`243`		`- WriteElementTag(writer, DataType.Int32, nzcount*4, out smallBlock);`
	`240`	`+ WriteElementTag(writer, DataType.Int32, nzcount*4, out var isSmallBlock);`
`244`	`241`	`for (var i = 0; i < nzcount; i++)`
`245`	`242`	`{`
`246`	`243`	`writer.Write(ir[i]);`
`247`	`244`	`}`
`248`	`245`
`249`		`- PadElement(writer, nzcount*4, smallBlock);`
	`246`	`+ PadElement(writer, nzcount*4, isSmallBlock);`
`250`	`247`
`251`	`248`	`// column data array`
`252`	`249`	`var jc = storage.RowPointers;`
`253`		`- WriteElementTag(writer, DataType.Int32, jc.Length*4, out smallBlock);`
	`250`	`+ WriteElementTag(writer, DataType.Int32, jc.Length*4, out isSmallBlock);`
`254`	`251`	`for (var i = 0; i < jc.Length; i++)`
`255`	`252`	`{`
`256`	`253`	`writer.Write(jc[i]);`
`257`	`254`	`}`
`258`	`255`
`259`		`- PadElement(writer, jc.Length*4, smallBlock);`
	`256`	`+ PadElement(writer, jc.Length*4, isSmallBlock);`
`260`	`257`
`261`	`258`	`// values`
`262`	`259`	`int size = doublePrecision ? nzcount8 : nzcount4;`
`263`		`- WriteElementTag(writer, doublePrecision ? DataType.Double : DataType.Single, size, out smallBlock);`
	`260`	`+ WriteElementTag(writer, doublePrecision ? DataType.Double : DataType.Single, size, out isSmallBlock);`
`264`	`261`
`265`	`262`	`if (doublePrecision && !complex)`
`266`	`263`	`{`
`@@ -272,14 +269,14 @@ static void WriteSparseMatrix<T>(BinaryWriter writer, Matrix<T> matrix, bool com`
`272`	`269`	`}`
`273`	`270`	`else if (doublePrecision)`
`274`	`271`	`{`
`275`		`- WriteComplexArray(writer, (Complex[])(object)storage.Values, nzcount, size, ref smallBlock);`
	`272`	`+ WriteComplexArray(writer, (Complex[])(object)storage.Values, nzcount, size, ref isSmallBlock);`
`276`	`273`	`}`
`277`	`274`	`else`
`278`	`275`	`{`
`279`		`- WriteComplex32Array(writer, (Complex32[])(object)storage.Values, nzcount, size, ref smallBlock);`
	`276`	`+ WriteComplex32Array(writer, (Complex32[])(object)storage.Values, nzcount, size, ref isSmallBlock);`
`280`	`277`	`}`
`281`	`278`
`282`		`- PadElement(writer, size, smallBlock);`
	`279`	`+ PadElement(writer, size, isSmallBlock);`
`283`	`280`	`}`
`284`	`281`
`285`	`282`	`static void WriteDoubleArray(BinaryWriter writer, double[] data, int count)`
`@@ -348,7 +345,7 @@ static void WriteElementTag(BinaryWriter writer, DataType dataType, int size, ou`
`348`	`345`	`}`
`349`	`346`	`}`
`350`	`347`
`351`		`- static void PadElement(BinaryWriter writer, int size, bool smallBlock, byte padValue = (byte)0)`
	`348`	`+ static void PadElement(BinaryWriter writer, int size, bool smallBlock, byte padValue = 0)`
`352`	`349`	`{`
`353`	`350`	`var blockSize = smallBlock ? SmallBlockSize : LargeBlockSize;`
`354`	`351`	`var offset = 0;`
`@@ -364,7 +361,7 @@ static void PadElement(BinaryWriter writer, int size, bool smallBlock, byte padV`
`364`	`361`	`}`
`365`	`362`	`}`
`366`	`363`
`367`		`- static void Pad(BinaryWriter writer, int count, byte padValue = (byte)0)`
	`364`	`+ static void Pad(BinaryWriter writer, int count, byte padValue = 0)`
`368`	`365`	`{`
`369`	`366`	`for (var i = 0; i < count; i++)`
`370`	`367`	`{`
Original file line number	Diff line number	Diff line change
`@@ -89,10 +89,7 @@ internal static List<MatlabMatrix> ParseFile(Stream stream)`
`89`	`89`	`// small format: size (2 bytes), type (2 bytes), data (4 bytes)`
`90`	`90`	`// long format: type (4 bytes), size (4 bytes), data (size, aligned to 8 bytes)`
`91`	`91`
`92`		`- DataType type;`
`93`		`- int size;`
`94`		`- bool smallBlock;`
`95`		`- ReadElementTag(reader, out type, out size, out smallBlock);`
	`92`	`+ ReadElementTag(reader, out var type, out var size, out var isSmallBlock);`
`96`	`93`
`97`	`94`	`// read element data of the size provided in the element header`
`98`	`95`	`// uncompress if compressed`
`@@ -105,7 +102,7 @@ internal static List<MatlabMatrix> ParseFile(Stream stream)`
`105`	`102`	`{`
`106`	`103`	`data = new byte[size];`
`107`	`104`	`reader.Read(data, 0, size);`
`108`		`- SkipElementPadding(reader, size, smallBlock);`
	`105`	`+ SkipElementPadding(reader, size, isSmallBlock);`
`109`	`106`	`}`
`110`	`107`
`111`	`108`	`if (type == DataType.Matrix)`
`@@ -169,12 +166,9 @@ internal static Matrix<T> ParseMatrix<T>(byte[] data)`
`169`	`166`	`var columns = reader.ReadInt32();`
`170`	`167`
`171`	`168`	`// Array name`
`172`		`- DataType type;`
`173`		`- int size;`
`174`		`- bool smallBlock;`
`175`		`- ReadElementTag(reader, out type, out size, out smallBlock);`
	`169`	`+ ReadElementTag(reader, out _, out var size, out var isSmallBlock);`
`176`	`170`	`reader.BaseStream.Seek(size, SeekOrigin.Current);`
`177`		`- SkipElementPadding(reader, size, smallBlock);`
	`171`	`+ SkipElementPadding(reader, size, isSmallBlock);`
`178`	`172`
`179`	`173`	`// Data`
`180`	`174`	`switch (arrayClass)`
`@@ -209,12 +203,8 @@ static Matrix<T> PopulateDenseMatrix<T>(BinaryReader reader, bool complex, int r`
`209`	`203`	`var count = rows*columns;`
`210`	`204`	`var data = new T[count];`
`211`	`205`
`212`		`- DataType type;`
`213`		`- int size;`
`214`		`- bool smallBlock;`
`215`		`-`
`216`	`206`	`// read real part array`
`217`		`- ReadElementTag(reader, out type, out size, out smallBlock);`
	`207`	`+ ReadElementTag(reader, out var type, out var size, out var isSmallBlock);`
`218`	`208`
`219`	`209`	`// direct copy if possible`
`220`	`210`	`if ((type == DataType.Double && dataType == typeof(double)) \|\| (type == DataType.Single && dataType == typeof(float)))`
`@@ -241,18 +231,18 @@ static Matrix<T> PopulateDenseMatrix<T>(BinaryReader reader, bool complex, int r`
`241`	`231`	`}`
`242`	`232`	`else if (dataType == typeof(Complex))`
`243`	`233`	`{`
`244`		`- PopulateComplexArray(reader, (Complex[])(object)data, complex, type, ref size, ref smallBlock);`
	`234`	`+ PopulateComplexArray(reader, (Complex[])(object)data, complex, type, ref size, ref isSmallBlock);`
`245`	`235`	`}`
`246`	`236`	`else if (dataType == typeof(Complex32))`
`247`	`237`	`{`
`248`		`- PopulateComplex32Array(reader, (Complex32[])(object)data, complex, type, ref size, ref smallBlock);`
	`238`	`+ PopulateComplex32Array(reader, (Complex32[])(object)data, complex, type, ref size, ref isSmallBlock);`
`249`	`239`	`}`
`250`	`240`	`else`
`251`	`241`	`{`
`252`	`242`	`throw new NotSupportedException();`
`253`	`243`	`}`
`254`	`244`
`255`		`- SkipElementPadding(reader, size, smallBlock);`
	`245`	`+ SkipElementPadding(reader, size, isSmallBlock);`
`256`	`246`	`return Matrix<T>.Build.Dense(rows, columns, data);`
`257`	`247`	`}`
`258`	`248`
`@@ -273,22 +263,18 @@ static Matrix<T> PopulateSparseMatrix<T>(BinaryReader reader, bool complex, int`
`273`	`263`	`// MATLAB sparse matrices are actually stored as CSC, so just read the data and then transpose.`
`274`	`264`	`var storage = matrix.Storage as SparseCompressedRowMatrixStorage<T>;`
`275`	`265`
`276`		`- DataType type;`
`277`		`- int size;`
`278`		`- bool smallBlock;`
`279`		`-`
`280`	`266`	`// populate the row data array`
`281`		`- ReadElementTag(reader, out type, out size, out smallBlock);`
	`267`	`+ ReadElementTag(reader, out var type, out var size, out var isSmallBlock);`
`282`	`268`	`var ir = storage.ColumnIndices = new int[size/4];`
`283`	`269`	`for (var i = 0; i < ir.Length; i++)`
`284`	`270`	`{`
`285`	`271`	`ir[i] = reader.ReadInt32();`
`286`	`272`	`}`
`287`	`273`
`288`		`- SkipElementPadding(reader, size, smallBlock);`
	`274`	`+ SkipElementPadding(reader, size, isSmallBlock);`
`289`	`275`
`290`	`276`	`// populate the column data array`
`291`		`- ReadElementTag(reader, out type, out size, out smallBlock);`
	`277`	`+ ReadElementTag(reader, out type, out size, out isSmallBlock);`
`292`	`278`	`var jc = storage.RowPointers;`
`293`	`279`	`if (jc.Length != size/4)`
`294`	`280`	`{`
`@@ -300,10 +286,10 @@ static Matrix<T> PopulateSparseMatrix<T>(BinaryReader reader, bool complex, int`
`300`	`286`	`jc[j] = reader.ReadInt32();`
`301`	`287`	`}`
`302`	`288`
`303`		`- SkipElementPadding(reader, size, smallBlock);`
	`289`	`+ SkipElementPadding(reader, size, isSmallBlock);`
`304`	`290`
`305`	`291`	`// populate the values`
`306`		`- ReadElementTag(reader, out type, out size, out smallBlock);`
	`292`	`+ ReadElementTag(reader, out type, out size, out isSmallBlock);`
`307`	`293`	`var dataType = typeof(T);`
`308`	`294`	`var data = storage.Values = new T[jc[columns]];`
`309`	`295`
`@@ -327,18 +313,18 @@ static Matrix<T> PopulateSparseMatrix<T>(BinaryReader reader, bool complex, int`
`327`	`313`	`}`
`328`	`314`	`else if (dataType == typeof(Complex))`
`329`	`315`	`{`
`330`		`- PopulateComplexArray(reader, (Complex[])(object)data, complex, type, ref size, ref smallBlock);`
	`316`	`+ PopulateComplexArray(reader, (Complex[])(object)data, complex, type, ref size, ref isSmallBlock);`
`331`	`317`	`}`
`332`	`318`	`else if (dataType == typeof(Complex32))`
`333`	`319`	`{`
`334`		`- PopulateComplex32Array(reader, (Complex32[])(object)data, complex, type, ref size, ref smallBlock);`
	`320`	`+ PopulateComplex32Array(reader, (Complex32[])(object)data, complex, type, ref size, ref isSmallBlock);`
`335`	`321`	`}`
`336`	`322`	`else`
`337`	`323`	`{`
`338`	`324`	`throw new NotSupportedException();`
`339`	`325`	`}`
`340`	`326`
`341`		`- SkipElementPadding(reader, size, smallBlock);`
	`327`	`+ SkipElementPadding(reader, size, isSmallBlock);`
`342`	`328`	`return matrix.Transpose();`
`343`	`329`	`}`
`344`	`330`
Original file line number	Diff line number	Diff line change
`@@ -59,12 +59,12 @@ public static void Write<T>(TextWriter writer, Matrix<T> matrix, string delimite`
`59`	`59`	`{`
`60`	`60`	`if (matrix == null)`
`61`	`61`	`{`
`62`		`- throw new ArgumentNullException("matrix");`
	`62`	`+ throw new ArgumentNullException(nameof(matrix));`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`if (writer == null)`
`66`	`66`	`{`
`67`		`- throw new ArgumentNullException("writer");`
	`67`	`+ throw new ArgumentNullException(nameof(writer));`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`if (columnHeaders != null && columnHeaders.Count > 0)`