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

Tests: matrix structural tests more thorough if mutable

la-knuth
Christoph Ruegg 14 years ago
parent
aa5716fdb6
commit
b23284e2ee
7 changed files with 133 additions and 114 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. 10
      src/UnitTests/LinearAlgebraTests/Complex/MatrixStructureTheory.cs
  2. 10
      src/UnitTests/LinearAlgebraTests/Complex32/MatrixStructureTheory.cs
  3. 10
      src/UnitTests/LinearAlgebraTests/Double/MatrixStructureTheory.cs
  4. 109
      src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Access.cs
  5. 50
      src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs
  6. 48
      src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs
  7. 10
      src/UnitTests/LinearAlgebraTests/Single/MatrixStructureTheory.cs

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

@ -36,28 +36,28 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
[Datapoints]
Complex[] scalars = new[] {new Complex(2d, 0d), new Complex(-1.5d, 3.5d), Complex.Zero};
protected override Matrix<Complex> CreateDense(int rows, int columns)
protected override Matrix<Complex> CreateDenseZero(int rows, int columns)
{
return new DenseMatrix(rows, columns);
}
protected override Matrix<Complex> CreateDense(int rows, int columns, int seed)
protected override Matrix<Complex> CreateDenseRandom(int rows, int columns, int seed)
{
var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseMatrix(rows, columns, Enumerable.Range(0, rows*columns).Select(k => new Complex(dist.Sample(), dist.Sample())).ToArray());
}
protected override Matrix<Complex> CreateSparse(int rows, int columns)
protected override Matrix<Complex> CreateSparseZero(int rows, int columns)
{
return new SparseMatrix(rows, columns);
}
protected override Vector<Complex> CreateVector(int size)
protected override Vector<Complex> CreateVectorZero(int size)
{
return new DenseVector(size);
}
protected override Vector<Complex> CreateVector(int size, int seed)
protected override Vector<Complex> CreateVectorRandom(int size, int seed)
{
var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseVector(Enumerable.Range(0, size).Select(k => new Complex(dist.Sample(), dist.Sample())).ToArray());

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

@ -36,28 +36,28 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
[Datapoints]
Complex32[] scalars = new[] {new Complex32(2f, 0f), new Complex32(-1.5f, 3.5f), Complex32.Zero};
protected override Matrix<Complex32> CreateDense(int rows, int columns)
protected override Matrix<Complex32> CreateDenseZero(int rows, int columns)
{
return new DenseMatrix(rows, columns);
}
protected override Matrix<Complex32> CreateDense(int rows, int columns, int seed)
protected override Matrix<Complex32> CreateDenseRandom(int rows, int columns, int seed)
{
var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseMatrix(rows, columns, Enumerable.Range(0, rows*columns).Select(k => new Complex32((float) dist.Sample(), (float) dist.Sample())).ToArray());
}
protected override Matrix<Complex32> CreateSparse(int rows, int columns)
protected override Matrix<Complex32> CreateSparseZero(int rows, int columns)
{
return new SparseMatrix(rows, columns);
}
protected override Vector<Complex32> CreateVector(int size)
protected override Vector<Complex32> CreateVectorZero(int size)
{
return new DenseVector(size);
}
protected override Vector<Complex32> CreateVector(int size, int seed)
protected override Vector<Complex32> CreateVectorRandom(int size, int seed)
{
var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseVector(Enumerable.Range(0, size).Select(k => new Complex32((float) dist.Sample(), (float) dist.Sample())).ToArray());

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

@ -35,28 +35,28 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
[Datapoints]
double[] _scalars = new[] {2d, -1.5d, 0d};
protected override Matrix<double> CreateDense(int rows, int columns)
protected override Matrix<double> CreateDenseZero(int rows, int columns)
{
return new DenseMatrix(rows, columns);
}
protected override Matrix<double> CreateDense(int rows, int columns, int seed)
protected override Matrix<double> CreateDenseRandom(int rows, int columns, int seed)
{
var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseMatrix(rows, columns, dist.Samples().Take(rows*columns).ToArray());
}
protected override Matrix<double> CreateSparse(int rows, int columns)
protected override Matrix<double> CreateSparseZero(int rows, int columns)
{
return new SparseMatrix(rows, columns);
}
protected override Vector<double> CreateVector(int size)
protected override Vector<double> CreateVectorZero(int size)
{
return new DenseVector(size);
}
protected override Vector<double> CreateVector(int size, int seed)
protected override Vector<double> CreateVectorRandom(int size, int seed)
{
var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseVector(dist.Samples().Take(size).ToArray());

109
src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Access.cs
View File

@ -45,7 +45,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanGetRowIntoResult(Matrix<T> matrix)
{
var row = CreateVector(matrix.ColumnCount);
var row = CreateVectorZero(matrix.ColumnCount);
matrix.Row(0, row);
for (var j = 0; j < matrix.ColumnCount; j++)
@ -96,7 +96,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanGetRowWithRangeIntoResult(Matrix<T> matrix)
{
var row = CreateVector(matrix.ColumnCount - 1);
var row = CreateVectorZero(matrix.ColumnCount - 1);
matrix.Row(0, 1, matrix.ColumnCount - 1, row);
for (var j = 0; j < matrix.ColumnCount - 1; j++)
@ -137,7 +137,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanGetColumnIntoResult(Matrix<T> matrix)
{
var col = CreateVector(matrix.RowCount);
var col = CreateVectorZero(matrix.RowCount);
matrix.Column(0, col);
for (var i = 0; i < matrix.RowCount; i++)
@ -188,7 +188,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanGetColumnWithRangeIntoResult(Matrix<T> matrix)
{
var col = CreateVector(matrix.RowCount - 1);
var col = CreateVectorZero(matrix.RowCount - 1);
matrix.Column(0, 1, matrix.RowCount - 1, col);
for (var i = 0; i < matrix.RowCount - 1; i++)
@ -207,32 +207,34 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
// First Row
var m = matrix.Clone();
m.SetRow(0, CreateVector(matrix.ColumnCount));
var v = CreateVectorFor(m, matrix.ColumnCount);
m.SetRow(0, v);
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]));
Assert.That(m[i, j], Is.EqualTo(i == 0 ? v[j] : matrix[i, j]));
}
}
// Last Row
m = matrix.Clone();
m.SetRow(matrix.RowCount - 1, CreateVector(matrix.ColumnCount));
v = CreateVectorFor(m, matrix.ColumnCount);
m.SetRow(matrix.RowCount - 1, v);
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]));
Assert.That(m[i, j], Is.EqualTo(i == matrix.RowCount - 1 ? v[j] : 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);
Assert.That(() => matrix.SetRow(-1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(matrix.RowCount, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(0, CreateVectorZero(matrix.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetRow(0, CreateVectorZero(matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -240,7 +242,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
// First Row
var m = matrix.Clone();
m.SetRow(0, CreateVector(matrix.ColumnCount).ToArray());
m.SetRow(0, CreateVectorZero(matrix.ColumnCount).ToArray());
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
@ -273,32 +275,34 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
// First Column
var m = matrix.Clone();
m.SetColumn(0, CreateVector(matrix.RowCount));
var v = CreateVectorFor(m, matrix.RowCount);
m.SetColumn(0, v);
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]));
Assert.That(m[i, j], Is.EqualTo(j == 0 ? v[i] : matrix[i, j]));
}
}
// Last Column
m = matrix.Clone();
m.SetColumn(matrix.ColumnCount - 1, CreateVector(matrix.RowCount));
v = CreateVectorFor(m, matrix.RowCount);
m.SetColumn(matrix.ColumnCount - 1, v);
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]));
Assert.That(m[i, j], Is.EqualTo(j == matrix.ColumnCount - 1 ? v[i] : 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);
Assert.That(() => matrix.SetColumn(-1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(matrix.ColumnCount, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(0, CreateVectorZero(matrix.RowCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetColumn(0, CreateVectorZero(matrix.RowCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -306,7 +310,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
// First Column
var m = matrix.Clone();
m.SetColumn(0, CreateVector(matrix.RowCount).ToArray());
m.SetColumn(0, CreateVectorZero(matrix.RowCount).ToArray());
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
@ -350,7 +354,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanGetUpperTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.UpperTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -360,7 +364,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
}
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
matrix.UpperTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -371,8 +375,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
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);
Assert.That(() => matrix.UpperTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.UpperTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -391,7 +395,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanGetLowerTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.LowerTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -401,7 +405,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
}
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
matrix.LowerTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -412,8 +416,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
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);
Assert.That(() => matrix.LowerTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.LowerTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -432,7 +436,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanGetStrictlyUpperTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyUpperTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -442,7 +446,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
}
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyUpperTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -453,8 +457,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
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);
Assert.That(() => matrix.StrictlyUpperTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyUpperTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -473,7 +477,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanGetStrictlyLowerTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyLowerTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -483,7 +487,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
}
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyLowerTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -494,8 +498,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
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);
Assert.That(() => matrix.StrictlyLowerTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyLowerTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -513,19 +517,20 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public void CanSetDiagonal(Matrix<T> matrix)
{
var m = matrix.Clone();
m.SetDiagonal(CreateVector(Math.Min(matrix.RowCount, matrix.ColumnCount)));
var v = CreateVectorFor(m, Math.Min(matrix.RowCount, matrix.ColumnCount));
m.SetDiagonal(v);
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]));
Assert.That(m[i, j], Is.EqualTo(i == j ? v[i] : 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);
Assert.That(() => matrix.SetDiagonal(CreateVectorZero(Math.Min(matrix.RowCount, matrix.ColumnCount) - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetDiagonal(CreateVectorZero(Math.Min(matrix.RowCount, matrix.ColumnCount) + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -593,7 +598,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public void CanSetSubmatrix(Matrix<T> matrix)
{
// Top Left Corner 2x2
var topleft = CreateDense(2, 2);
var topleft = CreateDenseFor(matrix, 2, 2);
var m = matrix.Clone();
m.SetSubMatrix(0, 2, 0, 2, topleft);
for (var i = 0; i < m.RowCount; i++)
@ -605,7 +610,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
// Bottom Right Cornet 1x2
var bottomright = CreateDense(1, 2);
var bottomright = CreateDenseFor(matrix, 1, 2);
m = matrix.Clone();
m.SetSubMatrix(matrix.RowCount - 1, 1, matrix.ColumnCount - 2, 2, bottomright);
for (var i = 0; i < m.RowCount; i++)
@ -619,16 +624,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
m = matrix.Clone();
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => m.SetSubMatrix(-1, 1, 0, 1, CreateDense(1,1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(matrix.RowCount, 1, 0, 1, CreateDense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 0, 0, 1, CreateDense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, -1, 1, CreateDense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, matrix.ColumnCount, 1, CreateDense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, 0, 0, CreateDense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(-1, 1, 0, 1, CreateDenseZero(1,1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(matrix.RowCount, 1, 0, 1, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 0, 0, 1, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, -1, 1, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, matrix.ColumnCount, 1, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, 0, 0, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
// Usually invalid, but not for SetSubMatrix (since size is explicitly provided)
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, CreateDense(1, 2)), Throws.Nothing);
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, CreateDense(2, 1)), Throws.Nothing);
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, CreateDenseZero(1, 2)), Throws.Nothing);
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, CreateDenseZero(2, 1)), Throws.Nothing);
}
}
}

50
src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs
View File

@ -68,7 +68,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanInsertRow(Matrix<T> matrix)
{
var row = CreateVector(matrix.ColumnCount, 0);
var row = CreateVectorRandom(matrix.ColumnCount, 0);
for (var position = 0; position < matrix.RowCount + 1; position++)
{
var result = matrix.InsertRow(position, row);
@ -95,16 +95,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => matrix.InsertRow(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.InsertRow(-1, CreateVector(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, CreateVector(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertRow(0, CreateVector(matrix.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertRow(0, CreateVector(matrix.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertRow(-1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertRow(0, CreateVectorZero(matrix.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertRow(0, CreateVectorZero(matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
public void CanInsertColumn(Matrix<T> matrix)
{
var column = CreateVector(matrix.RowCount, 0);
var column = CreateVectorRandom(matrix.RowCount, 0);
for (var position = 0; position < matrix.ColumnCount + 1; position++)
{
var result = matrix.InsertColumn(position, column);
@ -131,10 +131,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => matrix.InsertColumn(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.InsertColumn(-1, CreateVector(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, CreateVector(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertColumn(0, CreateVector(matrix.RowCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertColumn(0, CreateVector(matrix.RowCount + 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertColumn(-1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertColumn(0, CreateVectorZero(matrix.RowCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertColumn(0, CreateVectorZero(matrix.RowCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -166,7 +166,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assume.That(left.RowCount, Is.EqualTo(right.RowCount));
// THEN
var result = CreateDense(left.RowCount, left.ColumnCount + right.ColumnCount);
var result = CreateDenseZero(left.RowCount, left.ColumnCount + right.ColumnCount);
left.Append(right, result);
Assert.That(result.ColumnCount, Is.EqualTo(left.ColumnCount + right.ColumnCount));
@ -180,10 +180,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => left.Append(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => left.Append(right, CreateDense(left.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.Append(right, CreateDense(left.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.Append(right, CreateDense(left.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => left.Append(right, CreateDense(left.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => left.Append(right, CreateDenseZero(left.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.Append(right, CreateDenseZero(left.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.Append(right, CreateDenseZero(left.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => left.Append(right, CreateDenseZero(left.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -215,7 +215,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assume.That(top.ColumnCount, Is.EqualTo(bottom.ColumnCount));
// THEN
var result = CreateDense(top.RowCount + bottom.RowCount, top.ColumnCount);
var result = CreateDenseZero(top.RowCount + bottom.RowCount, top.ColumnCount);
top.Stack(bottom, result);
Assert.That(result.RowCount, Is.EqualTo(top.RowCount + bottom.RowCount));
@ -229,10 +229,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => top.Stack(bottom, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => top.Stack(bottom, CreateDense(top.RowCount + bottom.RowCount + 1, top.ColumnCount)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, CreateDense(top.RowCount + bottom.RowCount - 1, top.ColumnCount)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, CreateDense(top.RowCount + bottom.RowCount, top.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, CreateDense(top.RowCount + bottom.RowCount, top.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, CreateDenseZero(top.RowCount + bottom.RowCount + 1, top.ColumnCount)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, CreateDenseZero(top.RowCount + bottom.RowCount - 1, top.ColumnCount)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, CreateDenseZero(top.RowCount + bottom.RowCount, top.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, CreateDenseZero(top.RowCount + bottom.RowCount, top.ColumnCount - 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -264,7 +264,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanDiagonalStackIntoResult(Matrix<T> left, Matrix<T> right)
{
var result = CreateDense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount);
var result = CreateDenseZero(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount);
left.DiagonalStack(right, result);
Assert.That(result.RowCount, Is.EqualTo(left.RowCount + right.RowCount));
@ -286,10 +286,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => left.DiagonalStack(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => left.DiagonalStack(right, CreateDense(left.RowCount + right.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, CreateDense(left.RowCount + right.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, CreateDense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, CreateDense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, CreateDenseZero(left.RowCount + right.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, CreateDenseZero(left.RowCount + right.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, CreateDenseZero(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, CreateDenseZero(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
}
}
}

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

@ -10,13 +10,27 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public abstract partial class MatrixStructureTheory<T>
where T : struct, IEquatable<T>, IFormattable
{
protected abstract Matrix<T> CreateDense(int rows, int columns);
protected abstract Matrix<T> CreateDense(int rows, int columns, int seed);
protected abstract Matrix<T> CreateSparse(int rows, int columns);
protected abstract Vector<T> CreateVector(int size);
protected abstract Vector<T> CreateVector(int size, int seed);
protected abstract Matrix<T> CreateDenseZero(int rows, int columns);
protected abstract Matrix<T> CreateDenseRandom(int rows, int columns, int seed);
protected abstract Matrix<T> CreateSparseZero(int rows, int columns);
protected abstract Vector<T> CreateVectorZero(int size);
protected abstract Vector<T> CreateVectorRandom(int size, int seed);
protected abstract T Zero { get; }
protected Matrix<T> CreateDenseFor(Matrix<T> m, int rows = -1, int columns = -1, int seed = 1)
{
return m.IsFullyMutable
? CreateDenseRandom(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount, seed)
: CreateDenseZero(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount);
}
protected Vector<T> CreateVectorFor(Matrix<T> m, int size, int seed = 1)
{
return m.IsFullyMutable
? CreateVectorRandom(size, seed)
: CreateVectorZero(size);
}
[Theory, Timeout(200)]
public void IsEqualToItself(Matrix<T> matrix)
{
@ -76,11 +90,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)]
public void CanCopyTo(Matrix<T> matrix)
{
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount);
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.CopyTo(dense);
Assert.That(dense, Is.EqualTo(matrix));
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount);
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
matrix.CopyTo(sparse);
Assert.That(sparse, Is.EqualTo(matrix));
@ -88,8 +102,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assert.That(() => matrix.CopyTo(null), Throws.InstanceOf<ArgumentNullException>());
// bad arg
Assert.That(() => matrix.CopyTo(CreateDense(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.CopyTo(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => matrix.CopyTo(CreateDenseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.CopyTo(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory, Timeout(200)]
@ -147,7 +161,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public void CanCreateSameType(Matrix<T> matrix)
{
var empty = matrix.CreateMatrix(5, 6);
Assert.That(empty, Is.EqualTo(CreateDense(5, 6)));
Assert.That(empty, Is.EqualTo(CreateDenseZero(5, 6)));
Assert.That(empty.GetType(), Is.EqualTo(matrix.GetType()));
Assert.That(() => matrix.CreateMatrix(0, 2), Throws.InstanceOf<ArgumentOutOfRangeException>());
@ -158,9 +172,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test, Timeout(200)]
public void CanCreateFromColumns()
{
var column1 = CreateVector(1, 0);
var column2 = CreateVector(4, 1);
var column3 = CreateVector(2, 3);
var column1 = CreateVectorRandom(1, 0);
var column2 = CreateVectorRandom(4, 1);
var column3 = CreateVectorRandom(2, 3);
var matrix = Matrix<T>.CreateFromColumns(new List<Vector<T>>
{
@ -190,9 +204,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test, Timeout(200)]
public void CanCreateFromRows()
{
var row1 = CreateVector(1, 0);
var row2 = CreateVector(4, 1);
var row3 = CreateVector(2, 3);
var row1 = CreateVectorRandom(1, 0);
var row2 = CreateVectorRandom(4, 1);
var row3 = CreateVectorRandom(2, 3);
var matrix = Matrix<T>.CreateFromRows(new List<Vector<T>>
{
@ -222,7 +236,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test, Timeout(200)]
public void CanEnumerateWithIndex()
{
var dense = CreateDense(2, 3, 0);
var dense = CreateDenseRandom(2, 3, 0);
using(var enumerator = dense.IndexedEnumerator().GetEnumerator())
for (int i = 0; i < 2; i++)
{

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

@ -35,28 +35,28 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
[Datapoints]
float[] _scalars = new[] {2f, -1.5f, 0f};
protected override Matrix<float> CreateDense(int rows, int columns)
protected override Matrix<float> CreateDenseZero(int rows, int columns)
{
return new DenseMatrix(rows, columns);
}
protected override Matrix<float> CreateDense(int rows, int columns, int seed)
protected override Matrix<float> CreateDenseRandom(int rows, int columns, int seed)
{
var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseMatrix(rows, columns, dist.Samples().Select(d => (float) d).Take(rows*columns).ToArray());
}
protected override Matrix<float> CreateSparse(int rows, int columns)
protected override Matrix<float> CreateSparseZero(int rows, int columns)
{
return new SparseMatrix(rows, columns);
}
protected override Vector<float> CreateVector(int size)
protected override Vector<float> CreateVectorZero(int size)
{
return new DenseVector(size);
}
protected override Vector<float> CreateVector(int size, int seed)
protected override Vector<float> CreateVectorRandom(int size, int seed)
{
var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseVector(dist.Samples().Select(d => (float) d).Take(size).ToArray());

Write Preview
Loading…
Cancel
Save