added a IsSymmetric property to the matrix interface and an optimized version for sparse matrices. work item: 5653

src/MathNet.Numerics.5.1.ReSharper

@@ -75,7 +75,10 @@ Datatset
 Doesnt
 cosecant
 Ulps
-Matlab</UserWords>
+Matlab
+&amp;lt
+&amp;gt
+Wikipedia</UserWords>
             </CustomDictionary>
           </Dictionaries>
         </CustomDictionaries>

src/Numerics/LinearAlgebra/Complex/DiagonalMatrix.cs

@@ -1537,6 +1537,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             throw new InvalidOperationException("Permutations in diagonal matrix are not allowed");
         }
 
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public override bool IsSymmetric
+        {
+            get
+            {
+                return true;
+            }
+        }
+
         #region Static constructors for special matrices.
 
         /// <summary>

src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs

@@ -1503,6 +1503,71 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
                 }
             }
         }
+
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public override bool IsSymmetric
+        {
+            get
+            {
+                if (RowCount != ColumnCount)
+                {
+                    return false;
+                }
+
+                // todo: we might be able to speed this up by caching one half of the matrix
+                for (var row = 0; row < RowCount - 1; row++)
+                {
+                    var start = _rowIndex[row];
+                    var end = _rowIndex[row + 1];
+
+                    if (start == end)
+                    {
+                        continue;
+                    }
+
+                    if (!CheckIfOppositesAreEqual(start, end, row))
+                    {
+                        return false;
+                    }
+                }
+
+                var lastRow = _rowIndex.Length - 1;
+
+                if (_rowIndex[lastRow] < NonZerosCount)
+                {
+                    if (!CheckIfOppositesAreEqual(_rowIndex[lastRow], NonZerosCount, lastRow))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Checks if opposites in a range are equal.
+        /// </summary>
+        /// <param name="start">The start of the range.</param>
+        /// <param name="end">The end of the range.</param>
+        /// <param name="row">The row the row to check.</param>
+        /// <returns>If the values are equal or not.</returns>
+        private bool CheckIfOppositesAreEqual(int start, int end, int row)
+        {
+            for (var index = start; index < end; index++)
+            {
+                var column = _columnIndices[index];
+                var opposite = At(column, row);
+                if (!_nonZeroValues[index].Equals(opposite))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
     }
 }
 

src/Numerics/LinearAlgebra/Complex32/DiagonalMatrix.cs

@@ -1542,6 +1542,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             throw new InvalidOperationException("Permutations in diagonal matrix are not allowed");
         }
 
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public override bool IsSymmetric
+        {
+            get
+            {
+                return true;
+            }
+        }
+
         #region Static constructors for special matrices.
 
         /// <summary>

src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs

@@ -80,7 +80,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// <param name="columns">
         /// The number of columns.
         /// </param>
-        public SparseMatrix(int rows, int columns) : base(rows, columns)
+        public SparseMatrix(int rows, int columns)
+            : base(rows, columns)
         {
             _rowIndex = new int[rows];
         }
@@ -92,7 +93,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// <exception cref="ArgumentException">
         /// If <paramref name="order"/> is less than one.
         /// </exception>
-        public SparseMatrix(int order) : this(order, order)
+        public SparseMatrix(int order)
+            : this(order, order)
         {
         }
 
@@ -106,7 +108,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// The number of columns.
         /// </param>
         /// <param name="value">The value which we assign to each element of the matrix.</param>
-        public SparseMatrix(int rows, int columns, Complex32 value) : this(rows, columns)
+        public SparseMatrix(int rows, int columns, Complex32 value)
+            : this(rows, columns)
         {
             if (value == 0.0f)
             {
@@ -144,7 +147,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// <param name="array">The one dimensional array to create this matrix from. This array should store the matrix in column-major order. see: http://en.wikipedia.org/wiki/Column-major_order </param>
         /// <exception cref="ArgumentOutOfRangeException">If <paramref name="array"/> length is less than <paramref name="rows"/> * <paramref name="columns"/>.
         /// </exception>
-        public SparseMatrix(int rows, int columns, Complex32[] array) : this(rows, columns)
+        public SparseMatrix(int rows, int columns, Complex32[] array)
+            : this(rows, columns)
         {
             if (rows * columns > array.Length)
             {
@@ -164,7 +168,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// Initializes a new instance of the <see cref="SparseMatrix"/> class from a 2D array. 
         /// </summary>
         /// <param name="array">The 2D array to create this matrix from.</param>
-        public SparseMatrix(Complex32[,] array) : this(array.GetLength(0), array.GetLength(1))
+        public SparseMatrix(Complex32[,] array)
+            : this(array.GetLength(0), array.GetLength(1))
         {
             var rows = array.GetLength(0);
             var columns = array.GetLength(1);
@@ -1499,5 +1504,70 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
                 }
             }
         }
+
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public override bool IsSymmetric
+        {
+            get
+            {
+                if (RowCount != ColumnCount)
+                {
+                    return false;
+                }
+
+                // todo: we might be able to speed this up by caching one half of the matrix
+                for (var row = 0; row < RowCount - 1; row++)
+                {
+                    var start = _rowIndex[row];
+                    var end = _rowIndex[row + 1];
+
+                    if (start == end)
+                    {
+                        continue;
+                    }
+
+                    if (!CheckIfOppositesAreEqual(start, end, row))
+                    {
+                        return false;
+                    }
+                }
+
+                var lastRow = _rowIndex.Length - 1;
+
+                if (_rowIndex[lastRow] < NonZerosCount)
+                {
+                    if (!CheckIfOppositesAreEqual(_rowIndex[lastRow], NonZerosCount, lastRow))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Checks if opposites in a range are equal.
+        /// </summary>
+        /// <param name="start">The start of the range.</param>
+        /// <param name="end">The end of the range.</param>
+        /// <param name="row">The row the row to check.</param>
+        /// <returns>If the values are equal or not.</returns>
+        private bool CheckIfOppositesAreEqual(int start, int end, int row)
+        {
+            for (var index = start; index < end; index++)
+            {
+                var column = _columnIndices[index];
+                var opposite = At(column, row);
+                if (!_nonZeroValues[index].Equals(opposite))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
     }
 }

src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs

@@ -1536,6 +1536,17 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             throw new InvalidOperationException("Permutations in diagonal matrix are not allowed");
         }
 
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public override bool IsSymmetric
+        {
+            get
+            {
+                return true;
+            }
+        }
+
         #region Static constructors for special matrices.
 
         /// <summary>

src/Numerics/LinearAlgebra/Double/SparseMatrix.cs

@@ -1515,5 +1515,70 @@ namespace MathNet.Numerics.LinearAlgebra.Double
                 }
             }
         }
+
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public override bool IsSymmetric
+        {
+            get
+            {
+                if (RowCount != ColumnCount)
+                {
+                    return false;
+                }
+
+                // todo: we might be able to speed this up by caching one half of the matrix
+                for (var row = 0; row < RowCount - 1; row++)
+                {
+                    var start = _rowIndex[row];
+                    var end = _rowIndex[row + 1];
+
+                    if (start == end)
+                    {
+                        continue;
+                    }
+
+                    if (!CheckIfOppositesAreEqual(start, end, row))
+                    {
+                        return false;
+                    }
+                }
+
+                var lastRow = _rowIndex.Length - 1;
+
+                if (_rowIndex[lastRow] < NonZerosCount)
+                {
+                    if (!CheckIfOppositesAreEqual(_rowIndex[lastRow], NonZerosCount, lastRow))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Checks if opposites in a range are equal.
+        /// </summary>
+        /// <param name="start">The start of the range.</param>
+        /// <param name="end">The end of the range.</param>
+        /// <param name="row">The row the row to check.</param>
+        /// <returns>If the values are equal or not.</returns>
+        private bool CheckIfOppositesAreEqual(int start, int end, int row)
+        {
+            for (var index = start; index < end; index++)
+            {
+                var column = _columnIndices[index];
+                var opposite = At(column, row);
+                if (!_nonZeroValues[index].Equals(opposite))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
     }
 }

src/Numerics/LinearAlgebra/Generic/Matrix.cs

@@ -1773,5 +1773,37 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
                 }
             }
         }
+
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public virtual bool IsSymmetric
+        {
+            get
+            {
+                if (RowCount != ColumnCount)
+                {
+                    return false;
+                }
+
+                for (var row = 1; row < RowCount; row++)
+                {
+                    for (var column = 0; column < ColumnCount; column++)
+                    {
+                        if (column >= row)
+                        {
+                            continue;
+                        }
+
+                        if (!At(row, column).Equals(At(column, row)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+
+                return true;
+            }
+        }
     }
 }

src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs

@@ -1536,6 +1536,17 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             throw new InvalidOperationException("Permutations in diagonal matrix are not allowed");
         }
 
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public override bool IsSymmetric
+        {
+            get
+            {
+                return true;
+            }
+        }
+
         #region Static constructors for special matrices.
 
         /// <summary>

src/Numerics/LinearAlgebra/Single/SparseMatrix.cs

@@ -1498,5 +1498,70 @@ namespace MathNet.Numerics.LinearAlgebra.Single
                 }
             }
         }
+
+        /// <summary>
+        /// Gets a value indicating whether this matrix is symmetric.
+        /// </summary>
+        public override bool IsSymmetric
+        {
+            get
+            {
+                if (RowCount != ColumnCount)
+                {
+                    return false;
+                }
+
+                // todo: we might be able to speed this up by caching one half of the matrix
+                for (var row = 0; row < RowCount - 1; row++)
+                {
+                    var start = _rowIndex[row];
+                    var end = _rowIndex[row + 1];
+
+                    if (start == end)
+                    {
+                        continue;
+                    }
+
+                    if (!CheckIfOppositesAreEqual(start, end, row))
+                    {
+                        return false;
+                    }
+                }
+
+                var lastRow = _rowIndex.Length - 1;
+
+                if (_rowIndex[lastRow] < NonZerosCount)
+                {
+                    if (!CheckIfOppositesAreEqual(_rowIndex[lastRow], NonZerosCount, lastRow))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Checks if opposites in a range are equal.
+        /// </summary>
+        /// <param name="start">The start of the range.</param>
+        /// <param name="end">The end of the range.</param>
+        /// <param name="row">The row the row to check.</param>
+        /// <returns>If the values are equal or not.</returns>
+        private bool CheckIfOppositesAreEqual(int start, int end, int row)
+        {
+            for (var index = start; index < end; index++)
+            {
+                var column = _columnIndices[index];
+                var opposite = At(column, row);
+                if (!_nonZeroValues[index].Equals(opposite))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs

@@ -582,5 +582,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             Assert.AreEqual(2, item.Item2);
             Assert.AreEqual(new Complex(3.0, 1.0), item.Item3);
         }
+
+        /// <summary>
+        /// Can check if a matrix is symmetric.
+        /// </summary>
+        [Test]
+        public override void CanCheckIfMatrixIsSymmetric()
+        {
+            var matrix = TestMatrices["Square3x3"];
+            Assert.IsTrue(matrix.IsSymmetric);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex/MatrixLoader.cs

@@ -101,6 +101,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
                              { "Singular4x4", new[,] { { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) }, { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) }, { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) }, { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) } } }, 
                              { "Tall3x2", new[,] { { new Complex(-1.1, 1), new Complex(-2.2, 1) }, { Complex.Zero, new Complex(1.1, 1) }, { new Complex(-4.4, 1), new Complex(5.5, 1) } } }, 
                              { "Wide2x3", new[,] { { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1) }, { Complex.Zero, new Complex(1.1, 1), new Complex(2.2, 1) } } }, 
+                             { "Symmetric3x3", new[,] { { Complex.One, 2.0, 3.0 }, { 2.0, 2.0, 0.0 }, { 3.0, 0.0, 3.0 } } }
                          };
 
             TestMatrices = new Dictionary<string, Matrix>();

