LA: clear a set of rows or columns at storage level

src/Numerics/LinearAlgebra/Matrix.cs

@@ -146,6 +146,19 @@ namespace MathNet.Numerics.LinearAlgebra
             Storage.Clear();
         }
 
+        /// <summary>
+        /// Sets all values of a row to zero.
+        /// </summary>
+        public void ClearRow(int rowIndex)
+        {
+            if (rowIndex < 0 || rowIndex >= RowCount)
+            {
+                throw new ArgumentOutOfRangeException("rowIndex");
+            }
+
+            Storage.Clear(rowIndex, 1, 0, ColumnCount);
+        }
+
         /// <summary>
         /// Sets all values of a column to zero.
         /// </summary>
@@ -160,16 +173,45 @@ namespace MathNet.Numerics.LinearAlgebra
         }
 
         /// <summary>
-        /// Sets all values of a row to zero.
+        /// Sets all values for all of the chosen rows to zero.
         /// </summary>
-        public void ClearRow(int rowIndex)
+        public void ClearRows(params int[] rowIndices)
         {
-            if (rowIndex < 0 || rowIndex >= RowCount)
+            if (rowIndices.Length == 0)
             {
-                throw new ArgumentOutOfRangeException("rowIndex");
+                return;
             }
 
-            Storage.Clear(rowIndex, 1, 0, ColumnCount);
+            for (int k = 0; k < rowIndices.Length; k++)
+            {
+                if (rowIndices[k] < 0 || rowIndices[k] >= RowCount)
+                {
+                    throw new ArgumentOutOfRangeException("rowIndices");
+                }
+            }
+
+            Storage.ClearRows(rowIndices);
+        }
+
+        /// <summary>
+        /// Sets all values for all of the chosen columns to zero.
+        /// </summary>
+        public void ClearColumns(params int[] columnIndices)
+        {
+            if (columnIndices.Length == 0)
+            {
+                return;
+            }
+
+            for (int k = 0; k < columnIndices.Length; k++)
+            {
+                if (columnIndices[k] < 0 || columnIndices[k] >= ColumnCount)
+                {
+                    throw new ArgumentOutOfRangeException("columnIndices");
+                }
+            }
+
+            Storage.ClearColumns(columnIndices);
         }
 
         /// <summary>

src/Numerics/LinearAlgebra/Storage/DenseColumnMajorMatrixStorage.cs

@@ -127,6 +127,26 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             }
         }
 
+        public override void ClearRows(int[] rowIndices)
+        {
+            for (var j = 0; j < ColumnCount; j++)
+            {
+                int offset = j*RowCount;
+                for (var k = 0; k < rowIndices.Length; k++)
+                {
+                    Data[offset + rowIndices[k]] = Zero;
+                }
+            }
+        }
+
+        public override void ClearColumns(int[] columnIndices)
+        {
+            for (int k = 0; k < columnIndices.Length; k++)
+            {
+                Array.Clear(Data, columnIndices[k]*RowCount, RowCount);
+            }
+        }
+
         // INITIALIZATION
 
         public static DenseColumnMajorMatrixStorage<T> OfMatrix(MatrixStorage<T> matrix)

src/Numerics/LinearAlgebra/Storage/DiagonalMatrixStorage.cs

@@ -130,6 +130,22 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             }
         }
 
+        public override void ClearRows(int[] rowIndices)
+        {
+            for (int i = 0; i < rowIndices.Length; i++)
+            {
+                Data[rowIndices[i]] = Zero;
+            }
+        }
+
+        public override void ClearColumns(int[] columnIndices)
+        {
+            for (int i = 0; i < columnIndices.Length; i++)
+            {
+                Data[columnIndices[i]] = Zero;
+            }
+        }
+
         /// <summary>
         /// Indicates whether the current object is equal to another object of the same type.
         /// </summary>

src/Numerics/LinearAlgebra/Storage/MatrixStorage.cs

@@ -150,6 +150,30 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             }
         }
 
+        public virtual void ClearRows(int[] rowIndices)
+        {
+            for (var k = 0; k < rowIndices.Length; k++)
+            {
+                int row = rowIndices[k];
+                for (var j = 0; j < ColumnCount; j++)
+                {
+                    At(row, j, Zero);
+                }
+            }
+        }
+
+        public virtual void ClearColumns(int[] columnIndices)
+        {
+            for (var k = 0; k < ColumnCount; k++)
+            {
+                int column = columnIndices[k];
+                for (var i = 0; i < RowCount; i++)
+                {
+                    At(i, column, Zero);
+                }
+            }
+        }
+
         /// <summary>
         /// Indicates whether the current object is equal to another object of the same type.
         /// </summary>

