us1zcljz
/
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
Unified 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] [Datapoints]
Complex[] scalars = new[] {new Complex(2d, 0d), new Complex(-1.5d, 3.5d), Complex.Zero}; 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); 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)}; 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()); 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); return new SparseMatrix(rows, columns);
} }
protected override Vector<Complex> CreateVector(int size) protected override Vector<Complex> CreateVectorZero(int size)
{ {
return new DenseVector(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)}; var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseVector(Enumerable.Range(0, size).Select(k => new Complex(dist.Sample(), dist.Sample())).ToArray()); 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] [Datapoints]
Complex32[] scalars = new[] {new Complex32(2f, 0f), new Complex32(-1.5f, 3.5f), Complex32.Zero}; 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); 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)}; 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()); 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); return new SparseMatrix(rows, columns);
} }
protected override Vector<Complex32> CreateVector(int size) protected override Vector<Complex32> CreateVectorZero(int size)
{ {
return new DenseVector(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)}; 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()); 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] [Datapoints]
double[] _scalars = new[] {2d, -1.5d, 0d}; 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); 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)}; var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseMatrix(rows, columns, dist.Samples().Take(rows*columns).ToArray()); 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); return new SparseMatrix(rows, columns);
} }
protected override Vector<double> CreateVector(int size) protected override Vector<double> CreateVectorZero(int size)
{ {
return new DenseVector(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)}; var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseVector(dist.Samples().Take(size).ToArray()); 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)] [Theory, Timeout(200)]
public void CanGetRowIntoResult(Matrix<T> matrix) public void CanGetRowIntoResult(Matrix<T> matrix)
{ {
var row = CreateVector(matrix.ColumnCount); var row = CreateVectorZero(matrix.ColumnCount);
matrix.Row(0, row); matrix.Row(0, row);
for (var j = 0; j < matrix.ColumnCount; j++) for (var j = 0; j < matrix.ColumnCount; j++)
@ -96,7 +96,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanGetRowWithRangeIntoResult(Matrix<T> matrix) 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); matrix.Row(0, 1, matrix.ColumnCount - 1, row);
for (var j = 0; j < matrix.ColumnCount - 1; j++) for (var j = 0; j < matrix.ColumnCount - 1; j++)
@ -137,7 +137,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanGetColumnIntoResult(Matrix<T> matrix) public void CanGetColumnIntoResult(Matrix<T> matrix)
{ {
var col = CreateVector(matrix.RowCount); var col = CreateVectorZero(matrix.RowCount);
matrix.Column(0, col); matrix.Column(0, col);
for (var i = 0; i < matrix.RowCount; i++) for (var i = 0; i < matrix.RowCount; i++)
@ -188,7 +188,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanGetColumnWithRangeIntoResult(Matrix<T> matrix) 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); matrix.Column(0, 1, matrix.RowCount - 1, col);
for (var i = 0; i < matrix.RowCount - 1; i++) for (var i = 0; i < matrix.RowCount - 1; i++)
@ -207,32 +207,34 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{ {
// First Row // First Row
var m = matrix.Clone(); 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 i = 0; i < matrix.RowCount; i++)
{ {
for (var j = 0; j < matrix.ColumnCount; j++) 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 // Last Row
m = matrix.Clone(); 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 i = 0; i < matrix.RowCount; i++)
{ {
for (var j = 0; j < matrix.ColumnCount; j++) 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 // Invalid Rows
Assert.That(() => matrix.SetRow(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>()); 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(-1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(matrix.RowCount, CreateVector(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>()); Assert.That(() => matrix.SetRow(matrix.RowCount, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(0, CreateVector(matrix.ColumnCount - 1)), Throws.ArgumentException); Assert.That(() => matrix.SetRow(0, CreateVectorZero(matrix.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetRow(0, CreateVector(matrix.ColumnCount + 1)), Throws.ArgumentException); Assert.That(() => matrix.SetRow(0, CreateVectorZero(matrix.ColumnCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -240,7 +242,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{ {
// First Row // First Row
var m = matrix.Clone(); 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 i = 0; i < matrix.RowCount; i++)
{ {
for (var j = 0; j < matrix.ColumnCount; j++) for (var j = 0; j < matrix.ColumnCount; j++)
@ -273,32 +275,34 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{ {
// First Column // First Column
var m = matrix.Clone(); 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 i = 0; i < matrix.RowCount; i++)
{ {
for (var j = 0; j < matrix.ColumnCount; j++) 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 // Last Column
m = matrix.Clone(); 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 i = 0; i < matrix.RowCount; i++)
{ {
for (var j = 0; j < matrix.ColumnCount; j++) 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 // Invalid Rows
Assert.That(() => matrix.SetColumn(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>()); 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(-1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(matrix.ColumnCount, CreateVector(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>()); Assert.That(() => matrix.SetColumn(matrix.ColumnCount, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(0, CreateVector(matrix.RowCount - 1)), Throws.ArgumentException); Assert.That(() => matrix.SetColumn(0, CreateVectorZero(matrix.RowCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetColumn(0, CreateVector(matrix.RowCount + 1)), Throws.ArgumentException); Assert.That(() => matrix.SetColumn(0, CreateVectorZero(matrix.RowCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -306,7 +310,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{ {
// First Column // First Column
var m = matrix.Clone(); 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 i = 0; i < matrix.RowCount; i++)
{ {
for (var j = 0; j < matrix.ColumnCount; j++) for (var j = 0; j < matrix.ColumnCount; j++)
@ -350,7 +354,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanGetUpperTriangleIntoResult(Matrix<T> matrix) public void CanGetUpperTriangleIntoResult(Matrix<T> matrix)
{ {
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount); var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.UpperTriangle(dense); matrix.UpperTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++) 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); matrix.UpperTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++) 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(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.UpperTriangle(CreateSparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException); Assert.That(() => matrix.UpperTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.UpperTriangle(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException); Assert.That(() => matrix.UpperTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -391,7 +395,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanGetLowerTriangleIntoResult(Matrix<T> matrix) public void CanGetLowerTriangleIntoResult(Matrix<T> matrix)
{ {
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount); var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.LowerTriangle(dense); matrix.LowerTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++) 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); matrix.LowerTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++) 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(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.LowerTriangle(CreateSparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException); Assert.That(() => matrix.LowerTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.LowerTriangle(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException); Assert.That(() => matrix.LowerTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -432,7 +436,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanGetStrictlyUpperTriangleIntoResult(Matrix<T> matrix) public void CanGetStrictlyUpperTriangleIntoResult(Matrix<T> matrix)
{ {
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount); var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyUpperTriangle(dense); matrix.StrictlyUpperTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++) 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); matrix.StrictlyUpperTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++) 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(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.StrictlyUpperTriangle(CreateSparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException); Assert.That(() => matrix.StrictlyUpperTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyUpperTriangle(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException); Assert.That(() => matrix.StrictlyUpperTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -473,7 +477,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanGetStrictlyLowerTriangleIntoResult(Matrix<T> matrix) public void CanGetStrictlyLowerTriangleIntoResult(Matrix<T> matrix)
{ {
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount); var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyLowerTriangle(dense); matrix.StrictlyLowerTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++) 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); matrix.StrictlyLowerTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++) 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(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(() => matrix.StrictlyLowerTriangle(CreateSparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException); Assert.That(() => matrix.StrictlyLowerTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyLowerTriangle(CreateDense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException); Assert.That(() => matrix.StrictlyLowerTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -513,19 +517,20 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public void CanSetDiagonal(Matrix<T> matrix) public void CanSetDiagonal(Matrix<T> matrix)
{ {
var m = matrix.Clone(); 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 i = 0; i < matrix.RowCount; i++)
{ {
for (var j = 0; j < matrix.ColumnCount; j++) 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 // Invalid
Assert.That(() => matrix.SetDiagonal(default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>()); 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(CreateVectorZero(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);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -593,7 +598,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public void CanSetSubmatrix(Matrix<T> matrix) public void CanSetSubmatrix(Matrix<T> matrix)
{ {
// Top Left Corner 2x2 // Top Left Corner 2x2
var topleft = CreateDense(2, 2); var topleft = CreateDenseFor(matrix, 2, 2);
var m = matrix.Clone(); var m = matrix.Clone();
m.SetSubMatrix(0, 2, 0, 2, topleft); m.SetSubMatrix(0, 2, 0, 2, topleft);
for (var i = 0; i < m.RowCount; i++) for (var i = 0; i < m.RowCount; i++)
@ -605,7 +610,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
} }
// Bottom Right Cornet 1x2 // Bottom Right Cornet 1x2
var bottomright = CreateDense(1, 2); var bottomright = CreateDenseFor(matrix, 1, 2);
m = matrix.Clone(); m = matrix.Clone();
m.SetSubMatrix(matrix.RowCount - 1, 1, matrix.ColumnCount - 2, 2, bottomright); m.SetSubMatrix(matrix.RowCount - 1, 1, matrix.ColumnCount - 2, 2, bottomright);
for (var i = 0; i < m.RowCount; i++) for (var i = 0; i < m.RowCount; i++)
@ -619,16 +624,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid // Invalid
m = matrix.Clone(); m = matrix.Clone();
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>()); 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(-1, 1, 0, 1, CreateDenseZero(1,1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(matrix.RowCount, 1, 0, 1, CreateDense(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, CreateDense(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, CreateDense(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, CreateDense(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, CreateDense(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) // 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, CreateDenseZero(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(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)] [Theory, Timeout(200)]
public void CanInsertRow(Matrix<T> matrix) 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++) for (var position = 0; position < matrix.RowCount + 1; position++)
{ {
var result = matrix.InsertRow(position, row); var result = matrix.InsertRow(position, row);
@ -95,16 +95,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid // Invalid
Assert.That(() => matrix.InsertRow(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>()); 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(-1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, CreateVector(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>()); Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertRow(0, CreateVector(matrix.ColumnCount - 1)), Throws.ArgumentException); Assert.That(() => matrix.InsertRow(0, CreateVectorZero(matrix.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertRow(0, CreateVector(matrix.ColumnCount + 1)), Throws.ArgumentException); Assert.That(() => matrix.InsertRow(0, CreateVectorZero(matrix.ColumnCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanInsertColumn(Matrix<T> matrix) 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++) for (var position = 0; position < matrix.ColumnCount + 1; position++)
{ {
var result = matrix.InsertColumn(position, column); var result = matrix.InsertColumn(position, column);
@ -131,10 +131,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid // Invalid
Assert.That(() => matrix.InsertColumn(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>()); 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(-1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, CreateVector(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>()); Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertColumn(0, CreateVector(matrix.RowCount - 1)), Throws.ArgumentException); Assert.That(() => matrix.InsertColumn(0, CreateVectorZero(matrix.RowCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertColumn(0, CreateVector(matrix.RowCount + 1)), Throws.ArgumentException); Assert.That(() => matrix.InsertColumn(0, CreateVectorZero(matrix.RowCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -166,7 +166,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assume.That(left.RowCount, Is.EqualTo(right.RowCount)); Assume.That(left.RowCount, Is.EqualTo(right.RowCount));
// THEN // THEN
var result = CreateDense(left.RowCount, left.ColumnCount + right.ColumnCount); var result = CreateDenseZero(left.RowCount, left.ColumnCount + right.ColumnCount);
left.Append(right, result); left.Append(right, result);
Assert.That(result.ColumnCount, Is.EqualTo(left.ColumnCount + right.ColumnCount)); Assert.That(result.ColumnCount, Is.EqualTo(left.ColumnCount + right.ColumnCount));
@ -180,10 +180,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid // Invalid
Assert.That(() => left.Append(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>()); 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, CreateDenseZero(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, CreateDenseZero(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, CreateDenseZero(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, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -215,7 +215,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assume.That(top.ColumnCount, Is.EqualTo(bottom.ColumnCount)); Assume.That(top.ColumnCount, Is.EqualTo(bottom.ColumnCount));
// THEN // THEN
var result = CreateDense(top.RowCount + bottom.RowCount, top.ColumnCount); var result = CreateDenseZero(top.RowCount + bottom.RowCount, top.ColumnCount);
top.Stack(bottom, result); top.Stack(bottom, result);
Assert.That(result.RowCount, Is.EqualTo(top.RowCount + bottom.RowCount)); Assert.That(result.RowCount, Is.EqualTo(top.RowCount + bottom.RowCount));
@ -229,10 +229,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid // Invalid
Assert.That(() => top.Stack(bottom, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>()); 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, CreateDenseZero(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, CreateDenseZero(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, CreateDenseZero(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, top.ColumnCount - 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -264,7 +264,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanDiagonalStackIntoResult(Matrix<T> left, Matrix<T> right) 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); left.DiagonalStack(right, result);
Assert.That(result.RowCount, Is.EqualTo(left.RowCount + right.RowCount)); Assert.That(result.RowCount, Is.EqualTo(left.RowCount + right.RowCount));
@ -286,10 +286,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid // Invalid
Assert.That(() => left.DiagonalStack(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>()); 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, CreateDenseZero(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, CreateDenseZero(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, CreateDenseZero(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, 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> public abstract partial class MatrixStructureTheory<T>
where T : struct, IEquatable<T>, IFormattable where T : struct, IEquatable<T>, IFormattable
{ {
protected abstract Matrix<T> CreateDense(int rows, int columns); protected abstract Matrix<T> CreateDenseZero(int rows, int columns);
protected abstract Matrix<T> CreateDense(int rows, int columns, int seed); protected abstract Matrix<T> CreateDenseRandom(int rows, int columns, int seed);
protected abstract Matrix<T> CreateSparse(int rows, int columns); protected abstract Matrix<T> CreateSparseZero(int rows, int columns);
protected abstract Vector<T> CreateVector(int size); protected abstract Vector<T> CreateVectorZero(int size);
protected abstract Vector<T> CreateVector(int size, int seed); protected abstract Vector<T> CreateVectorRandom(int size, int seed);
protected abstract T Zero { get; } 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)] [Theory, Timeout(200)]
public void IsEqualToItself(Matrix<T> matrix) public void IsEqualToItself(Matrix<T> matrix)
{ {
@ -76,11 +90,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory, Timeout(200)] [Theory, Timeout(200)]
public void CanCopyTo(Matrix<T> matrix) public void CanCopyTo(Matrix<T> matrix)
{ {
var dense = CreateDense(matrix.RowCount, matrix.ColumnCount); var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
matrix.CopyTo(dense); matrix.CopyTo(dense);
Assert.That(dense, Is.EqualTo(matrix)); Assert.That(dense, Is.EqualTo(matrix));
var sparse = CreateSparse(matrix.RowCount, matrix.ColumnCount); var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
matrix.CopyTo(sparse); matrix.CopyTo(sparse);
Assert.That(sparse, Is.EqualTo(matrix)); Assert.That(sparse, Is.EqualTo(matrix));
@ -88,8 +102,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assert.That(() => matrix.CopyTo(null), Throws.InstanceOf<ArgumentNullException>()); Assert.That(() => matrix.CopyTo(null), Throws.InstanceOf<ArgumentNullException>());
// bad arg // bad arg
Assert.That(() => matrix.CopyTo(CreateDense(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException); Assert.That(() => matrix.CopyTo(CreateDenseZero(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, matrix.ColumnCount + 1)), Throws.ArgumentException);
} }
[Theory, Timeout(200)] [Theory, Timeout(200)]
@ -147,7 +161,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public void CanCreateSameType(Matrix<T> matrix) public void CanCreateSameType(Matrix<T> matrix)
{ {
var empty = matrix.CreateMatrix(5, 6); 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(empty.GetType(), Is.EqualTo(matrix.GetType()));
Assert.That(() => matrix.CreateMatrix(0, 2), Throws.InstanceOf<ArgumentOutOfRangeException>()); Assert.That(() => matrix.CreateMatrix(0, 2), Throws.InstanceOf<ArgumentOutOfRangeException>());
@ -158,9 +172,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test, Timeout(200)] [Test, Timeout(200)]
public void CanCreateFromColumns() public void CanCreateFromColumns()
{ {
var column1 = CreateVector(1, 0); var column1 = CreateVectorRandom(1, 0);
var column2 = CreateVector(4, 1); var column2 = CreateVectorRandom(4, 1);
var column3 = CreateVector(2, 3); var column3 = CreateVectorRandom(2, 3);
var matrix = Matrix<T>.CreateFromColumns(new List<Vector<T>> var matrix = Matrix<T>.CreateFromColumns(new List<Vector<T>>
{ {
@ -190,9 +204,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test, Timeout(200)] [Test, Timeout(200)]
public void CanCreateFromRows() public void CanCreateFromRows()
{ {
var row1 = CreateVector(1, 0); var row1 = CreateVectorRandom(1, 0);
var row2 = CreateVector(4, 1); var row2 = CreateVectorRandom(4, 1);
var row3 = CreateVector(2, 3); var row3 = CreateVectorRandom(2, 3);
var matrix = Matrix<T>.CreateFromRows(new List<Vector<T>> var matrix = Matrix<T>.CreateFromRows(new List<Vector<T>>
{ {
@ -222,7 +236,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test, Timeout(200)] [Test, Timeout(200)]
public void CanEnumerateWithIndex() public void CanEnumerateWithIndex()
{ {
var dense = CreateDense(2, 3, 0); var dense = CreateDenseRandom(2, 3, 0);
using(var enumerator = dense.IndexedEnumerator().GetEnumerator()) using(var enumerator = dense.IndexedEnumerator().GetEnumerator())
for (int i = 0; i < 2; i++) 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] [Datapoints]
float[] _scalars = new[] {2f, -1.5f, 0f}; 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); 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)}; var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseMatrix(rows, columns, dist.Samples().Select(d => (float) d).Take(rows*columns).ToArray()); 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); return new SparseMatrix(rows, columns);
} }
protected override Vector<float> CreateVector(int size) protected override Vector<float> CreateVectorZero(int size)
{ {
return new DenseVector(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)}; var dist = new Normal {RandomSource = new MersenneTwister(seed)};
return new DenseVector(dist.Samples().Select(d => (float) d).Take(size).ToArray()); return new DenseVector(dist.Samples().Select(d => (float) d).Take(size).ToArray());

Write Preview
Loading…
Cancel
Save