From 2e787ddafbf20f41f3349223859bc7c4a7237ee7 Mon Sep 17 00:00:00 2001 From: Christoph Ruegg Date: Thu, 29 May 2014 09:39:11 +0200 Subject: [PATCH] LA: Matrix.IsSymmetric now a method; added IsConjugateSymmetric; more efficient #209 --- .../LinearAlgebra/Complex/DenseMatrix.cs | 50 +++++++++++++ .../LinearAlgebra/Complex/DiagonalMatrix.cs | 17 +++-- src/Numerics/LinearAlgebra/Complex/Matrix.cs | 24 ++++++ .../LinearAlgebra/Complex/SparseMatrix.cs | 75 +++++++++++-------- .../LinearAlgebra/Complex32/DenseMatrix.cs | 50 +++++++++++++ .../LinearAlgebra/Complex32/DiagonalMatrix.cs | 17 +++-- .../LinearAlgebra/Complex32/Matrix.cs | 24 ++++++ .../LinearAlgebra/Complex32/SparseMatrix.cs | 75 +++++++++++-------- .../LinearAlgebra/Double/DenseMatrix.cs | 25 +++++++ .../LinearAlgebra/Double/DiagonalMatrix.cs | 9 +-- src/Numerics/LinearAlgebra/Double/Matrix.cs | 8 ++ .../LinearAlgebra/Double/SparseMatrix.cs | 62 +++++---------- src/Numerics/LinearAlgebra/Matrix.cs | 32 ++++---- .../LinearAlgebra/Single/DenseMatrix.cs | 25 +++++++ .../LinearAlgebra/Single/DiagonalMatrix.cs | 9 +-- src/Numerics/LinearAlgebra/Single/Matrix.cs | 8 ++ .../LinearAlgebra/Single/SparseMatrix.cs | 64 ++++++---------- .../Complex/DiagonalMatrixTests.cs | 2 +- .../LinearAlgebraTests/Complex/MatrixTests.cs | 4 +- .../Complex32/DiagonalMatrixTests.cs | 2 +- .../Complex32/MatrixTests.cs | 4 +- .../Double/DiagonalMatrixTests.cs | 2 +- .../LinearAlgebraTests/Double/MatrixTests.cs | 4 +- .../Single/DiagonalMatrixTests.cs | 2 +- .../LinearAlgebraTests/Single/MatrixTests.cs | 4 +- 25 files changed, 403 insertions(+), 195 deletions(-) diff --git a/src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs index 4d59ec3e..6f86670d 100644 --- a/src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs @@ -1228,6 +1228,56 @@ namespace MathNet.Numerics.LinearAlgebra.Complex return (DenseMatrix)leftSide.Remainder(rightSide); } + /// + /// Evaluates whether this matrix is symmetric. + /// + public override bool IsSymmetric() + { + if (RowCount != ColumnCount) + { + return false; + } + + for (var j = 0; j < ColumnCount; j++) + { + var index = j * RowCount; + for (var i = j + 1; i < RowCount; i++) + { + if (_values[(i*ColumnCount) + j] != _values[index + i]) + { + return false; + } + } + } + + return true; + } + + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public override bool IsConjugateSymmetric() + { + if (RowCount != ColumnCount) + { + return false; + } + + for (var j = 0; j < ColumnCount; j++) + { + var index = j * RowCount; + for (var i = j + 1; i < RowCount; i++) + { + if (_values[(i*ColumnCount) + j] != _values[index + i].Conjugate()) + { + return false; + } + } + } + + return true; + } + public override Cholesky Cholesky() { return DenseCholesky.Create(this); diff --git a/src/Numerics/LinearAlgebra/Complex/DiagonalMatrix.cs b/src/Numerics/LinearAlgebra/Complex/DiagonalMatrix.cs index 84fb114d..21499a70 100644 --- a/src/Numerics/LinearAlgebra/Complex/DiagonalMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex/DiagonalMatrix.cs @@ -955,14 +955,19 @@ namespace MathNet.Numerics.LinearAlgebra.Complex } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public override bool IsSymmetric + public override sealed bool IsSymmetric() { - get - { - return true; - } + return true; + } + + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public override sealed bool IsConjugateSymmetric() + { + return true; } } } diff --git a/src/Numerics/LinearAlgebra/Complex/Matrix.cs b/src/Numerics/LinearAlgebra/Complex/Matrix.cs index 46a1daad..e86f28db 100644 --- a/src/Numerics/LinearAlgebra/Complex/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Complex/Matrix.cs @@ -661,6 +661,30 @@ namespace MathNet.Numerics.LinearAlgebra.Complex return sum; } + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public override bool IsConjugateSymmetric() + { + if (RowCount != ColumnCount) + { + return false; + } + + for (var row = 0; row < RowCount; row++) + { + for (var column = row + 1; column < ColumnCount; column++) + { + if (!At(row, column).Equals(At(column, row).Conjugate())) + { + return false; + } + } + } + + return true; + } + public override Cholesky Cholesky() { return UserCholesky.Create(this); diff --git a/src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs b/src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs index 25e8a469..34e524f1 100644 --- a/src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs @@ -1209,58 +1209,73 @@ namespace MathNet.Numerics.LinearAlgebra.Complex } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public override bool IsSymmetric + public override bool IsSymmetric() { - get + if (RowCount != ColumnCount) { - if (RowCount != ColumnCount) + return false; + } + + var rowPointers = _storage.RowPointers; + var columnIndices = _storage.ColumnIndices; + var values = _storage.Values; + + for (var row = 0; row < RowCount; row++) + { + var start = rowPointers[row]; + var end = rowPointers[row + 1]; + + if (start == end) { - return false; + continue; } - // todo: we might be able to speed this up by caching one half of the matrix - var rowPointers = _storage.RowPointers; - for (var row = 0; row < RowCount; row++) + for (var index = start; index < end; index++) { - var start = rowPointers[row]; - var end = rowPointers[row + 1]; - - if (start == end) - { - continue; - } - - if (!CheckIfOppositesAreEqual(start, end, row)) + var column = columnIndices[index]; + if (!values[index].Equals(At(column, row))) { return false; } } - - return true; } + + return true; } /// - /// Checks if opposites in a range are equal. + /// Evaluates whether this matrix is conjugate symmetric. /// - /// The start of the range. - /// The end of the range. - /// The row the row to check. - /// If the values are equal or not. - private bool CheckIfOppositesAreEqual(int start, int end, int row) + public override bool IsConjugateSymmetric() { + if (RowCount != ColumnCount) + { + return false; + } + + var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; - for (var index = start; index < end; index++) + for (var row = 0; row < RowCount; row++) { - var column = columnIndices[index]; - var opposite = At(column, row); - if (!values[index].Equals(opposite)) + var start = rowPointers[row]; + var end = rowPointers[row + 1]; + + if (start == end) { - return false; + continue; + } + + for (var index = start; index < end; index++) + { + var column = columnIndices[index]; + if (!values[index].Equals(At(column, row).Conjugate())) + { + return false; + } } } diff --git a/src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs index 6e50b40e..cb261bd4 100644 --- a/src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs @@ -1225,6 +1225,56 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 return (DenseMatrix)leftSide.Remainder(rightSide); } + /// + /// Evaluates whether this matrix is symmetric. + /// + public override bool IsSymmetric() + { + if (RowCount != ColumnCount) + { + return false; + } + + for (var j = 0; j < ColumnCount; j++) + { + var index = j * RowCount; + for (var i = j + 1; i < RowCount; i++) + { + if (_values[(i*ColumnCount) + j] != _values[index + i]) + { + return false; + } + } + } + + return true; + } + + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public override bool IsConjugateSymmetric() + { + if (RowCount != ColumnCount) + { + return false; + } + + for (var j = 0; j < ColumnCount; j++) + { + var index = j * RowCount; + for (var i = j + 1; i < RowCount; i++) + { + if (_values[(i*ColumnCount) + j] != _values[index + i].Conjugate()) + { + return false; + } + } + } + + return true; + } + public override Cholesky Cholesky() { return DenseCholesky.Create(this); diff --git a/src/Numerics/LinearAlgebra/Complex32/DiagonalMatrix.cs b/src/Numerics/LinearAlgebra/Complex32/DiagonalMatrix.cs index 6aa3b62a..0e360fac 100644 --- a/src/Numerics/LinearAlgebra/Complex32/DiagonalMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex32/DiagonalMatrix.cs @@ -949,14 +949,19 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public override bool IsSymmetric + public override sealed bool IsSymmetric() { - get - { - return true; - } + return true; + } + + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public override sealed bool IsConjugateSymmetric() + { + return true; } } } diff --git a/src/Numerics/LinearAlgebra/Complex32/Matrix.cs b/src/Numerics/LinearAlgebra/Complex32/Matrix.cs index 7bd2179d..4119d872 100644 --- a/src/Numerics/LinearAlgebra/Complex32/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Complex32/Matrix.cs @@ -655,6 +655,30 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 return sum; } + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public override bool IsConjugateSymmetric() + { + if (RowCount != ColumnCount) + { + return false; + } + + for (var row = 0; row < RowCount; row++) + { + for (var column = row + 1; column < ColumnCount; column++) + { + if (!At(row, column).Equals(At(column, row).Conjugate())) + { + return false; + } + } + } + + return true; + } + public override Cholesky Cholesky() { return UserCholesky.Create(this); diff --git a/src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs b/src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs index 1d959ca7..0bb049d7 100644 --- a/src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs @@ -1203,58 +1203,73 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32 } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public override bool IsSymmetric + public override bool IsSymmetric() { - get + if (RowCount != ColumnCount) { - if (RowCount != ColumnCount) + return false; + } + + var rowPointers = _storage.RowPointers; + var columnIndices = _storage.ColumnIndices; + var values = _storage.Values; + + for (var row = 0; row < RowCount; row++) + { + var start = rowPointers[row]; + var end = rowPointers[row + 1]; + + if (start == end) { - return false; + continue; } - // todo: we might be able to speed this up by caching one half of the matrix - var rowPointers = _storage.RowPointers; - for (var row = 0; row < RowCount; row++) + for (var index = start; index < end; index++) { - var start = rowPointers[row]; - var end = rowPointers[row + 1]; - - if (start == end) - { - continue; - } - - if (!CheckIfOppositesAreEqual(start, end, row)) + var column = columnIndices[index]; + if (!values[index].Equals(At(column, row))) { return false; } } - - return true; } + + return true; } /// - /// Checks if opposites in a range are equal. + /// Evaluates whether this matrix is conjugate symmetric. /// - /// The start of the range. - /// The end of the range. - /// The row the row to check. - /// If the values are equal or not. - private bool CheckIfOppositesAreEqual(int start, int end, int row) + public override bool IsConjugateSymmetric() { + if (RowCount != ColumnCount) + { + return false; + } + + var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; - for (var index = start; index < end; index++) + for (var row = 0; row < RowCount; row++) { - var column = columnIndices[index]; - var opposite = At(column, row); - if (!values[index].Equals(opposite)) + var start = rowPointers[row]; + var end = rowPointers[row + 1]; + + if (start == end) { - return false; + continue; + } + + for (var index = start; index < end; index++) + { + var column = columnIndices[index]; + if (!values[index].Equals(At(column, row).Conjugate())) + { + return false; + } } } diff --git a/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs index c433b597..bb9e12d2 100644 --- a/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs @@ -1180,6 +1180,31 @@ namespace MathNet.Numerics.LinearAlgebra.Double return (DenseMatrix)leftSide.Remainder(rightSide); } + /// + /// Evaluates whether this matrix is symmetric. + /// + public override bool IsSymmetric() + { + if (RowCount != ColumnCount) + { + return false; + } + + for (var j = 0; j < ColumnCount; j++) + { + var index = j * RowCount; + for (var i = j + 1; i < RowCount; i++) + { + if (_values[(i*ColumnCount) + j] != _values[index + i]) + { + return false; + } + } + } + + return true; + } + public override Cholesky Cholesky() { return DenseCholesky.Create(this); diff --git a/src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs b/src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs index bed0524a..052bf3f7 100644 --- a/src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs +++ b/src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs @@ -799,14 +799,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public override bool IsSymmetric + public override sealed bool IsSymmetric() { - get - { - return true; - } + return true; } /// diff --git a/src/Numerics/LinearAlgebra/Double/Matrix.cs b/src/Numerics/LinearAlgebra/Double/Matrix.cs index 2285e5bc..7ba8f7e6 100644 --- a/src/Numerics/LinearAlgebra/Double/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Double/Matrix.cs @@ -656,6 +656,14 @@ namespace MathNet.Numerics.LinearAlgebra.Double return sum; } + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public override sealed bool IsConjugateSymmetric() + { + return IsSymmetric(); + } + public override Cholesky Cholesky() { return UserCholesky.Create(this); diff --git a/src/Numerics/LinearAlgebra/Double/SparseMatrix.cs b/src/Numerics/LinearAlgebra/Double/SparseMatrix.cs index 550f8eab..eb2cbdb1 100644 --- a/src/Numerics/LinearAlgebra/Double/SparseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Double/SparseMatrix.cs @@ -1256,58 +1256,36 @@ namespace MathNet.Numerics.LinearAlgebra.Double } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public override bool IsSymmetric + public override bool IsSymmetric() { - get + if (RowCount != ColumnCount) { - if (RowCount != ColumnCount) - { - return false; - } - - // todo: we might be able to speed this up by caching one half of the matrix - var rowPointers = _storage.RowPointers; - for (var row = 0; row < RowCount; row++) - { - var start = rowPointers[row]; - var end = rowPointers[row + 1]; - - if (start == end) - { - continue; - } - - if (!CheckIfOppositesAreEqual(start, end, row)) - { - return false; - } - } - - return true; + return false; } - } - /// - /// Checks if opposites in a range are equal. - /// - /// The start of the range. - /// The end of the range. - /// The row the row to check. - /// If the values are equal or not. - private bool CheckIfOppositesAreEqual(int start, int end, int row) - { + var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; - for (var index = start; index < end; index++) + for (var row = 0; row < RowCount; row++) { - var column = columnIndices[index]; - var opposite = At(column, row); - if (!values[index].Equals(opposite)) + var start = rowPointers[row]; + var end = rowPointers[row + 1]; + + if (start == end) + { + continue; + } + + for (var index = start; index < end; index++) { - return false; + var column = columnIndices[index]; + if (!values[index].Equals(At(column, row))) + { + return false; + } } } diff --git a/src/Numerics/LinearAlgebra/Matrix.cs b/src/Numerics/LinearAlgebra/Matrix.cs index 96ffa61b..680d83e4 100644 --- a/src/Numerics/LinearAlgebra/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Matrix.cs @@ -1268,32 +1268,34 @@ namespace MathNet.Numerics.LinearAlgebra } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public virtual bool IsSymmetric + public virtual bool IsSymmetric() { - get + if (RowCount != ColumnCount) { - if (RowCount != ColumnCount) - { - return false; - } + return false; + } - for (var row = 0; row < RowCount; row++) + for (var row = 0; row < RowCount; row++) + { + for (var column = row + 1; column < ColumnCount; column++) { - for (var column = row + 1; column < ColumnCount; column++) + if (!At(row, column).Equals(At(column, row))) { - if (!At(row, column).Equals(At(column, row))) - { - return false; - } + return false; } } - - return true; } + + return true; } + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public abstract bool IsConjugateSymmetric(); + /// /// Returns this matrix as a multidimensional array. /// diff --git a/src/Numerics/LinearAlgebra/Single/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Single/DenseMatrix.cs index 49830598..6d61b1e9 100644 --- a/src/Numerics/LinearAlgebra/Single/DenseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Single/DenseMatrix.cs @@ -1180,6 +1180,31 @@ namespace MathNet.Numerics.LinearAlgebra.Single return (DenseMatrix)leftSide.Remainder(rightSide); } + /// + /// Evaluates whether this matrix is symmetric. + /// + public override bool IsSymmetric() + { + if (RowCount != ColumnCount) + { + return false; + } + + for (var j = 0; j < ColumnCount; j++) + { + var index = j * RowCount; + for (var i = j + 1; i < RowCount; i++) + { + if (_values[(i*ColumnCount) + j] != _values[index + i]) + { + return false; + } + } + } + + return true; + } + public override Cholesky Cholesky() { return DenseCholesky.Create(this); diff --git a/src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs b/src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs index 7b07623c..8d3ddc46 100644 --- a/src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs +++ b/src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs @@ -799,14 +799,11 @@ namespace MathNet.Numerics.LinearAlgebra.Single } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public override bool IsSymmetric + public override sealed bool IsSymmetric() { - get - { - return true; - } + return true; } /// diff --git a/src/Numerics/LinearAlgebra/Single/Matrix.cs b/src/Numerics/LinearAlgebra/Single/Matrix.cs index ee0f66ea..349ad3c9 100644 --- a/src/Numerics/LinearAlgebra/Single/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Single/Matrix.cs @@ -656,6 +656,14 @@ namespace MathNet.Numerics.LinearAlgebra.Single return sum; } + /// + /// Evaluates whether this matrix is conjugate symmetric. + /// + public override sealed bool IsConjugateSymmetric() + { + return IsSymmetric(); + } + public override Cholesky Cholesky() { return UserCholesky.Create(this); diff --git a/src/Numerics/LinearAlgebra/Single/SparseMatrix.cs b/src/Numerics/LinearAlgebra/Single/SparseMatrix.cs index a7e1d560..615f63f5 100644 --- a/src/Numerics/LinearAlgebra/Single/SparseMatrix.cs +++ b/src/Numerics/LinearAlgebra/Single/SparseMatrix.cs @@ -1261,58 +1261,38 @@ namespace MathNet.Numerics.LinearAlgebra.Single } /// - /// Gets a value indicating whether this matrix is symmetric. + /// Evaluates whether this matrix is symmetric. /// - public override bool IsSymmetric + public override bool IsSymmetric() { - get + if (RowCount != ColumnCount) { - if (RowCount != ColumnCount) - { - return false; - } - - // todo: we might be able to speed this up by caching one half of the matrix - var rowPointers = _storage.RowPointers; - for (var row = 0; row < RowCount; row++) - { - var start = rowPointers[row]; - var end = rowPointers[row + 1]; - - if (start == end) - { - continue; - } - - if (!CheckIfOppositesAreEqual(start, end, row)) - { - return false; - } - } - - return true; + return false; } - } - /// - /// Checks if opposites in a range are equal. - /// - /// The start of the range. - /// The end of the range. - /// The row the row to check. - /// If the values are equal or not. - private bool CheckIfOppositesAreEqual(int start, int end, int row) - { + // todo: we might be able to speed this up by caching one half of the matrix + var rowPointers = _storage.RowPointers; var columnIndices = _storage.ColumnIndices; var values = _storage.Values; - for (var index = start; index < end; index++) + for (var row = 0; row < RowCount; row++) { - var column = columnIndices[index]; - var opposite = At(column, row); - if (!values[index].Equals(opposite)) + var start = rowPointers[row]; + var end = rowPointers[row + 1]; + + if (start == end) + { + continue; + } + + for (var index = start; index < end; index++) { - return false; + var column = columnIndices[index]; + var opposite = At(column, row); + if (!values[index].Equals(opposite)) + { + return false; + } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs index 6f0d0c5c..412d1cca 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs @@ -362,7 +362,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public override void CanCheckIfMatrixIsSymmetric() { var matrix = TestMatrices["Square3x3"]; - Assert.IsTrue(matrix.IsSymmetric); + Assert.IsTrue(matrix.IsSymmetric()); } [Test] diff --git a/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs index 1161c4a1..7eb85392 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs @@ -156,10 +156,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex public virtual void CanCheckIfMatrixIsSymmetric() { var matrix = TestMatrices["Symmetric3x3"]; - Assert.IsTrue(matrix.IsSymmetric); + Assert.IsTrue(matrix.IsSymmetric()); matrix = TestMatrices["Square3x3"]; - Assert.IsFalse(matrix.IsSymmetric); + Assert.IsFalse(matrix.IsSymmetric()); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs index bffa92cc..8381efbc 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs @@ -358,7 +358,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public override void CanCheckIfMatrixIsSymmetric() { var matrix = TestMatrices["Square3x3"]; - Assert.IsTrue(matrix.IsSymmetric); + Assert.IsTrue(matrix.IsSymmetric()); } [Test] diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs index 936977a0..c6ecf226 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs @@ -156,10 +156,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32 public virtual void CanCheckIfMatrixIsSymmetric() { var matrix = TestMatrices["Symmetric3x3"]; - Assert.IsTrue(matrix.IsSymmetric); + Assert.IsTrue(matrix.IsSymmetric()); matrix = TestMatrices["Square3x3"]; - Assert.IsFalse(matrix.IsSymmetric); + Assert.IsFalse(matrix.IsSymmetric()); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs index 82c120b7..50cae94e 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs @@ -357,7 +357,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public override void CanCheckIfMatrixIsSymmetric() { var matrix = TestMatrices["Square3x3"]; - Assert.IsTrue(matrix.IsSymmetric); + Assert.IsTrue(matrix.IsSymmetric()); } [Test] diff --git a/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs index 4d58a443..7f8aad0d 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs @@ -129,10 +129,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double public virtual void CanCheckIfMatrixIsSymmetric() { var matrix = TestMatrices["Symmetric3x3"]; - Assert.IsTrue(matrix.IsSymmetric); + Assert.IsTrue(matrix.IsSymmetric()); matrix = TestMatrices["Square3x3"]; - Assert.IsFalse(matrix.IsSymmetric); + Assert.IsFalse(matrix.IsSymmetric()); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs index c28ce158..32d2c189 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs @@ -356,7 +356,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public override void CanCheckIfMatrixIsSymmetric() { var matrix = TestMatrices["Square3x3"]; - Assert.IsTrue(matrix.IsSymmetric); + Assert.IsTrue(matrix.IsSymmetric()); } [Test] diff --git a/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs index c4b9371a..67bfcd12 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs @@ -129,10 +129,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single public virtual void CanCheckIfMatrixIsSymmetric() { var matrix = TestMatrices["Symmetric3x3"]; - Assert.IsTrue(matrix.IsSymmetric); + Assert.IsTrue(matrix.IsSymmetric()); matrix = TestMatrices["Square3x3"]; - Assert.IsFalse(matrix.IsSymmetric); + Assert.IsFalse(matrix.IsSymmetric()); } } }