src/Numerics/LinearAlgebra/Storage/SparseCompressedRowMatrixStorage.cs

@@ -31,6 +31,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Security.Policy;
 using MathNet.Numerics.Properties;
 
 namespace MathNet.Numerics.LinearAlgebra.Storage
@@ -232,7 +233,7 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
         /// <remarks>WARNING: This method is not thread safe. Use "lock" with it and be sure to avoid deadlocks</remarks>
         public int FindItem(int row, int column)
         {
-            // Determin bounds in columnIndices array where this item should be searched (using rowIndex)
+            // Determine bounds in columnIndices array where this item should be searched (using rowIndex)
             return Array.BinarySearch(ColumnIndices, RowPointers[row], RowPointers[row + 1] - RowPointers[row], column);
         }
 
@@ -264,6 +265,12 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
         }
 
         public void Normalize()
+        {
+            NormalizeOrdering();
+            NormalizeZeros();
+        }
+
+        public void NormalizeOrdering()
         {
             for (int i = 0; i < RowCount; i++)
             {
@@ -274,6 +281,10 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
                     Sorting.Sort(ColumnIndices, Values, index, count);
                 }
             }
+        }
+
+        public void NormalizeZeros()
+        {
             MapInplace(x => x, Zeros.AllowSkip);
         }
 
@@ -336,6 +347,26 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             }
         }
 
+        public override void ClearRows(int[] rowIndices)
+        {
+            var rows = new bool[RowCount];
+            for (int i = 0; i < rowIndices.Length; i++)
+            {
+                rows[rowIndices[i]] = true;
+            }
+            MapIndexedInplace((i, j, x) => rows[i] ? Zero : x, Zeros.AllowSkip);
+        }
+
+        public override void ClearColumns(int[] columnIndices)
+        {
+            var columns = new bool[ColumnCount];
+            for (int i = 0; i < columnIndices.Length; i++)
+            {
+                columns[columnIndices[i]] = true;
+            }
+            MapIndexedInplace((i, j, x) => columns[j] ? Zero : x, Zeros.AllowSkip);
+        }
+
         /// <summary>
         /// Indicates whether the current object is equal to another object of the same type.
         /// </summary>

src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs

@@ -148,17 +148,39 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanClearSubMatrix(Matrix<T> matrix)
         {
-            var cleared = matrix.Clone();
+            Assume.That(matrix.RowCount, Is.GreaterThanOrEqualTo(2));
-            Assume.That(cleared.RowCount, Is.GreaterThanOrEqualTo(2));
+            Assume.That(matrix.ColumnCount, Is.GreaterThanOrEqualTo(2));
-            Assume.That(cleared.ColumnCount, Is.GreaterThanOrEqualTo(2));
 
-            cleared.Storage.Clear(0, 2, 1, 1);
+            var cleared = matrix.Clone();
+            cleared.ClearSubMatrix(0, 2, 1, 1);
             Assert.That(cleared.At(0, 0), Is.EqualTo(matrix.At(0, 0)));
             Assert.That(cleared.At(1, 0), Is.EqualTo(matrix.At(1, 0)));
             Assert.That(cleared.At(0, 1), Is.EqualTo(Zero));
             Assert.That(cleared.At(1, 1), Is.EqualTo(Zero));
         }
 
+        [Theory]
+        public void CanClearRows(Matrix<T> matrix)
+        {
+            Assume.That(matrix.RowCount, Is.GreaterThanOrEqualTo(2));
+
+            var cleared = matrix.Clone();
+            cleared.ClearRows(1);
+            Assert.That(cleared.At(0, 0), Is.EqualTo(matrix.At(0, 0)));
+            Assert.That(cleared.At(1, 0), Is.EqualTo(Zero));
+        }
+
+        [Theory]
+        public void CanClearColumns(Matrix<T> matrix)
+        {
+            Assume.That(matrix.ColumnCount, Is.GreaterThanOrEqualTo(2));
+
+            var cleared = matrix.Clone();
+            cleared.ClearColumns(1);
+            Assert.That(cleared.At(0, 0), Is.EqualTo(matrix.At(0, 0)));
+            Assert.That(cleared.At(0, 1), Is.EqualTo(Zero));
+        }
+
         [Theory]
         public void CanToArray(Matrix<T> matrix)
         {