tsai
/
mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Tests: replace matrix structural tests with theory (part 4) - Triangle, Diagonal

pull/47/head
Christoph Ruegg 14 years ago
parent
5d7fc8e67e
commit
0fd379dffe
13 changed files with 401 additions and 3007 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 88
      src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs
  2. 5
      src/UnitTests/LinearAlgebraTests/Complex/MatrixStructureTheory.cs
  3. 676
      src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs
  4. 88
      src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs
  5. 5
      src/UnitTests/LinearAlgebraTests/Complex32/MatrixStructureTheory.cs
  6. 676
      src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs
  7. 88
      src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs
  8. 5
      src/UnitTests/LinearAlgebraTests/Double/MatrixStructureTheory.cs
  9. 640
      src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs
  10. 404
      src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs
  11. 88
      src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs
  12. 5
      src/UnitTests/LinearAlgebraTests/Single/MatrixStructureTheory.cs
  13. 640
      src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs

88
src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs
View File

@ -320,94 +320,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
}
}
/// <summary>
/// Can set a column with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column array.</param>
public override void CanSetColumnWithArray(string name, double[] column)
{
try
{
// Pass all invoke to base
base.CanSetColumnWithArray(name, column);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a column with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column values.</param>
public override void CanSetColumnWithVector(string name, double[] column)
{
try
{
// Pass all invoke to base
base.CanSetColumnWithVector(name, column);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a row with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row values.</param>
public override void CanSetRowWithArray(string name, double[] row)
{
try
{
// Pass all invoke to base
base.CanSetRowWithArray(name, row);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a row with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
public override void CanSetRowWithVector(string name, double[] row)
{
try
{
// Pass all invoke to base
base.CanSetRowWithVector(name, row);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a submatrix.
/// </summary>

5
src/UnitTests/LinearAlgebraTests/Complex/MatrixStructureTheory.cs
View File

@ -46,5 +46,10 @@
{
return new DenseVector(size);
}
protected override Complex Zero
{
get { return Complex.Zero; }
}
}
}

676
src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs
View File

@ -36,350 +36,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
/// </summary>
public abstract partial class MatrixTests : MatrixLoader
{
/// <summary>
/// Can set a row.
/// </summary>
/// <param name="rowIndex">Row index.</param>
/// <param name="name">Matrix name.</param>
[TestCase(0, "Singular3x3")]
[TestCase(1, "Square3x3")]
[TestCase(2, "Square3x3")]
public void CanSetRow(int rowIndex, string name)
{
var matrix = TestMatrices[name].Clone();
matrix.SetRow(rowIndex, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(i == rowIndex ? Complex.Zero : TestMatrices[name][i, j], matrix[i, j]);
}
}
}
/// <summary>
/// Can set a column.
/// </summary>
/// <param name="colIndex">Column index.</param>
/// <param name="name">Matrix name.</param>
[TestCase(0, "Singular3x3")]
[TestCase(1, "Square3x3")]
[TestCase(2, "Square3x3")]
public void CanSetColumn(int colIndex, string name)
{
var matrix = TestMatrices[name].Clone();
matrix.SetColumn(colIndex, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(j == colIndex ? Complex.Zero : TestMatrices[name][i, j], matrix[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanUpperTriangle(string name)
{
var data = TestMatrices[name];
var upper = data.UpperTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i <= j ? data[i, j] : Complex.Zero, upper[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix into a result matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanUpperTriangleIntoResult(string name)
{
var data = TestMatrices[name];
var result = CreateMatrix(data.RowCount, data.ColumnCount);
data.UpperTriangle(result);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i <= j ? data[i, j] : Complex.Zero, result[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix into <c>null</c> result matrix throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultNullThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<Complex> result = null;
Assert.Throws<ArgumentNullException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get an upper triangle into a result matrix with unequal rows throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultWithUnEqualRowsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get an upper triangle into a result matrix with unequal columns throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultWithUnEqualColumnsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get a lower triangle matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanLowerTriangle(string name)
{
var data = TestMatrices[name];
var lower = data.LowerTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i >= j ? data[i, j] : Complex.Zero, lower[i, j]);
}
}
}
/// <summary>
/// Get a lower triangle matrix into a result matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanLowerTriangleIntoResult(string name)
{
var data = TestMatrices[name];
var result = CreateMatrix(data.RowCount, data.ColumnCount);
data.LowerTriangle(result);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i >= j ? data[i, j] : Complex.Zero, result[i, j]);
}
}
}
/// <summary>
/// Get a lower triangle matrix into <c>null</c> result matrix throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultNullThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<Complex> result = null;
Assert.Throws<ArgumentNullException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a lower triangle into a result matrix with unequal rows throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultWithUnEqualRowsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a lower triangle into a result matrix with unequal columns throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultWithUnEqualColumnsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a strictly lower triangle.
/// </summary>
[Test]
public void CanStrictlyLowerTriangle()
{
foreach (var data in TestMatrices.Values)
{
var lower = data.StrictlyLowerTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i > j ? data[i, j] : Complex.Zero, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly lower triangle into a result matrix.
/// </summary>
[Test]
public void CanStrictlyLowerTriangleIntoResult()
{
foreach (var data in TestMatrices.Values)
{
var lower = CreateMatrix(data.RowCount, data.ColumnCount);
data.StrictlyLowerTriangle(lower);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i > j ? data[i, j] : Complex.Zero, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly lower triangle with <c>null</c> parameter throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleWithNullParameterThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<Complex> lower = null;
Assert.Throws<ArgumentNullException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly lower triangle into result with unequal column number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleIntoResultWithUnequalColumnNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly lower triangle into result with unequal row number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleIntoResultWithUnequalRowNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle.
/// </summary>
[Test]
public void CanStrictlyUpperTriangle()
{
foreach (var data in TestMatrices.Values)
{
var lower = data.StrictlyUpperTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i < j ? data[i, j] : Complex.Zero, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly upper triangle into a result matrix.
/// </summary>
[Test]
public void CanStrictlyUpperTriangleIntoResult()
{
foreach (var data in TestMatrices.Values)
{
var lower = CreateMatrix(data.RowCount, data.ColumnCount);
data.StrictlyUpperTriangle(lower);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i < j ? data[i, j] : Complex.Zero, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly upper triangle with <c>null</c> parameter throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleWithNullParameterThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<Complex> lower = null;
Assert.Throws<ArgumentNullException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle into a result matrix with unequal column number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleIntoResultWithUnequalColumnNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle into a result matrix with unequal row number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleIntoResultWithUnequalRowNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Can transpose a matrix.
/// </summary>
@ -432,129 +88,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
}
}
/// <summary>
/// Can set a column with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Column real values array.</param>
[TestCase("Singular3x3", new double[] { 1, 2, 3 })]
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Tall3x2", new double[] { 1, 2, 3 })]
[TestCase("Wide2x3", new double[] { 1, 2 })]
public virtual void CanSetColumnWithArray(string name, double[] real)
{
var column = new Complex[real.Length];
for (var i = 0; i < real.Length; i++)
{
column[i] = new Complex(real[i], 1);
}
var matrix = TestMatrices[name];
for (var i = 0; i < matrix.ColumnCount; i++)
{
matrix.SetColumn(i, column);
for (var j = 0; j < matrix.RowCount; j++)
{
Assert.AreEqual(matrix[j, i], column[j]);
}
}
}
/// <summary>
/// Set a column with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithNullArrayThrowsArgumentNullException()
{
Complex[] vec = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Singular3x3"].SetColumn(1, vec));
}
/// <summary>
/// Set a column with unequal array length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithArrayUnequalLengthThrowsArgumentException()
{
var array = new Complex[] { 1, 2, 3, 4, 5 };
Assert.Throws<ArgumentException>(() => TestMatrices["Singular3x3"].SetColumn(1, array));
}
/// <summary>
/// Set a column array with invalid column index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetColumnWithArrayWithInvalidColumnIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
Complex[] column = { 1, 2, 3 };
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(matrix.ColumnCount + 1, column));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(-1, column));
}
/// <summary>
/// Can set a column with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Column real values.</param>
[TestCase("Singular3x3", new double[] { 1, 2, 3 })]
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Tall3x2", new double[] { 1, 2, 3 })]
[TestCase("Wide2x3", new double[] { 1, 2 })]
public virtual void CanSetColumnWithVector(string name, double[] real)
{
var column = new Complex[real.Length];
for (var i = 0; i < real.Length; i++)
{
column[i] = new Complex(real[i], 1);
}
var matrix = TestMatrices[name];
var columnVector = CreateVector(column);
for (var i = 0; i < matrix.ColumnCount; i++)
{
matrix.SetColumn(i, column);
for (var j = 0; j < matrix.RowCount; j++)
{
Assert.AreEqual(matrix[j, i], columnVector[j]);
}
}
}
/// <summary>
/// Set a column with vector with wrong length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithVectorWithUnequalLengthThrowsArgumentException()
{
var matrix = TestMatrices["Singular3x3"];
var columnVector = CreateVector(new Complex[] { 1, 2, 3, 4, 5 });
Assert.Throws<ArgumentException>(() => matrix.SetColumn(1, columnVector));
}
/// <summary>
/// Set a column with <c>null</c> vector throw <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetColumnWithNullVectorThrowsArgumentNullException()
{
var matrix = TestMatrices["Square3x3"];
Vector<Complex> columnVector = null;
Assert.Throws<ArgumentNullException>(() => matrix.SetColumn(1, columnVector));
}
/// <summary>
/// Set column vector with invalid column index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetColumnWithVectorWithInvalidColumnIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
var column = CreateVector(new Complex[] { 1, 2, 3 });
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(-1, column));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(matrix.ColumnCount + 1, column));
}
/// <summary>
/// Can insert a column.
/// </summary>
@ -615,118 +148,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
Assert.Throws<ArgumentException>(() => matrix.InsertColumn(0, column));
}
/// <summary>
/// Can set a row with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Row index.</param>
[TestCase("Singular3x3", new double[] { 1, 2, 3 })]
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Tall3x2", new double[] { 1, 2 })]
[TestCase("Wide2x3", new double[] { 1, 2, 3 })]
public virtual void CanSetRowWithArray(string name, double[] real)
{
var row = new Complex[real.Length];
for (var i = 0; i < real.Length; i++)
{
row[i] = new Complex(real[i], 1);
}
var matrix = TestMatrices[name];
for (var i = 0; i < matrix.RowCount; i++)
{
matrix.SetRow(i, row);
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], row[j]);
}
}
}
/// <summary>
/// Set a row with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public virtual void SetRowWithNullArrayThrowsArgumentNullException()
{
Complex[] arr = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetRow(1, arr));
}
/// <summary>
/// Set a row with an array with invalid row index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetRowWithArrayWithInvalidRowIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
Complex[] row = { 1, 2, 3 };
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(-1, row));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(matrix.RowCount + 1, row));
}
/// <summary>
/// Can set a row with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Row real values.</param>
[TestCase("Singular3x3", new double[] { 1, 2, 3 })]
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Tall3x2", new double[] { 1, 2 })]
[TestCase("Wide2x3", new double[] { 1, 2, 3 })]
public virtual void CanSetRowWithVector(string name, double[] real)
{
var row = new Complex[real.Length];
for (var i = 0; i < real.Length; i++)
{
row[i] = new Complex(real[i], 1);
}
var matrix = TestMatrices[name];
var rowVector = CreateVector(row);
for (var i = 0; i < matrix.RowCount; i++)
{
matrix.SetRow(i, row);
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], rowVector[j]);
}
}
}
/// <summary>
/// Set a row with a vector of unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetRowWithVectorWithUnequalLengthThrowsArgumentException()
{
var vec = CreateVector(new Complex[] { 1, 2, 3, 4, 5 });
Assert.Throws<ArgumentException>(() => TestMatrices["Square3x3"].SetRow(1, vec));
}
/// <summary>
/// Set a row with a <c>null</c> vector throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetRowWithNullVectorThrowsArgumentNullException()
{
var matrix = TestMatrices["Square3x3"];
Vector<Complex> rowVector = null;
Assert.Throws<ArgumentNullException>(() => matrix.SetRow(1, rowVector));
}
/// <summary>
/// Set a row with a vector with invalid row index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetRowWithVectorWithInvalidRowIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
var row = CreateVector(new Complex[] { 1, 2, 3 });
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(-1, row));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(matrix.RowCount + 1, row));
}
/// <summary>
/// Can set a submatrix.
/// </summary>
@ -809,103 +230,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetSubMatrix(0, 2, 0, 2, subMatrix));
}
/// <summary>
/// Can set a diagonal vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Diagonal real values.</param>
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Wide2x3", new double[] { 1, 2 })]
[TestCase("Tall3x2", new double[] { 1, 2 })]
public void CanSetDiagonalVector(string name, double[] real)
{
var diagonal = new Complex[real.Length];
for (var i = 0; i < real.Length; i++)
{
diagonal[i] = new Complex(real[i], 1);
}
var matrix = TestMatrices[name];
var vector = CreateVector(diagonal);
matrix.SetDiagonal(vector);
var min = Math.Min(matrix.ColumnCount, matrix.RowCount);
Assert.AreEqual(diagonal.Length, min);
for (var i = 0; i < vector.Count; i++)
{
Assert.AreEqual(vector[i], matrix[i, i]);
}
}
/// <summary>
/// Set a diagonal vector with unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void SetDiagonalVectorWithUnequalLengthThrowsArgumentException()
{
var vector = CreateVector(new Complex[] { 1, 2, 3 });
Assert.Throws<ArgumentException>(() => TestMatrices["Wide2x3"].SetDiagonal(vector));
}
/// <summary>
/// Set a diagonal with <c>null</c> vector throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetDiagonalWithNullVectorThrowsArgumentNullException()
{
Vector<Complex> vector = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetDiagonal(vector));
}
/// <summary>
/// Can set a diagonal array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Diagonal real values.</param>
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Wide2x3", new double[] { 1, 2 })]
[TestCase("Tall3x2", new double[] { 1, 2 })]
public void CanSetDiagonalArray(string name, double[] real)
{
var diagonal = new Complex[real.Length];
for (var i = 0; i < real.Length; i++)
{
diagonal[i] = new Complex(real[i], 1);
}
var matrix = TestMatrices[name];
matrix.SetDiagonal(diagonal);
var min = Math.Min(matrix.ColumnCount, matrix.RowCount);
Assert.AreEqual(diagonal.Length, min);
for (var i = 0; i < diagonal.Length; i++)
{
Assert.AreEqual(diagonal[i], matrix[i, i]);
}
}
/// <summary>
/// Set a diagonal array with unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void SetDiagonalArrayWithUnequalLengthThrowsArgumentException()
{
var array = new Complex[] { 1, 2, 3 };
Assert.Throws<ArgumentException>(() => TestMatrices["Wide2x3"].SetDiagonal(array));
}
/// <summary>
/// Set a diagonal with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetDiagonalWithNullArrayThrowsArgumentNullException()
{
Complex[] array = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetDiagonal(array));
}
/// <summary>
/// Can insert a row.
/// </summary>