src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs

@@ -1851,5 +1851,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             Assert.AreEqual(2, item.Item2);
             Assert.AreEqual(new Complex(2.0, 1.0), item.Item3);
         }
+
+        /// <summary>
+        /// Can check if a matrix is symmetric.
+        /// </summary>
+        [Test]
+        public virtual void CanCheckIfMatrixIsSymmetric()
+        {
+            var matrix = TestMatrices["Symmetric3x3"];
+            Assert.IsTrue(matrix.IsSymmetric);
+
+            matrix = TestMatrices["Square3x3"];
+            Assert.IsFalse(matrix.IsSymmetric);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs

@@ -582,5 +582,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             Assert.AreEqual(2, item.Item2);
             Assert.AreEqual(new Complex32(3.0f, 1.0f), item.Item3);
         }
+
+        /// <summary>
+        /// Can check if a matrix is symmetric.
+        /// </summary>
+        [Test]
+        public override void CanCheckIfMatrixIsSymmetric()
+        {
+            var matrix = TestMatrices["Square3x3"];
+            Assert.IsTrue(matrix.IsSymmetric);
+        }
+
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/MatrixLoader.cs

@@ -101,6 +101,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
                              { "Singular4x4", new[,] { { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) }, { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) }, { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) }, { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) } } }, 
                              { "Tall3x2", new[,] { { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1) }, { Complex32.Zero, new Complex32(1.1f, 1) }, { new Complex32(-4.4f, 1), new Complex32(5.5f, 1) } } }, 
                              { "Wide2x3", new[,] { { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1) }, { Complex32.Zero, new Complex32(1.1f, 1), new Complex32(2.2f, 1) } } },
