fixed sparse matrix Submatrix bug. work item: 5671

src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs

@@ -428,8 +428,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             for (int i = rowIndex, row = 0; i < rowMax; i++, row++)
             {
                 var startIndex = _rowIndex[i];
-                var endIndex = row < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount;
-
+                var endIndex = i < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount;
                 for (int j = startIndex; j < endIndex; j++)
                 {
                     // check if the column index is in the range

src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs

@@ -428,7 +428,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             for (int i = rowIndex, row = 0; i < rowMax; i++, row++)
             {
                 var startIndex = _rowIndex[i];
-                var endIndex = row < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount;
+                var endIndex = i < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount;
 
                 for (int j = startIndex; j < endIndex; j++)
                 {

src/Numerics/LinearAlgebra/Double/SparseMatrix.cs

@@ -421,7 +421,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             for (int i = rowIndex, row = 0; i < rowMax; i++, row++)
             {
                 var startIndex = _rowIndex[i];
-                var endIndex = row < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount;
+                var endIndex = i < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount;
 
                 for (int j = startIndex; j < endIndex; j++)
                 {

src/Numerics/LinearAlgebra/Single/SparseMatrix.cs

@@ -422,7 +422,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             for (int i = rowIndex, row = 0; i < rowMax; i++, row++)
             {
                 var startIndex = _rowIndex[i];
-                var endIndex = row < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount;
+                var endIndex = i < _rowIndex.Length - 1 ? _rowIndex[i + 1] : NonZerosCount;
 
                 for (int j = startIndex; j < endIndex; j++)
                 {

src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs

@@ -592,5 +592,43 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             var matrix = TestMatrices["Square3x3"];
             Assert.IsTrue(matrix.IsSymmetric);
         }
+
+        /// <summary>
+        /// Can get a sub-matrix.
+        /// </summary>
+        [Test]
+        public override void CanGetASubMatrix()
+        {
+            var matrix = CreateMatrix(10, 10);
+            for (var row = 0; row < matrix.RowCount; row++)
+            {
+                for (var column = 0; column < matrix.ColumnCount; column++)
+                {
+                    if (row == column)
+                    {
+                        matrix[row, column] = 1.0;
+                    }
+                }
+            }
+
+            var submatrix = matrix.SubMatrix(8, 2, 0, 2);
+            Assert.AreEqual(2, submatrix.RowCount);
+            Assert.AreEqual(2, submatrix.ColumnCount);
+
+            for (var row = 0; row < submatrix.RowCount; row++)
+            {
+                for (var column = 0; column < submatrix.ColumnCount; column++)
+                {
+                    if (row == column)
+                    {
+                        Assert.AreEqual(Complex.One, submatrix[row, column]);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(Complex.Zero, submatrix[row, column]);
+                    }
+                }
+            }
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs

@@ -1864,5 +1864,33 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             matrix = TestMatrices["Square3x3"];
             Assert.IsFalse(matrix.IsSymmetric);
         }
+
+        /// <summary>
+        /// Can get a sub-matrix.
+        /// </summary>
+        [Test]
+        public virtual void CanGetASubMatrix()
+        {
+            var matrix = CreateMatrix(10, 10);
+            for (var row = 0; row < matrix.RowCount; row++)
+            {
+                for (var column = 0; column < matrix.ColumnCount; column++)
+                {
+                    matrix[row, column] = 1.0;
+                }
+            }
+
+            var submatrix = matrix.SubMatrix(8, 2, 0, 2);
+            Assert.AreEqual(2, submatrix.RowCount);
+            Assert.AreEqual(2, submatrix.ColumnCount);
+
+            for (var row = 0; row < submatrix.RowCount; row++)
+            {
+                for (var column = 0; column < submatrix.ColumnCount; column++)
+                {
+                    Assert.AreEqual(Complex.One, submatrix[row, column]);
+                }
+            }
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs

@@ -592,6 +592,42 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             var matrix = TestMatrices["Square3x3"];
             Assert.IsTrue(matrix.IsSymmetric);
         }
+        /// <summary>
+        /// Can get a sub-matrix.
+        /// </summary>
+        [Test]
+        public override void CanGetASubMatrix()
+        {
+            var matrix = CreateMatrix(10, 10);
+            for (var row = 0; row < matrix.RowCount; row++)
+            {
+                for (var column = 0; column < matrix.ColumnCount; column++)
+                {
+                    if (row == column)
+                    {
+                        matrix[row, column] = 1.0f;
+                    }
+                }
+            }
+
+            var submatrix = matrix.SubMatrix(8, 2, 0, 2);
+            Assert.AreEqual(2, submatrix.RowCount);
+            Assert.AreEqual(2, submatrix.ColumnCount);
 
+            for (var row = 0; row < submatrix.RowCount; row++)
+            {
+                for (var column = 0; column < submatrix.ColumnCount; column++)
+                {
+                    if (row == column)
+                    {
+                        Assert.AreEqual(Complex32.One, submatrix[row, column]);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(Complex32.Zero, submatrix[row, column]);
+                    }
+                }
+            }
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs

@@ -1864,5 +1864,33 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             matrix = TestMatrices["Square3x3"];
             Assert.IsFalse(matrix.IsSymmetric);
         }
+
+        /// <summary>
+        /// Can get a sub-matrix.
+        /// </summary>
+        [Test]
+        public virtual void CanGetASubMatrix()
+        {
+            var matrix = CreateMatrix(10, 10);
+            for (var row = 0; row < matrix.RowCount; row++)
+            {
+                for (var column = 0; column < matrix.ColumnCount; column++)
+                {
+                    matrix[row, column] = 1.0f;
+                }
+            }
+
+            var submatrix = matrix.SubMatrix(8, 2, 0, 2);
+            Assert.AreEqual(2, submatrix.RowCount);
+            Assert.AreEqual(2, submatrix.ColumnCount);
+
+            for (var row = 0; row < submatrix.RowCount; row++)
+            {
+                for (var column = 0; column < submatrix.ColumnCount; column++)
+                {
+                    Assert.AreEqual(Complex32.One, submatrix[row, column]);
+                }
+            }
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs

@@ -592,5 +592,43 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             var matrix = TestMatrices["Square3x3"];
             Assert.IsTrue(matrix.IsSymmetric);
         }
+
+        /// <summary>
+        /// Can get a sub-matrix.
+        /// </summary>
+        [Test]
+        public override void CanGetASubMatrix()
+        {
+            var matrix = CreateMatrix(10, 10);
+            for (var row = 0; row < matrix.RowCount; row++)
+            {
+                for (var column = 0; column < matrix.ColumnCount; column++)
+                {
+                    if (row == column)
+                    {
+                        matrix[row, column] = 1.0;
+                    }
+                }
+            }
+
+            var submatrix = matrix.SubMatrix(8, 2, 0, 2);
+            Assert.AreEqual(2, submatrix.RowCount);
+            Assert.AreEqual(2, submatrix.ColumnCount);
+
+            for (var row = 0; row < submatrix.RowCount; row++)
+            {
+                for (var column = 0; column < submatrix.ColumnCount; column++)
+                {
+                    if (row == column)
+                    {
+                        Assert.AreEqual(1.0, submatrix[row, column]);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(0.0, submatrix[row, column]);
+                    }
+                }
+            }
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs

@@ -1805,5 +1805,33 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             matrix = TestMatrices["Square3x3"];
             Assert.IsFalse(matrix.IsSymmetric);
         }
+
+        /// <summary>
+        /// Can get a sub-matrix.
+        /// </summary>
+        [Test]
+        public virtual void CanGetASubMatrix()
+        {
+            var matrix = CreateMatrix(10, 10);
+            for (var row = 0; row < matrix.RowCount; row++)
+            {
+                for (var column = 0; column < matrix.ColumnCount; column++)
+                {
+                    matrix[row, column] = 1.0;
+                }
+            }
+
+            var submatrix = matrix.SubMatrix(8, 2, 0, 2);
+            Assert.AreEqual(2, submatrix.RowCount);
+            Assert.AreEqual(2, submatrix.ColumnCount);
+
+            for (var row = 0; row < submatrix.RowCount; row++)
+            {
+                for (var column = 0; column < submatrix.ColumnCount; column++)
+                {
+                    Assert.AreEqual(1.0, submatrix[row, column]);
+                }
+            }
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs

@@ -591,5 +591,43 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             var matrix = TestMatrices["Square3x3"];
             Assert.IsTrue(matrix.IsSymmetric);
         }
+
+        /// <summary>
+        /// Can get a sub-matrix.
+        /// </summary>
+        [Test]
+        public override void CanGetASubMatrix()
+        {
+            var matrix = CreateMatrix(10, 10);
+            for (var row = 0; row < matrix.RowCount; row++)
+            {
+                for (var column = 0; column < matrix.ColumnCount; column++)
+                {
+                    if (row == column)
+                    {
+                        matrix[row, column] = 1.0f;
+                    }
+                }
+            }
+
+            var submatrix = matrix.SubMatrix(8, 2, 0, 2);
+            Assert.AreEqual(2, submatrix.RowCount);
+            Assert.AreEqual(2, submatrix.ColumnCount);
+
+            for (var row = 0; row < submatrix.RowCount; row++)
+            {
+                for (var column = 0; column < submatrix.ColumnCount; column++)
+                {
+                    if (row == column)
+                    {
+                        Assert.AreEqual(1.0f, submatrix[row, column]);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(0.0f, submatrix[row, column]);
+                    }
+                }
+            }
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs

@@ -1805,5 +1805,33 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             matrix = TestMatrices["Square3x3"];
             Assert.IsFalse(matrix.IsSymmetric);
         }
+
+        /// <summary>
+        /// Can get a sub-matrix.
+        /// </summary>
+        [Test]
+        public virtual void CanGetASubMatrix()
+        {
+            var matrix = CreateMatrix(10, 10);
+            for (var row = 0; row < matrix.RowCount; row++)
+            {
+                for (var column = 0; column < matrix.ColumnCount; column++)
+                {
+                    matrix[row, column] = 1.0f;
+                }
+            }
+
+            var submatrix = matrix.SubMatrix(8, 2, 0, 2);
+            Assert.AreEqual(2, submatrix.RowCount);
+            Assert.AreEqual(2, submatrix.ColumnCount);
+
+            for (var row = 0; row < submatrix.RowCount; row++)
+            {
+                for (var column = 0; column < submatrix.ColumnCount; column++)
+                {
+                    Assert.AreEqual(1.0f, submatrix[row, column]);
+                }
+            }
+        }
     }
 }