88
src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs
View File

@ -320,94 +320,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
}
}
/// <summary>
/// Can set a column with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column array.</param>
public override void CanSetColumnWithArray(string name, float[] column)
{
try
{
// Pass all invoke to base
base.CanSetColumnWithArray(name, column);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a column with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column values.</param>
public override void CanSetColumnWithVector(string name, float[] column)
{
try
{
// Pass all invoke to base
base.CanSetColumnWithVector(name, column);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a row with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row values.</param>
public override void CanSetRowWithArray(string name, float[] row)
{
try
{
// Pass all invoke to base
base.CanSetRowWithArray(name, row);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a row with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
public override void CanSetRowWithVector(string name, float[] row)
{
try
{
// Pass all invoke to base
base.CanSetRowWithVector(name, row);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a submatrix.
/// </summary>

5
src/UnitTests/LinearAlgebraTests/Complex32/MatrixStructureTheory.cs
View File

@ -46,5 +46,10 @@
{
return new DenseVector(size);
}
protected override Complex32 Zero
{
get { return Complex32.Zero; }
}
}
}

676
src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs
View File

@ -36,350 +36,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
/// </summary>
public abstract partial class MatrixTests : MatrixLoader
{
/// <summary>
/// Can set a row.
/// </summary>
/// <param name="rowIndex">Row index.</param>
/// <param name="name">Matrix name.</param>
[TestCase(0, "Singular3x3")]
[TestCase(1, "Square3x3")]
[TestCase(2, "Square3x3")]
public void CanSetRow(int rowIndex, string name)
{
var matrix = TestMatrices[name].Clone();
matrix.SetRow(rowIndex, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(i == rowIndex ? Complex32.Zero : TestMatrices[name][i, j], matrix[i, j]);
}
}
}
/// <summary>
/// Can set a column.
/// </summary>
/// <param name="colIndex">Column index.</param>
/// <param name="name">Matrix name.</param>
[TestCase(0, "Singular3x3")]
[TestCase(1, "Square3x3")]
[TestCase(2, "Square3x3")]
public void CanSetColumn(int colIndex, string name)
{
var matrix = TestMatrices[name].Clone();
matrix.SetColumn(colIndex, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(j == colIndex ? Complex32.Zero : TestMatrices[name][i, j], matrix[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanUpperTriangle(string name)
{
var data = TestMatrices[name];
var upper = data.UpperTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i <= j ? data[i, j] : Complex32.Zero, upper[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix into a result matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanUpperTriangleIntoResult(string name)
{
var data = TestMatrices[name];
var result = CreateMatrix(data.RowCount, data.ColumnCount);
data.UpperTriangle(result);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i <= j ? data[i, j] : Complex32.Zero, result[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix into <c>null</c> result matrix throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultNullThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<Complex32> result = null;
Assert.Throws<ArgumentNullException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get an upper triangle into a result matrix with unequal rows throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultWithUnEqualRowsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get an upper triangle into a result matrix with unequal columns throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultWithUnEqualColumnsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get a lower triangle matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanLowerTriangle(string name)
{
var data = TestMatrices[name];
var lower = data.LowerTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i >= j ? data[i, j] : Complex32.Zero, lower[i, j]);
}
}
}
/// <summary>
/// Get a lower triangle matrix into a result matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanLowerTriangleIntoResult(string name)
{
var data = TestMatrices[name];
var result = CreateMatrix(data.RowCount, data.ColumnCount);
data.LowerTriangle(result);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i >= j ? data[i, j] : Complex32.Zero, result[i, j]);
}
}
}
/// <summary>
/// Get a lower triangle matrix into <c>null</c> result matrix throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultNullThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<Complex32> result = null;
Assert.Throws<ArgumentNullException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a lower triangle into a result matrix with unequal rows throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultWithUnEqualRowsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a lower triangle into a result matrix with unequal columns throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultWithUnEqualColumnsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a strictly lower triangle.
/// </summary>
[Test]
public void CanStrictlyLowerTriangle()
{
foreach (var data in TestMatrices.Values)
{
var lower = data.StrictlyLowerTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i > j ? data[i, j] : Complex32.Zero, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly lower triangle into a result matrix.
/// </summary>
[Test]
public void CanStrictlyLowerTriangleIntoResult()
{
foreach (var data in TestMatrices.Values)
{
var lower = CreateMatrix(data.RowCount, data.ColumnCount);
data.StrictlyLowerTriangle(lower);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i > j ? data[i, j] : Complex32.Zero, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly lower triangle with <c>null</c> parameter throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleWithNullParameterThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<Complex32> lower = null;
Assert.Throws<ArgumentNullException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly lower triangle into result with unequal column number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleIntoResultWithUnequalColumnNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly lower triangle into result with unequal row number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleIntoResultWithUnequalRowNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle.
/// </summary>
[Test]
public void CanStrictlyUpperTriangle()
{
foreach (var data in TestMatrices.Values)
{
var lower = data.StrictlyUpperTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i < j ? data[i, j] : Complex32.Zero, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly upper triangle into a result matrix.
/// </summary>
[Test]
public void CanStrictlyUpperTriangleIntoResult()
{
foreach (var data in TestMatrices.Values)
{
var lower = CreateMatrix(data.RowCount, data.ColumnCount);
data.StrictlyUpperTriangle(lower);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i < j ? data[i, j] : Complex32.Zero, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly upper triangle with <c>null</c> parameter throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleWithNullParameterThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<Complex32> lower = null;
Assert.Throws<ArgumentNullException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle into a result matrix with unequal column number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleIntoResultWithUnequalColumnNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle into a result matrix with unequal row number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleIntoResultWithUnequalRowNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Can transpose a matrix.
/// </summary>
@ -432,129 +88,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
}
}
/// <summary>
/// Can set a column with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Column real values array.</param>
[TestCase("Singular3x3", new float[] { 1, 2, 3 })]
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Tall3x2", new float[] { 1, 2, 3 })]
[TestCase("Wide2x3", new float[] { 1, 2 })]
public virtual void CanSetColumnWithArray(string name, float[] real)
{
var column = new Complex32[real.Length];
for (var i = 0; i < real.Length; i++)
{
column[i] = new Complex32(real[i], 1);
}
var matrix = TestMatrices[name];
for (var i = 0; i < matrix.ColumnCount; i++)
{
matrix.SetColumn(i, column);
for (var j = 0; j < matrix.RowCount; j++)
{
Assert.AreEqual(matrix[j, i], column[j]);
}
}
}
/// <summary>
/// Set a column with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithNullArrayThrowsArgumentNullException()
{
Complex32[] vec = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Singular3x3"].SetColumn(1, vec));
}
/// <summary>
/// Set a column with unequal array length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithArrayUnequalLengthThrowsArgumentException()
{
var array = new Complex32[] { 1, 2, 3, 4, 5 };
Assert.Throws<ArgumentException>(() => TestMatrices["Singular3x3"].SetColumn(1, array));
}
/// <summary>
/// Set a column array with invalid column index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetColumnWithArrayWithInvalidColumnIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
Complex32[] column = { 1, 2, 3 };
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(matrix.ColumnCount + 1, column));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(-1, column));
}
/// <summary>
/// Can set a column with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Column real values.</param>
[TestCase("Singular3x3", new float[] { 1, 2, 3 })]
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Tall3x2", new float[] { 1, 2, 3 })]
[TestCase("Wide2x3", new float[] { 1, 2 })]
public virtual void CanSetColumnWithVector(string name, float[] real)
{
var column = new Complex32[real.Length];
for (var i = 0; i < real.Length; i++)
{
column[i] = new Complex32(real[i], 1);
}
var matrix = TestMatrices[name];
var columnVector = CreateVector(column);
for (var i = 0; i < matrix.ColumnCount; i++)
{
matrix.SetColumn(i, column);
for (var j = 0; j < matrix.RowCount; j++)
{
Assert.AreEqual(matrix[j, i], columnVector[j]);
}
}
}
/// <summary>
/// Set a column with vector with wrong length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithVectorWithUnequalLengthThrowsArgumentException()
{
var matrix = TestMatrices["Singular3x3"];
var columnVector = CreateVector(new Complex32[] { 1, 2, 3, 4, 5 });
Assert.Throws<ArgumentException>(() => matrix.SetColumn(1, columnVector));
}
/// <summary>
/// Set a column with <c>null</c> vector throw <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetColumnWithNullVectorThrowsArgumentNullException()
{
var matrix = TestMatrices["Square3x3"];
Vector<Complex32> columnVector = null;
Assert.Throws<ArgumentNullException>(() => matrix.SetColumn(1, columnVector));
}
/// <summary>
/// Set column vector with invalid column index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetColumnWithVectorWithInvalidColumnIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
var column = CreateVector(new Complex32[] { 1, 2, 3 });
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(-1, column));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(matrix.ColumnCount + 1, column));
}
/// <summary>
/// Can insert a column.
/// </summary>
@ -615,118 +148,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
Assert.Throws<ArgumentException>(() => matrix.InsertColumn(0, column));
}
/// <summary>
/// Can set a row with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Row index.</param>
[TestCase("Singular3x3", new float[] { 1, 2, 3 })]
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Tall3x2", new float[] { 1, 2 })]
[TestCase("Wide2x3", new float[] { 1, 2, 3 })]
public virtual void CanSetRowWithArray(string name, float[] real)
{
var row = new Complex32[real.Length];
for (var i = 0; i < real.Length; i++)
{
row[i] = new Complex32(real[i], 1);
}
var matrix = TestMatrices[name];
for (var i = 0; i < matrix.RowCount; i++)
{
matrix.SetRow(i, row);
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], row[j]);
}
}
}
/// <summary>
/// Set a row with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public virtual void SetRowWithNullArrayThrowsArgumentNullException()
{
Complex32[] arr = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetRow(1, arr));
}
/// <summary>
/// Set a row with an array with invalid row index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetRowWithArrayWithInvalidRowIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
Complex32[] row = { 1, 2, 3 };
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(-1, row));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(matrix.RowCount + 1, row));
}
/// <summary>
/// Can set a row with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Row real values.</param>
[TestCase("Singular3x3", new float[] { 1, 2, 3 })]
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Tall3x2", new float[] { 1, 2 })]
[TestCase("Wide2x3", new float[] { 1, 2, 3 })]
public virtual void CanSetRowWithVector(string name, float[] real)
{
var row = new Complex32[real.Length];
for (var i = 0; i < real.Length; i++)
{
row[i] = new Complex32(real[i], 1);
}
var matrix = TestMatrices[name];
var rowVector = CreateVector(row);
for (var i = 0; i < matrix.RowCount; i++)
{
matrix.SetRow(i, row);
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], rowVector[j]);
}
}
}
/// <summary>
/// Set a row with a vector of unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetRowWithVectorWithUnequalLengthThrowsArgumentException()
{
var vec = CreateVector(new Complex32[] { 1, 2, 3, 4, 5 });
Assert.Throws<ArgumentException>(() => TestMatrices["Square3x3"].SetRow(1, vec));
}
/// <summary>
/// Set a row with a <c>null</c> vector throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetRowWithNullVectorThrowsArgumentNullException()
{
var matrix = TestMatrices["Square3x3"];
Vector<Complex32> rowVector = null;
Assert.Throws<ArgumentNullException>(() => matrix.SetRow(1, rowVector));
}
/// <summary>
/// Set a row with a vector with invalid row index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetRowWithVectorWithInvalidRowIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
var row = CreateVector(new Complex32[] { 1, 2, 3 });
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(-1, row));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(matrix.RowCount + 1, row));
}
/// <summary>
/// Can set a submatrix.
/// </summary>
@ -809,103 +230,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetSubMatrix(0, 2, 0, 2, subMatrix));
}
/// <summary>
/// Can set a diagonal vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Diagonal real values.</param>
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Wide2x3", new float[] { 1, 2 })]
[TestCase("Tall3x2", new float[] { 1, 2 })]
public void CanSetDiagonalVector(string name, float[] real)
{
var diagonal = new Complex32[real.Length];
for (var i = 0; i < real.Length; i++)
{
diagonal[i] = new Complex32(real[i], 1);
}
var matrix = TestMatrices[name];
var vector = CreateVector(diagonal);
matrix.SetDiagonal(vector);
var min = Math.Min(matrix.ColumnCount, matrix.RowCount);
Assert.AreEqual(diagonal.Length, min);
for (var i = 0; i < vector.Count; i++)
{
Assert.AreEqual(vector[i], matrix[i, i]);
}
}
/// <summary>
/// Set a diagonal vector with unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void SetDiagonalVectorWithUnequalLengthThrowsArgumentException()
{
var vector = CreateVector(new Complex32[] { 1, 2, 3 });
Assert.Throws<ArgumentException>(() => TestMatrices["Wide2x3"].SetDiagonal(vector));
}
/// <summary>
/// Set a diagonal with <c>null</c> vector throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetDiagonalWithNullVectorThrowsArgumentNullException()
{
Vector<Complex32> vector = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetDiagonal(vector));
}
/// <summary>
/// Can set a diagonal array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="real">Diagonal real values.</param>
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Wide2x3", new float[] { 1, 2 })]
[TestCase("Tall3x2", new float[] { 1, 2 })]
public void CanSetDiagonalArray(string name, float[] real)
{
var diagonal = new Complex32[real.Length];
for (var i = 0; i < real.Length; i++)
{
diagonal[i] = new Complex32(real[i], 1);
}
var matrix = TestMatrices[name];
matrix.SetDiagonal(diagonal);
var min = Math.Min(matrix.ColumnCount, matrix.RowCount);
Assert.AreEqual(diagonal.Length, min);
for (var i = 0; i < diagonal.Length; i++)
{
Assert.AreEqual(diagonal[i], matrix[i, i]);
}
}
/// <summary>
/// Set a diagonal array with unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void SetDiagonalArrayWithUnequalLengthThrowsArgumentException()
{
var array = new Complex32[] { 1, 2, 3 };
Assert.Throws<ArgumentException>(() => TestMatrices["Wide2x3"].SetDiagonal(array));
}
/// <summary>
/// Set a diagonal with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetDiagonalWithNullArrayThrowsArgumentNullException()
{
Complex32[] array = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetDiagonal(array));
}
/// <summary>
/// Can insert a row.
/// </summary>