+                             { "Symmetric3x3", new[,] { { Complex32.One, 2.0f, 3.0f }, { 2.0f, 2.0f, 0.0f }, { 3.0f, 0.0f, 3.0f } } }
                          };
 
             TestMatrices = new Dictionary<string, Matrix>();

src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs

@@ -1851,5 +1851,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             Assert.AreEqual(2, item.Item2);
             Assert.AreEqual(new Complex32(2.0f, 1.0f), item.Item3);
         }
+
+        /// <summary>
+        /// Can check if a matrix is symmetric.
+        /// </summary>
+        [Test]
+        public virtual void CanCheckIfMatrixIsSymmetric()
+        {
+            var matrix = TestMatrices["Symmetric3x3"];
+            Assert.IsTrue(matrix.IsSymmetric);
+
+            matrix = TestMatrices["Square3x3"];
+            Assert.IsFalse(matrix.IsSymmetric);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs

@@ -582,5 +582,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             Assert.AreEqual(2, item.Item2);
             Assert.AreEqual(3.0, item.Item3);
         }
+
+        /// <summary>
+        /// Can check if a matrix is symmetric.
+        /// </summary>
+        [Test]
+        public override void CanCheckIfMatrixIsSymmetric()
+        {
+            var matrix = TestMatrices["Square3x3"];
+            Assert.IsTrue(matrix.IsSymmetric);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Double/MatrixLoader.cs

@@ -100,6 +100,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
                              { "Singular4x4", new[,] { { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 } } }, 
                              { "Tall3x2", new[,] { { -1.1, -2.2 }, { 0.0, 1.1 }, { -4.4, 5.5 } } }, 
                              { "Wide2x3", new[,] { { -1.1, -2.2, -3.3 }, { 0.0, 1.1, 2.2 } } }, 
+                             { "Symmetric3x3", new[,] { { 1.0, 2.0, 3.0 }, { 2.0, 2.0, 0.0 }, { 3.0, 0.0, 3.0 } } }
                          };
 
             TestMatrices = new Dictionary<string, Matrix>();