88
src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs
View File

@ -320,94 +320,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
}
}
/// <summary>
/// Can set a column with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column array.</param>
public override void CanSetColumnWithArray(string name, double[] column)
{
try
{
// Pass all invoke to base
base.CanSetColumnWithArray(name, column);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a column with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column values.</param>
public override void CanSetColumnWithVector(string name, double[] column)
{
try
{
// Pass all invoke to base
base.CanSetColumnWithVector(name, column);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a row with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
public override void CanSetRowWithArray(string name, double[] row)
{
try
{
// Pass all invoke to base
base.CanSetRowWithArray(name, row);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a row with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
public override void CanSetRowWithVector(string name, double[] row)
{
try
{
// Pass all invoke to base
base.CanSetRowWithVector(name, row);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a submatrix.
/// </summary>

5
src/UnitTests/LinearAlgebraTests/Double/MatrixStructureTheory.cs
View File

@ -45,5 +45,10 @@
{
return new DenseVector(size);
}
protected override double Zero
{
get { return 0d; }
}
}
}

640
src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs
View File

@ -35,350 +35,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
/// </summary>
public abstract partial class MatrixTests : MatrixLoader
{
/// <summary>
/// Can set a row.
/// </summary>
/// <param name="rowIndex">Row index.</param>
/// <param name="name">Matrix name.</param>
[TestCase(0, "Singular3x3")]
[TestCase(1, "Square3x3")]
[TestCase(2, "Square3x3")]
public void CanSetRow(int rowIndex, string name)
{
var matrix = TestMatrices[name].Clone();
matrix.SetRow(rowIndex, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(i == rowIndex ? 0.0 : TestMatrices[name][i, j], matrix[i, j]);
}
}
}
/// <summary>
/// Can set a column.
/// </summary>
/// <param name="colIndex">Column index.</param>
/// <param name="name">Matrix name.</param>
[TestCase(0, "Singular3x3")]
[TestCase(1, "Square3x3")]
[TestCase(2, "Square3x3")]
public void CanSetColumn(int colIndex, string name)
{
var matrix = TestMatrices[name].Clone();
matrix.SetColumn(colIndex, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(j == colIndex ? 0.0 : TestMatrices[name][i, j], matrix[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanUpperTriangle(string name)
{
var data = TestMatrices[name];
var upper = data.UpperTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i <= j ? data[i, j] : 0, upper[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix into a result matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanUpperTriangleIntoResult(string name)
{
var data = TestMatrices[name];
var result = CreateMatrix(data.RowCount, data.ColumnCount);
data.UpperTriangle(result);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i <= j ? data[i, j] : 0, result[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix into <c>null</c> result matrix throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultNullThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<double> result = null;
Assert.Throws<ArgumentNullException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get an upper triangle into a result matrix with unequal rows throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultWithUnEqualRowsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get an upper triangle into a result matrix with unequal columns throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultWithUnEqualColumnsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get a lower triangle matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanLowerTriangle(string name)
{
var data = TestMatrices[name];
var lower = data.LowerTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i >= j ? data[i, j] : 0, lower[i, j]);
}
}
}
/// <summary>
/// Get a lower triangle matrix into a result matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanLowerTriangleIntoResult(string name)
{
var data = TestMatrices[name];
var result = CreateMatrix(data.RowCount, data.ColumnCount);
data.LowerTriangle(result);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i >= j ? data[i, j] : 0, result[i, j]);
}
}
}
/// <summary>
/// Get a lower triangle matrix into <c>null</c> result matrix throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultNullThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<double> result = null;
Assert.Throws<ArgumentNullException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a lower triangle into a result matrix with unequal rows throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultWithUnEqualRowsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a lower triangle into a result matrix with unequal columns throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultWithUnEqualColumnsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a strictly lower triangle.
/// </summary>
[Test]
public void CanStrictlyLowerTriangle()
{
foreach (var data in TestMatrices.Values)
{
var lower = data.StrictlyLowerTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i > j ? data[i, j] : 0, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly lower triangle into a result matrix.
/// </summary>
[Test]
public void CanStrictlyLowerTriangleIntoResult()
{
foreach (var data in TestMatrices.Values)
{
var lower = CreateMatrix(data.RowCount, data.ColumnCount);
data.StrictlyLowerTriangle(lower);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i > j ? data[i, j] : 0, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly lower triangle with <c>null</c> parameter throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleWithNullParameterThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<double> lower = null;
Assert.Throws<ArgumentNullException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly lower triangle into result with unequal column number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleIntoResultWithUnequalColumnNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly lower triangle into result with unequal row number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleIntoResultWithUnequalRowNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle.
/// </summary>
[Test]
public void CanStrictlyUpperTriangle()
{
foreach (var data in TestMatrices.Values)
{
var lower = data.StrictlyUpperTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i < j ? data[i, j] : 0, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly upper triangle into a result matrix.
/// </summary>
[Test]
public void CanStrictlyUpperTriangleIntoResult()
{
foreach (var data in TestMatrices.Values)
{
var lower = CreateMatrix(data.RowCount, data.ColumnCount);
data.StrictlyUpperTriangle(lower);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i < j ? data[i, j] : 0, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly upper triangle with <c>null</c> parameter throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleWithNullParameterThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<double> lower = null;
Assert.Throws<ArgumentNullException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle into a result matrix with unequal column number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleIntoResultWithUnequalColumnNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle into a result matrix with unequal row number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleIntoResultWithUnequalRowNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Can transpose a matrix.
/// </summary>
@ -405,117 +61,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
}
}
/// <summary>
/// Can set a column with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column array.</param>
[TestCase("Singular3x3", new double[] { 1, 2, 3 })]
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Tall3x2", new double[] { 1, 2, 3 })]
[TestCase("Wide2x3", new double[] { 1, 2 })]
public virtual void CanSetColumnWithArray(string name, double[] column)
{
var matrix = TestMatrices[name];
for (var i = 0; i < matrix.ColumnCount; i++)
{
matrix.SetColumn(i, column);
for (var j = 0; j < matrix.RowCount; j++)
{
Assert.AreEqual(matrix[j, i], column[j]);
}
}
}
/// <summary>
/// Set a column with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithNullArrayThrowsArgumentNullException()
{
double[] vec = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Singular3x3"].SetColumn(1, vec));
}
/// <summary>
/// Set a column with unequal array length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithArrayUnequalLengthThrowsArgumentException()
{
var array = new double[] { 1, 2, 3, 4, 5 };
Assert.Throws<ArgumentException>(() => TestMatrices["Singular3x3"].SetColumn(1, array));
}
/// <summary>
/// Set a column array with invalid column index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetColumnWithArrayWithInvalidColumnIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
double[] column = { 1, 2, 3 };
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(matrix.ColumnCount + 1, column));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(-1, column));
}
/// <summary>
/// Can set a column with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column values.</param>
[TestCase("Singular3x3", new double[] { 1, 2, 3 })]
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Tall3x2", new double[] { 1, 2, 3 })]
[TestCase("Wide2x3", new double[] { 1, 2 })]
public virtual void CanSetColumnWithVector(string name, double[] column)
{
var matrix = TestMatrices[name];
var columnVector = CreateVector(column);
for (var i = 0; i < matrix.ColumnCount; i++)
{
matrix.SetColumn(i, column);
for (var j = 0; j < matrix.RowCount; j++)
{
Assert.AreEqual(matrix[j, i], columnVector[j]);
}
}
}
/// <summary>
/// Set a column with vector with wrong length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithVectorWithUnequalLengthThrowsArgumentException()
{
var matrix = TestMatrices["Singular3x3"];
var columnVector = CreateVector(new double[] { 1, 2, 3, 4, 5 });
Assert.Throws<ArgumentException>(() => matrix.SetColumn(1, columnVector));
}
/// <summary>
/// Set a column with <c>null</c> vector throw <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetColumnWithNullVectorThrowsArgumentNullException()
{
var matrix = TestMatrices["Square3x3"];
Vector<double> columnVector = null;
Assert.Throws<ArgumentNullException>(() => matrix.SetColumn(1, columnVector));
}
/// <summary>
/// Set column vector with invalid column index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetColumnWithVectorWithInvalidColumnIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
var column = CreateVector(new double[] { 1, 2, 3 });
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(-1, column));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(matrix.ColumnCount + 1, column));
}
/// <summary>
/// Can insert a column.
/// </summary>
@ -576,106 +121,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
Assert.Throws<ArgumentException>(() => matrix.InsertColumn(0, column));
}
/// <summary>
/// Can set a row with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
[TestCase("Singular3x3", new double[] { 1, 2, 3 })]
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Tall3x2", new double[] { 1, 2 })]
[TestCase("Wide2x3", new double[] { 1, 2, 3 })]
public virtual void CanSetRowWithArray(string name, double[] row)
{
var matrix = TestMatrices[name];
for (var i = 0; i < matrix.RowCount; i++)
{
matrix.SetRow(i, row);
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], row[j]);
}
}
}
/// <summary>
/// Set a row with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public virtual void SetRowWithNullArrayThrowsArgumentNullException()
{
double[] arr = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetRow(1, arr));
}
/// <summary>
/// Set a row with an array with invalid row index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetRowWithArrayWithInvalidRowIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
double[] row = { 1, 2, 3 };
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(-1, row));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(matrix.RowCount + 1, row));
}
/// <summary>
/// Can set a row with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
[TestCase("Singular3x3", new double[] { 1, 2, 3 })]
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Tall3x2", new double[] { 1, 2 })]
[TestCase("Wide2x3", new double[] { 1, 2, 3 })]
public virtual void CanSetRowWithVector(string name, double[] row)
{
var matrix = TestMatrices[name];
var rowVector = CreateVector(row);
for (var i = 0; i < matrix.RowCount; i++)
{
matrix.SetRow(i, row);
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], rowVector[j]);
}
}
}
/// <summary>
/// Set a row with a vector of unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetRowWithVectorWithUnequalLengthThrowsArgumentException()
{
var vec = CreateVector(new double[] { 1, 2, 3, 4, 5 });
Assert.Throws<ArgumentException>(() => TestMatrices["Square3x3"].SetRow(1, vec));
}
/// <summary>
/// Set a row with a <c>null</c> vector throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetRowWithNullVectorThrowsArgumentNullException()
{
var matrix = TestMatrices["Square3x3"];
Vector<double> rowVector = null;
Assert.Throws<ArgumentNullException>(() => matrix.SetRow(1, rowVector));
}
/// <summary>
/// Set a row with a vector with invalid row index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetRowWithVectorWithInvalidRowIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
var row = CreateVector(new double[] { 1, 2, 3 });
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(-1, row));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(matrix.RowCount + 1, row));
}
/// <summary>
/// Can set a submatrix.
/// </summary>
@ -758,91 +203,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetSubMatrix(0, 2, 0, 2, subMatrix));
}
/// <summary>
/// Can set a diagonal vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="diagonal">Diagonal vector.</param>
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Wide2x3", new double[] { 1, 2 })]
[TestCase("Tall3x2", new double[] { 1, 2 })]
public void CanSetDiagonalVector(string name, double[] diagonal)
{
var matrix = TestMatrices[name];
var vector = CreateVector(diagonal);
matrix.SetDiagonal(vector);
var min = Math.Min(matrix.ColumnCount, matrix.RowCount);
Assert.AreEqual(diagonal.Length, min);
for (var i = 0; i < vector.Count; i++)
{
Assert.AreEqual(vector[i], matrix[i, i]);
}
}
/// <summary>
/// Set a diagonal vector with unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void SetDiagonalVectorWithUnequalLengthThrowsArgumentException()
{
var vector = CreateVector(new double[] { 1, 2, 3 });
Assert.Throws<ArgumentException>(() => TestMatrices["Wide2x3"].SetDiagonal(vector));
}
/// <summary>
/// Set a diagonal with <c>null</c> vector throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetDiagonalWithNullVectorThrowsArgumentNullException()
{
Vector<double> vector = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetDiagonal(vector));
}
/// <summary>
/// Can set a diagonal array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="diagonal">Diagonal array.</param>
[TestCase("Square3x3", new double[] { 1, 2, 3 })]
[TestCase("Wide2x3", new double[] { 1, 2 })]
[TestCase("Tall3x2", new double[] { 1, 2 })]
public void CanSetDiagonalArray(string name, double[] diagonal)
{
var matrix = TestMatrices[name];
matrix.SetDiagonal(diagonal);
var min = Math.Min(matrix.ColumnCount, matrix.RowCount);
Assert.AreEqual(diagonal.Length, min);
for (var i = 0; i < diagonal.Length; i++)
{
Assert.AreEqual(diagonal[i], matrix[i, i]);
}
}
/// <summary>
/// Set a diagonal array with unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void SetDiagonalArrayWithUnequalLengthThrowsArgumentException()
{
var array = new double[] { 1, 2, 3 };
Assert.Throws<ArgumentException>(() => TestMatrices["Wide2x3"].SetDiagonal(array));
}
/// <summary>
/// Set a diagonal with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetDiagonalWithNullArrayThrowsArgumentNullException()
{
double[] array = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetDiagonal(array));
}
/// <summary>
/// Can insert a row.
/// </summary>

404
src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs
View File

@ -11,6 +11,7 @@
protected abstract Matrix<T> CreateDense(int rows, int columns);
protected abstract Matrix<T> CreateSparse(int rows, int columns);
protected abstract Vector<T> CreateVector(int size);
protected abstract T Zero { get; }
[Theory, Timeout(200)]
public void IsEqualToItself(Matrix<T> matrix)
@ -43,9 +44,9 @@
{
Assert.That(matrix, Is.Not.EqualTo(2));
Assert.IsFalse(matrix.Equals(2));
Assert.IsFalse(matrix.Equals((object)2));
Assert.IsFalse(((object)matrix).Equals(2));
Assert.IsFalse(matrix == (object)2);
Assert.IsFalse(matrix.Equals((object) 2));
Assert.IsFalse(((object) matrix).Equals(2));
Assert.IsFalse(matrix == (object) 2);
}
[Theory, Timeout(200)]
@ -116,15 +117,17 @@
[Theory, Timeout(200)]
public void CanGetFieldsByIndex(Matrix<T> matrix)
{
Assert.That(() => { var x = matrix[0, 0]; }, Throws.Nothing);
Assert.That(() => { var x = matrix[0, matrix.ColumnCount - 1]; }, Throws.Nothing);
Assert.That(() => { var x = matrix[matrix.RowCount - 1, 0]; }, Throws.Nothing);
Assert.That(() => matrix[0, 0], Throws.Nothing);
Assert.That(() => matrix[0, matrix.ColumnCount - 1], Throws.Nothing);
Assert.That(() => matrix[matrix.RowCount - 1, 0], Throws.Nothing);
Assert.That(() => { var x = matrix[-1, 1]; }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { var x = matrix[1, -1]; }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { var x = matrix[0, matrix.ColumnCount]; }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix[-1, 1], Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix[1, -1], Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix[0, matrix.ColumnCount], Throws.InstanceOf<ArgumentOutOfRangeException>());
}
#region Row & Column Access
[Theory, Timeout(200)]
public void CanGetRow(Matrix<T> matrix)
{
@ -145,8 +148,8 @@
}
// Invalid Rows
Assert.That(() => { matrix.Row(-1); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Row(matrix.RowCount); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Row(-1), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Row(matrix.RowCount), Throws.InstanceOf<ArgumentOutOfRangeException>());
}
[Theory, Timeout(200)]
@ -193,11 +196,11 @@
}
// Invalid Rows
Assert.That(() => { matrix.Row(-1, 0, 2); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Row(matrix.RowCount, 0, 1); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Row(0, -1, 1); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Row(0, 1, 0); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Row(0, 0, matrix.ColumnCount + 1); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Row(-1, 0, 2), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Row(matrix.RowCount, 0, 1), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Row(0, -1, 1), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Row(0, 1, 0), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Row(0, 0, matrix.ColumnCount + 1), Throws.InstanceOf<ArgumentOutOfRangeException>());
}
[Theory, Timeout(200)]
@ -237,8 +240,8 @@
}
// Invalid Columns
Assert.That(() => { matrix.Column(-1); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Column(matrix.ColumnCount); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Column(-1), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Column(matrix.ColumnCount), Throws.InstanceOf<ArgumentOutOfRangeException>());
}
[Theory, Timeout(200)]
@ -285,11 +288,11 @@
}
// Invalid Rows
Assert.That(() => { matrix.Column(-1, 0, 2); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Column(matrix.ColumnCount, 0, 1); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Column(0, -1, 1); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Column(0, 1, 0); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => { matrix.Column(0, 0, matrix.RowCount + 1); }, Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Column(-1, 0, 2), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Column(matrix.ColumnCount, 0, 1), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Column(0, -1, 1), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Column(0, 1, 0), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Column(0, 0, matrix.RowCount + 1), Throws.InstanceOf<ArgumentOutOfRangeException>());
}
[Theory, Timeout(200)]
@ -308,5 +311,360 @@
Assert.That(() => matrix.Column(matrix.ColumnCount, 0, matrix.ColumnCount - 1, col), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.Column(0, 0, matrix.RowCount, col), Throws.InstanceOf<ArgumentOutOfRangeException>());
}
[Theory, Timeout(200)]
public void CanSetRow(Matrix<T> matrix)
{
// First Row
var m = matrix.Clone();
m.SetRow(0, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(i == 0 ? Zero : matrix[i, j]));
}
}
// Last Row
m = matrix.Clone();
m.SetRow(matrix.RowCount - 1, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(i == matrix.RowCount - 1 ? Zero : matrix[i, j]));
}
}
// Invalid Rows
Assert.That(() => matrix.SetRow(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.SetRow(-1, CreateVector(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(matrix.RowCount, CreateVector(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(0, CreateVector(matrix.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetRow(0, CreateVector(matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
public void CanSetRowArray(Matrix<T> matrix)
{
// First Row
var m = matrix.Clone();
m.SetRow(0, CreateVector(matrix.ColumnCount).ToArray());
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(i == 0 ? Zero : matrix[i, j]));
}
}
// Last Row
m = matrix.Clone();
m.SetRow(matrix.RowCount - 1, new T[matrix.ColumnCount]);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(i == matrix.RowCount - 1 ? Zero : matrix[i, j]));
}
}
// Invalid Rows
Assert.That(() => matrix.SetRow(0, default(T[])), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.SetRow(-1, new T[matrix.ColumnCount]), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(matrix.RowCount, new T[matrix.ColumnCount]), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(0, new T[matrix.ColumnCount - 1]), Throws.ArgumentException);
Assert.That(() => matrix.SetRow(0, new T[matrix.ColumnCount + 1]), Throws.ArgumentException);
}
[Theory, Timeout(200)]
public void CanSetColumn(Matrix<T> matrix)
{
// First Column
var m = matrix.Clone();
m.SetColumn(0, CreateVector(matrix.RowCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(j == 0 ? Zero : matrix[i, j]));
}
}
// Last Column
m = matrix.Clone();
m.SetColumn(matrix.ColumnCount - 1, CreateVector(matrix.RowCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(j == matrix.ColumnCount - 1 ? Zero : matrix[i, j]));
}
}
// Invalid Rows
Assert.That(() => matrix.SetColumn(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.SetColumn(-1, CreateVector(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(matrix.ColumnCount, CreateVector(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(0, CreateVector(matrix.RowCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetColumn(0, CreateVector(matrix.RowCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
public void CanSetColumnArray(Matrix<T> matrix)
{
// First Column
var m = matrix.Clone();
m.SetColumn(0, CreateVector(matrix.RowCount).ToArray());
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(j == 0 ? Zero : matrix[i, j]));
}
}
// Last Column
m = matrix.Clone();
m.SetColumn(matrix.ColumnCount - 1, new T[matrix.RowCount]);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(j == matrix.ColumnCount - 1 ? Zero : matrix[i, j]));
}
}
// Invalid Rows
Assert.That(() => matrix.SetColumn(0, default(T[])), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.SetColumn(-1, new T[matrix.RowCount]), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(matrix.ColumnCount, new T[matrix.RowCount]), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(0, new T[matrix.RowCount - 1]), Throws.ArgumentException);
Assert.That(() => matrix.SetColumn(0, new T[matrix.RowCount + 1]), Throws.ArgumentException);
}
#endregion
#region Triangle Access
[Theory, Timeout(200)]
public void CanGetUpperTriangle(Matrix<T> matrix)
{
var upper = matrix.UpperTriangle();
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(upper[i, j], Is.EqualTo(i <= j ? matrix[i, j] : Zero));
}
}
}
[Theory, Timeout(200)]
public void CanGetUpperTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
matrix.UpperTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(dense[i, j], Is.EqualTo(i <= j ? matrix[i, j] : Zero));
}
}
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
matrix.UpperTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(sparse[i, j], Is.EqualTo(i <= j ? matrix[i, j] : Zero));
}
}
Assert.That(() => matrix.UpperTriangle(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.UpperTriangle(CreateSparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.UpperTriangle(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
public void CanGetLowerTriangle(Matrix<T> matrix)
{
var upper = matrix.LowerTriangle();
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(upper[i, j], Is.EqualTo(i >= j ? matrix[i, j] : Zero));
}
}
}
[Theory, Timeout(200)]
public void CanGetLowerTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
matrix.LowerTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(dense[i, j], Is.EqualTo(i >= j ? matrix[i, j] : Zero));
}
}
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
matrix.LowerTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(sparse[i, j], Is.EqualTo(i >= j ? matrix[i, j] : Zero));
}
}
Assert.That(() => matrix.LowerTriangle(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.LowerTriangle(CreateSparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.LowerTriangle(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
public void CanGetStrictlyUpperTriangle(Matrix<T> matrix)
{
var upper = matrix.StrictlyUpperTriangle();
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(upper[i, j], Is.EqualTo(i < j ? matrix[i, j] : Zero));
}
}
}
[Theory, Timeout(200)]
public void CanGetStrictlyUpperTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyUpperTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(dense[i, j], Is.EqualTo(i < j ? matrix[i, j] : Zero));
}
}
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyUpperTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(sparse[i, j], Is.EqualTo(i < j ? matrix[i, j] : Zero));
}
}
Assert.That(() => matrix.StrictlyUpperTriangle(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.StrictlyUpperTriangle(CreateSparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyUpperTriangle(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
public void CanGetStrictlyLowerTriangle(Matrix<T> matrix)
{
var upper = matrix.StrictlyLowerTriangle();
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(upper[i, j], Is.EqualTo(i > j ? matrix[i, j] : Zero));
}
}
}
[Theory, Timeout(200)]
public void CanGetStrictlyLowerTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyLowerTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(dense[i, j], Is.EqualTo(i > j ? matrix[i, j] : Zero));
}
}
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyLowerTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(sparse[i, j], Is.EqualTo(i > j ? matrix[i, j] : Zero));
}
}
Assert.That(() => matrix.StrictlyLowerTriangle(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.StrictlyLowerTriangle(CreateSparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyLowerTriangle(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
#endregion
#region Diagonal Access
[Theory, Timeout(200)]
public void CanGetDiagonal(Matrix<T> matrix)
{
var diag = matrix.Diagonal();
Assert.That(diag.Count, Is.EqualTo(Math.Min(matrix.RowCount, matrix.ColumnCount)));
for (var i = 0; i < Math.Min(matrix.RowCount, matrix.ColumnCount); i++)
{
Assert.That(diag[i], Is.EqualTo(matrix[i, i]));
}
}
[Theory, Timeout(200)]
public void CanSetDiagonal(Matrix<T> matrix)
{
var m = matrix.Clone();
m.SetDiagonal(CreateVector(Math.Min(matrix.RowCount, matrix.ColumnCount)));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(i == j ? Zero : matrix[i, j]));
}
}
// Invalid
Assert.That(() => matrix.SetDiagonal(default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.SetDiagonal(CreateVector(Math.Min(matrix.RowCount, matrix.ColumnCount) - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetDiagonal(CreateVector(Math.Min(matrix.RowCount, matrix.ColumnCount) + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
public void CanSetDiagonalArray(Matrix<T> matrix)
{
var m = matrix.Clone();
m.SetDiagonal(new T[Math.Min(matrix.RowCount, matrix.ColumnCount)]);
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.That(m[i, j], Is.EqualTo(i == j ? Zero : matrix[i, j]));
}
}
// Invalid
Assert.That(() => matrix.SetDiagonal(default(T[])), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.SetDiagonal(new T[Math.Min(matrix.RowCount, matrix.ColumnCount) - 1]), Throws.ArgumentException);
Assert.That(() => matrix.SetDiagonal(new T[Math.Min(matrix.RowCount, matrix.ColumnCount) + 1]), Throws.ArgumentException);
}
#endregion
}
}

88
src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs
View File

@ -319,94 +319,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
}
}
/// <summary>
/// Can set a column with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column array.</param>
public override void CanSetColumnWithArray(string name, float[] column)
{
try
{
// Pass all invoke to base
base.CanSetColumnWithArray(name, column);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a column with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column values.</param>
public override void CanSetColumnWithVector(string name, float[] column)
{
try
{
// Pass all invoke to base
base.CanSetColumnWithVector(name, column);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a row with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
public override void CanSetRowWithArray(string name, float[] row)
{
try
{
// Pass all invoke to base
base.CanSetRowWithArray(name, row);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a row with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
public override void CanSetRowWithVector(string name, float[] row)
{
try
{
// Pass all invoke to base
base.CanSetRowWithVector(name, row);
}
catch (AggregateException ex)
{
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException)))
{
throw;
}
}
}
/// <summary>
/// Can set a submatrix.
/// </summary>

5
src/UnitTests/LinearAlgebraTests/Single/MatrixStructureTheory.cs
View File

@ -45,5 +45,10 @@
{
return new DenseVector(size);
}
protected override float Zero
{
get { return 0f; }
}
}
}

640
src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs
View File

@ -35,350 +35,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
/// </summary>
public abstract partial class MatrixTests : MatrixLoader
{
/// <summary>
/// Can set a row.
/// </summary>
/// <param name="rowIndex">Row index.</param>
/// <param name="name">Matrix name.</param>
[TestCase(0, "Singular3x3")]
[TestCase(1, "Square3x3")]
[TestCase(2, "Square3x3")]
public void CanSetRow(int rowIndex, string name)
{
var matrix = TestMatrices[name].Clone();
matrix.SetRow(rowIndex, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(i == rowIndex ? 0.0f : TestMatrices[name][i, j], matrix[i, j]);
}
}
}
/// <summary>
/// Can set a column.
/// </summary>
/// <param name="colIndex">Column index.</param>
/// <param name="name">Matrix name.</param>
[TestCase(0, "Singular3x3")]
[TestCase(1, "Square3x3")]
[TestCase(2, "Square3x3")]
public void CanSetColumn(int colIndex, string name)
{
var matrix = TestMatrices[name].Clone();
matrix.SetColumn(colIndex, CreateVector(matrix.ColumnCount));
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(j == colIndex ? 0.0f : TestMatrices[name][i, j], matrix[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanUpperTriangle(string name)
{
var data = TestMatrices[name];
var upper = data.UpperTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i <= j ? data[i, j] : 0, upper[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix into a result matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanUpperTriangleIntoResult(string name)
{
var data = TestMatrices[name];
var result = CreateMatrix(data.RowCount, data.ColumnCount);
data.UpperTriangle(result);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i <= j ? data[i, j] : 0, result[i, j]);
}
}
}
/// <summary>
/// Get an upper triangle matrix into <c>null</c> result matrix throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultNullThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<float> result = null;
Assert.Throws<ArgumentNullException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get an upper triangle into a result matrix with unequal rows throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultWithUnEqualRowsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get an upper triangle into a result matrix with unequal columns throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void UpperTriangleIntoResultWithUnEqualColumnsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.UpperTriangle(result));
}
/// <summary>
/// Get a lower triangle matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanLowerTriangle(string name)
{
var data = TestMatrices[name];
var lower = data.LowerTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i >= j ? data[i, j] : 0, lower[i, j]);
}
}
}
/// <summary>
/// Get a lower triangle matrix into a result matrix.
/// </summary>
/// <param name="name">Matrix name.</param>
[TestCase("Singular3x3")]
[TestCase("Square3x3")]
[TestCase("Square4x4")]
[TestCase("Tall3x2")]
[TestCase("Wide2x3")]
public void CanLowerTriangleIntoResult(string name)
{
var data = TestMatrices[name];
var result = CreateMatrix(data.RowCount, data.ColumnCount);
data.LowerTriangle(result);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i >= j ? data[i, j] : 0, result[i, j]);
}
}
}
/// <summary>
/// Get a lower triangle matrix into <c>null</c> result matrix throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultNullThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<float> result = null;
Assert.Throws<ArgumentNullException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a lower triangle into a result matrix with unequal rows throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultWithUnEqualRowsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a lower triangle into a result matrix with unequal columns throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void LowerTriangleIntoResultWithUnEqualColumnsThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var result = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.LowerTriangle(result));
}
/// <summary>
/// Get a strictly lower triangle.
/// </summary>
[Test]
public void CanStrictlyLowerTriangle()
{
foreach (var data in TestMatrices.Values)
{
var lower = data.StrictlyLowerTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i > j ? data[i, j] : 0, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly lower triangle into a result matrix.
/// </summary>
[Test]
public void CanStrictlyLowerTriangleIntoResult()
{
foreach (var data in TestMatrices.Values)
{
var lower = CreateMatrix(data.RowCount, data.ColumnCount);
data.StrictlyLowerTriangle(lower);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i > j ? data[i, j] : 0, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly lower triangle with <c>null</c> parameter throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleWithNullParameterThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<float> lower = null;
Assert.Throws<ArgumentNullException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly lower triangle into result with unequal column number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleIntoResultWithUnequalColumnNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly lower triangle into result with unequal row number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyLowerTriangleIntoResultWithUnequalRowNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.StrictlyLowerTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle.
/// </summary>
[Test]
public void CanStrictlyUpperTriangle()
{
foreach (var data in TestMatrices.Values)
{
var lower = data.StrictlyUpperTriangle();
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i < j ? data[i, j] : 0, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly upper triangle into a result matrix.
/// </summary>
[Test]
public void CanStrictlyUpperTriangleIntoResult()
{
foreach (var data in TestMatrices.Values)
{
var lower = CreateMatrix(data.RowCount, data.ColumnCount);
data.StrictlyUpperTriangle(lower);
for (var i = 0; i < data.RowCount; i++)
{
for (var j = 0; j < data.ColumnCount; j++)
{
Assert.AreEqual(i < j ? data[i, j] : 0, lower[i, j]);
}
}
}
}
/// <summary>
/// Get a strictly upper triangle with <c>null</c> parameter throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleWithNullParameterThrowsArgumentNullException()
{
var data = TestMatrices["Square3x3"];
Matrix<float> lower = null;
Assert.Throws<ArgumentNullException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle into a result matrix with unequal column number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleIntoResultWithUnequalColumnNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount, data.ColumnCount + 1);
Assert.Throws<ArgumentException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Get a strictly upper triangle into a result matrix with unequal row number throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void StrictlyUpperTriangleIntoResultWithUnequalRowNumberThrowsArgumentException()
{
var data = TestMatrices["Square3x3"];
var lower = CreateMatrix(data.RowCount + 1, data.ColumnCount);
Assert.Throws<ArgumentException>(() => data.StrictlyUpperTriangle(lower));
}
/// <summary>
/// Can transpose a matrix.
/// </summary>
@ -405,117 +61,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
}
}
/// <summary>
/// Can set a column with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column array.</param>
[TestCase("Singular3x3", new float[] { 1, 2, 3 })]
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Tall3x2", new float[] { 1, 2, 3 })]
[TestCase("Wide2x3", new float[] { 1, 2 })]
public virtual void CanSetColumnWithArray(string name, float[] column)
{
var matrix = TestMatrices[name];
for (var i = 0; i < matrix.ColumnCount; i++)
{
matrix.SetColumn(i, column);
for (var j = 0; j < matrix.RowCount; j++)
{
Assert.AreEqual(matrix[j, i], column[j]);
}
}
}
/// <summary>
/// Set a column with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithNullArrayThrowsArgumentNullException()
{
float[] vec = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Singular3x3"].SetColumn(1, vec));
}
/// <summary>
/// Set a column with unequal array length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithArrayUnequalLengthThrowsArgumentException()
{
var array = new float[] { 1, 2, 3, 4, 5 };
Assert.Throws<ArgumentException>(() => TestMatrices["Singular3x3"].SetColumn(1, array));
}
/// <summary>
/// Set a column array with invalid column index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetColumnWithArrayWithInvalidColumnIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
float[] column = { 1, 2, 3 };
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(matrix.ColumnCount + 1, column));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(-1, column));
}
/// <summary>
/// Can set a column with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="column">Column values.</param>
[TestCase("Singular3x3", new float[] { 1, 2, 3 })]
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Tall3x2", new float[] { 1, 2, 3 })]
[TestCase("Wide2x3", new float[] { 1, 2 })]
public virtual void CanSetColumnWithVector(string name, float[] column)
{
var matrix = TestMatrices[name];
var columnVector = CreateVector(column);
for (var i = 0; i < matrix.ColumnCount; i++)
{
matrix.SetColumn(i, column);
for (var j = 0; j < matrix.RowCount; j++)
{
Assert.AreEqual(matrix[j, i], columnVector[j]);
}
}
}
/// <summary>
/// Set a column with vector with wrong length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetColumnWithVectorWithUnequalLengthThrowsArgumentException()
{
var matrix = TestMatrices["Singular3x3"];
var columnVector = CreateVector(new float[] { 1, 2, 3, 4, 5 });
Assert.Throws<ArgumentException>(() => matrix.SetColumn(1, columnVector));
}
/// <summary>
/// Set a column with <c>null</c> vector throw <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetColumnWithNullVectorThrowsArgumentNullException()
{
var matrix = TestMatrices["Square3x3"];
Vector<float> columnVector = null;
Assert.Throws<ArgumentNullException>(() => matrix.SetColumn(1, columnVector));
}
/// <summary>
/// Set column vector with invalid column index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetColumnWithVectorWithInvalidColumnIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
var column = CreateVector(new float[] { 1, 2, 3 });
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(-1, column));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetColumn(matrix.ColumnCount + 1, column));
}
/// <summary>
/// Can insert a column.
/// </summary>
@ -576,106 +121,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
Assert.Throws<ArgumentException>(() => matrix.InsertColumn(0, column));
}
/// <summary>
/// Can set a row with an array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
[TestCase("Singular3x3", new float[] { 1, 2, 3 })]
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Tall3x2", new float[] { 1, 2 })]
[TestCase("Wide2x3", new float[] { 1, 2, 3 })]
public virtual void CanSetRowWithArray(string name, float[] row)
{
var matrix = TestMatrices[name];
for (var i = 0; i < matrix.RowCount; i++)
{
matrix.SetRow(i, row);
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], row[j]);
}
}
}
/// <summary>
/// Set a row with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public virtual void SetRowWithNullArrayThrowsArgumentNullException()
{
float[] arr = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetRow(1, arr));
}
/// <summary>
/// Set a row with an array with invalid row index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetRowWithArrayWithInvalidRowIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
float[] row = { 1, 2, 3 };
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(-1, row));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(matrix.RowCount + 1, row));
}
/// <summary>
/// Can set a row with a vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="row">Row index.</param>
[TestCase("Singular3x3", new float[] { 1, 2, 3 })]
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Tall3x2", new float[] { 1, 2 })]
[TestCase("Wide2x3", new float[] { 1, 2, 3 })]
public virtual void CanSetRowWithVector(string name, float[] row)
{
var matrix = TestMatrices[name];
var rowVector = CreateVector(row);
for (var i = 0; i < matrix.RowCount; i++)
{
matrix.SetRow(i, row);
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], rowVector[j]);
}
}
}
/// <summary>
/// Set a row with a vector of unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public virtual void SetRowWithVectorWithUnequalLengthThrowsArgumentException()
{
var vec = CreateVector(new float[] { 1, 2, 3, 4, 5 });
Assert.Throws<ArgumentException>(() => TestMatrices["Square3x3"].SetRow(1, vec));
}
/// <summary>
/// Set a row with a <c>null</c> vector throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetRowWithNullVectorThrowsArgumentNullException()
{
var matrix = TestMatrices["Square3x3"];
Vector<float> rowVector = null;
Assert.Throws<ArgumentNullException>(() => matrix.SetRow(1, rowVector));
}
/// <summary>
/// Set a row with a vector with invalid row index throws <c>ArgumentOutOfRangeException</c>.
/// </summary>
[Test]
public void SetRowWithVectorWithInvalidRowIndexThrowsArgumentOutOfRangeException()
{
var matrix = TestMatrices["Square3x3"];
var row = CreateVector(new float[] { 1, 2, 3 });
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(-1, row));
Assert.Throws<ArgumentOutOfRangeException>(() => matrix.SetRow(matrix.RowCount + 1, row));
}
/// <summary>
/// Can set a submatrix.
/// </summary>
@ -758,91 +203,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetSubMatrix(0, 2, 0, 2, subMatrix));
}
/// <summary>
/// Can set a diagonal vector.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="diagonal">Diagonal vector.</param>
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Wide2x3", new float[] { 1, 2 })]
[TestCase("Tall3x2", new float[] { 1, 2 })]
public void CanSetDiagonalVector(string name, float[] diagonal)
{
var matrix = TestMatrices[name];
var vector = CreateVector(diagonal);
matrix.SetDiagonal(vector);
var min = Math.Min(matrix.ColumnCount, matrix.RowCount);
Assert.AreEqual(diagonal.Length, min);
for (var i = 0; i < vector.Count; i++)
{
Assert.AreEqual(vector[i], matrix[i, i]);
}
}
/// <summary>
/// Set a diagonal vector with unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void SetDiagonalVectorWithUnequalLengthThrowsArgumentException()
{
var vector = CreateVector(new float[] { 1, 2, 3 });
Assert.Throws<ArgumentException>(() => TestMatrices["Wide2x3"].SetDiagonal(vector));
}
/// <summary>
/// Set a diagonal with <c>null</c> vector throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetDiagonalWithNullVectorThrowsArgumentNullException()
{
Vector<float> vector = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetDiagonal(vector));
}
/// <summary>
/// Can set a diagonal array.
/// </summary>
/// <param name="name">Matrix name.</param>
/// <param name="diagonal">Diagonal array.</param>
[TestCase("Square3x3", new float[] { 1, 2, 3 })]
[TestCase("Wide2x3", new float[] { 1, 2 })]
[TestCase("Tall3x2", new float[] { 1, 2 })]
public void CanSetDiagonalArray(string name, float[] diagonal)
{
var matrix = TestMatrices[name];
matrix.SetDiagonal(diagonal);
var min = Math.Min(matrix.ColumnCount, matrix.RowCount);
Assert.AreEqual(diagonal.Length, min);
for (var i = 0; i < diagonal.Length; i++)
{
Assert.AreEqual(diagonal[i], matrix[i, i]);
}
}
/// <summary>
/// Set a diagonal array with unequal length throws <c>ArgumentException</c>.
/// </summary>
[Test]
public void SetDiagonalArrayWithUnequalLengthThrowsArgumentException()
{
var array = new float[] { 1, 2, 3 };
Assert.Throws<ArgumentException>(() => TestMatrices["Wide2x3"].SetDiagonal(array));
}
/// <summary>
/// Set a diagonal with <c>null</c> array throws <c>ArgumentNullException</c>.
/// </summary>
[Test]
public void SetDiagonalWithNullArrayThrowsArgumentNullException()
{
float[] array = null;
Assert.Throws<ArgumentNullException>(() => TestMatrices["Square3x3"].SetDiagonal(array));
}
/// <summary>
/// Can insert a row.
/// </summary>

Write Preview
Loading…
Cancel
Save