src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs

@@ -1792,5 +1792,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             Assert.AreEqual(2, item.Item2);
             Assert.AreEqual(2.0, item.Item3);
         }
+
+        /// <summary>
+        /// Can check if a matrix is symmetric.
+        /// </summary>
+        [Test]
+        public virtual void CanCheckIfMatrixIsSymmetric()
+        {
+            var matrix = TestMatrices["Symmetric3x3"];
+            Assert.IsTrue(matrix.IsSymmetric);
+            
+            matrix = TestMatrices["Square3x3"];
+            Assert.IsFalse(matrix.IsSymmetric);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs

@@ -581,5 +581,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             Assert.AreEqual(2, item.Item2);
             Assert.AreEqual(3.0f, item.Item3);
         }
+
+        /// <summary>
+        /// Can check if a matrix is symmetric.
+        /// </summary>
+        [Test]
+        public override void CanCheckIfMatrixIsSymmetric()
+        {
+            var matrix = TestMatrices["Square3x3"];
+            Assert.IsTrue(matrix.IsSymmetric);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Single/MatrixLoader.cs

@@ -100,6 +100,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
                              { "Singular4x4", new[,] { { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f } } }, 
                              { "Tall3x2", new[,] { { -1.1f, -2.2f }, { 0.0f, 1.1f }, { -4.4f, 5.5f } } }, 
                              { "Wide2x3", new[,] { { -1.1f, -2.2f, -3.3f }, { 0.0f, 1.1f, 2.2f } } }, 
+                             { "Symmetric3x3", new[,] { { 1.0f, 2.0f, 3.0f }, { 2.0f, 2.0f, 0.0f }, { 3.0f, 0.0f, 3.0f } } }
                          };
 
             TestMatrices = new Dictionary<string, Matrix>();

src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs

@@ -1792,5 +1792,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             Assert.AreEqual(2, item.Item2);
             Assert.AreEqual(2.0f, item.Item3);
         }
+
+        /// <summary>
+        /// Can check if a matrix is symmetric.
+        /// </summary>
+        [Test]
+        public virtual void CanCheckIfMatrixIsSymmetric()
+        {
+            var matrix = TestMatrices["Symmetric3x3"];
+            Assert.IsTrue(matrix.IsSymmetric);
+
+            matrix = TestMatrices["Square3x3"];
+            Assert.IsFalse(matrix.IsSymmetric);
+        }
     }
 }