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

Tests: simplify matrix structure theory tests by using matrix builders

pull/184/head
Christoph Ruegg 13 years ago
parent
5e997534ad
commit
056d3e5742
7 changed files with 161 additions and 296 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. 63
      src/UnitTests/LinearAlgebraTests/Complex/MatrixStructureTheory.cs
  2. 63
      src/UnitTests/LinearAlgebraTests/Complex32/MatrixStructureTheory.cs
  3. 63
      src/UnitTests/LinearAlgebraTests/Double/MatrixStructureTheory.cs
  4. 80
      src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Access.cs
  5. 50
      src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs
  6. 75
      src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs
  7. 63
      src/UnitTests/LinearAlgebraTests/Single/MatrixStructureTheory.cs

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

@ -28,11 +28,7 @@
// OTHER DEALINGS IN THE SOFTWARE.
// </copyright>
using System.Linq;
using MathNet.Numerics.Distributions;
using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Complex;
using MathNet.Numerics.Random;
using NUnit.Framework;
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
@ -48,53 +44,26 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
{
[Datapoints]
Matrix<Complex>[] _matrices = new Matrix<Complex>[]
{
DenseMatrix.OfArray(new[,] {{1d, new Complex(1.1d, -4d), 2d}, {1d, 1d, 2d}, {1d, new Complex(1d, 2d), 2d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d}, {0d, 1.1d, new Complex(2.2d, -1.2d)}, {-4.4d, 5.5d, 6.6d}}),
DenseMatrix.OfArray(new[,] {{new Complex(-1.1d, -2d), -2.2d, -3.3d, -4.4d}, {0d, 1.1d, 2.2d, 3.3d}, {1d, 2.1d, 6.2d, 4.3d}, {-4.4d, 5.5d, 6.6d, -7.7d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, new Complex(-2.2d, 3.4d), -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d}, {Complex.Zero, 1.1d}, {-4.4d, 5.5d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d}, {0d, new Complex(1.1d, 0.1d), 2.2d}}),
DenseMatrix.OfArray(new[,] {{1d, 2d, 3d}, {2d, new Complex(2d, 2d), 0d}, {3d, Complex.Zero, 3d}}),
SparseMatrix.OfArray(new[,] {{7d, 1d, 2d}, {1d, 1d, 2d}, {1d, 1d + Complex.ImaginaryOne, 2d}}),
SparseMatrix.OfArray(new[,] {{7d, 1d, 2d}, {new Complex(1d, 2d), 0d, Complex.Zero}, {-2d, 0d, 0d}}),
SparseMatrix.OfArray(new[,] {{-1.1d, 0d, 0d}, {0d, new Complex(1.1d, 2d), 2.2d}}),
new DiagonalMatrix(3, 3, new[] {new Complex(1d, 1d), -2d, 1.5d}),
new DiagonalMatrix(3, 3, new[] {new Complex(1d, 2d), 0d, -1.5d}),
new UserDefinedMatrix(new[,] {{0d, 1d, 2d}, {-1d, 7.7d, 0d}, {-2d, Complex.Zero, 0d}})
};
[Datapoints]
Complex[] scalars = new[] {new Complex(2d, 0d), new Complex(-1.5d, 3.5d), Complex.Zero};
protected override Matrix<Complex> CreateDenseZero(int rows, int columns)
{
return new DenseMatrix(rows, columns);
}
Matrix<Complex>.Build.DenseOfArray(new[,] { { 1d, new Complex(1.1d, -4d), 2d }, { 1d, 1d, 2d }, { 1d, new Complex(1d, 2d), 2d } }),
Matrix<Complex>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d }, { 0d, 1.1d, new Complex(2.2d, -1.2d) }, { -4.4d, 5.5d, 6.6d } }),
Matrix<Complex>.Build.DenseOfArray(new[,] { { new Complex(-1.1d, -2d), -2.2d, -3.3d, -4.4d }, { 0d, 1.1d, 2.2d, 3.3d }, { 1d, 2.1d, 6.2d, 4.3d }, { -4.4d, 5.5d, 6.6d, -7.7d } }),
Matrix<Complex>.Build.DenseOfArray(new[,] { { -1.1d, new Complex(-2.2d, 3.4d), -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d } }),
Matrix<Complex>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d }, { Complex.Zero, 1.1d }, { -4.4d, 5.5d } }),
Matrix<Complex>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d }, { 0d, new Complex(1.1d, 0.1d), 2.2d } }),
Matrix<Complex>.Build.DenseOfArray(new[,] { { 1d, 2d, 3d }, { 2d, new Complex(2d, 2d), 0d }, { 3d, Complex.Zero, 3d } }),
protected override Matrix<Complex> CreateDenseRandom(int rows, int columns, int seed)
{
var dist = new Normal(new MersenneTwister(seed));
return new DenseMatrix(rows, columns, Enumerable.Range(0, rows*columns).Select(k => new Complex(dist.Sample(), dist.Sample())).ToArray());
}
Matrix<Complex>.Build.SparseOfArray(new[,] { { 7d, 1d, 2d }, { 1d, 1d, 2d }, { 1d, 1d + Complex.ImaginaryOne, 2d } }),
Matrix<Complex>.Build.SparseOfArray(new[,] { { 7d, 1d, 2d }, { new Complex(1d, 2d), 0d, Complex.Zero }, { -2d, 0d, 0d } }),
Matrix<Complex>.Build.SparseOfArray(new[,] { { -1.1d, 0d, 0d }, { 0d, new Complex(1.1d, 2d), 2.2d } }),
protected override Matrix<Complex> CreateSparseZero(int rows, int columns)
{
return new SparseMatrix(rows, columns);
}
Matrix<Complex>.Build.Diagonal(3, 3, new[] { new Complex(1d, 1d), -2d, 1.5d }),
Matrix<Complex>.Build.Diagonal(3, 3, new[] { new Complex(1d, 2d), 0d, -1.5d }),
protected override Vector<Complex> CreateVectorZero(int size)
{
return new DenseVector(size);
}
new UserDefinedMatrix(new[,] { { 0d, 1d, 2d }, { -1d, 7.7d, 0d }, { -2d, Complex.Zero, 0d } })
};
protected override Vector<Complex> CreateVectorRandom(int size, int seed)
{
var dist = new Normal(new MersenneTwister(seed));
return new DenseVector(Enumerable.Range(0, size).Select(k => new Complex(dist.Sample(), dist.Sample())).ToArray());
}
[Datapoints]
Complex[] _scalars = new[] { new Complex(2d, 0d), new Complex(-1.5d, 3.5d), Complex.Zero };
}
}

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

@ -28,11 +28,7 @@
// OTHER DEALINGS IN THE SOFTWARE.
// </copyright>
using System.Linq;
using MathNet.Numerics.Distributions;
using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Complex32;
using MathNet.Numerics.Random;
using NUnit.Framework;
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
@ -44,53 +40,26 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
{
[Datapoints]
Matrix<Complex32>[] _matrices = new Matrix<Complex32>[]
{
DenseMatrix.OfArray(new[,] {{1f, new Complex32(1.1f, -4f), 2f}, {1f, 1f, 2f}, {1f, new Complex32(1f, 2f), 2f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f}, {0f, 1.1f, new Complex32(2.2f, -1.2f)}, {-4.4f, 5.5f, 6.6f}}),
DenseMatrix.OfArray(new[,] {{new Complex32(-1.1f, -2f), -2.2f, -3.3f, -4.4f}, {0f, 1.1f, 2.2f, 3.3f}, {1f, 2.1f, 6.2f, 4.3f}, {-4.4f, 5.5f, 6.6f, -7.7f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, new Complex32(-2.2f, 3.4f), -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f}, {Complex32.Zero, 1.1f}, {-4.4f, 5.5f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f}, {0f, new Complex32(1.1f, 0.1f), 2.2f}}),
DenseMatrix.OfArray(new[,] {{1f, 2f, 3f}, {2f, new Complex32(2f, 2f), 0f}, {3f, Complex32.Zero, 3f}}),
SparseMatrix.OfArray(new[,] {{7f, 1f, 2f}, {1f, 1f, 2f}, {1f, 1f + Complex32.ImaginaryOne, 2f}}),
SparseMatrix.OfArray(new[,] {{7f, 1f, 2f}, {new Complex32(1f, 2f), 0f, Complex32.Zero}, {-2f, 0f, 0f}}),
SparseMatrix.OfArray(new[,] {{-1.1f, 0f, 0f}, {0f, new Complex32(1.1f, 2f), 2.2f}}),
new DiagonalMatrix(3, 3, new[] {new Complex32(1f, 1f), -2f, 1.5f}),
new DiagonalMatrix(3, 3, new[] {new Complex32(1f, 2f), 0f, -1.5f}),
new UserDefinedMatrix(new[,] {{0f, 1f, 2f}, {-1f, 7.7f, 0f}, {-2f, Complex32.Zero, 0f}})
};
[Datapoints]
Complex32[] scalars = new[] {new Complex32(2f, 0f), new Complex32(-1.5f, 3.5f), Complex32.Zero};
protected override Matrix<Complex32> CreateDenseZero(int rows, int columns)
{
return new DenseMatrix(rows, columns);
}
Matrix<Complex32>.Build.DenseOfArray(new[,] { { 1f, new Complex32(1.1f, -4f), 2f }, { 1f, 1f, 2f }, { 1f, new Complex32(1f, 2f), 2f } }),
Matrix<Complex32>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f }, { 0f, 1.1f, new Complex32(2.2f, -1.2f) }, { -4.4f, 5.5f, 6.6f } }),
Matrix<Complex32>.Build.DenseOfArray(new[,] { { new Complex32(-1.1f, -2f), -2.2f, -3.3f, -4.4f }, { 0f, 1.1f, 2.2f, 3.3f }, { 1f, 2.1f, 6.2f, 4.3f }, { -4.4f, 5.5f, 6.6f, -7.7f } }),
Matrix<Complex32>.Build.DenseOfArray(new[,] { { -1.1f, new Complex32(-2.2f, 3.4f), -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f } }),
Matrix<Complex32>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f }, { Complex32.Zero, 1.1f }, { -4.4f, 5.5f } }),
Matrix<Complex32>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f }, { 0f, new Complex32(1.1f, 0.1f), 2.2f } }),
Matrix<Complex32>.Build.DenseOfArray(new[,] { { 1f, 2f, 3f }, { 2f, new Complex32(2f, 2f), 0f }, { 3f, Complex32.Zero, 3f } }),
protected override Matrix<Complex32> CreateDenseRandom(int rows, int columns, int seed)
{
var dist = new Normal(new MersenneTwister(seed));
return new DenseMatrix(rows, columns, Enumerable.Range(0, rows*columns).Select(k => new Complex32((float) dist.Sample(), (float) dist.Sample())).ToArray());
}
Matrix<Complex32>.Build.SparseOfArray(new[,] { { 7f, 1f, 2f }, { 1f, 1f, 2f }, { 1f, 1f + Complex32.ImaginaryOne, 2f } }),
Matrix<Complex32>.Build.SparseOfArray(new[,] { { 7f, 1f, 2f }, { new Complex32(1f, 2f), 0f, Complex32.Zero }, { -2f, 0f, 0f } }),
Matrix<Complex32>.Build.SparseOfArray(new[,] { { -1.1f, 0f, 0f }, { 0f, new Complex32(1.1f, 2f), 2.2f } }),
protected override Matrix<Complex32> CreateSparseZero(int rows, int columns)
{
return new SparseMatrix(rows, columns);
}
Matrix<Complex32>.Build.Diagonal(3, 3, new[] { new Complex32(1f, 1f), -2f, 1.5f }),
Matrix<Complex32>.Build.Diagonal(3, 3, new[] { new Complex32(1f, 2f), 0f, -1.5f }),
protected override Vector<Complex32> CreateVectorZero(int size)
{
return new DenseVector(size);
}
new UserDefinedMatrix(new[,] { { 0f, 1f, 2f }, { -1f, 7.7f, 0f }, { -2f, Complex32.Zero, 0f } })
};
protected override Vector<Complex32> CreateVectorRandom(int size, int seed)
{
var dist = new Normal(new MersenneTwister(seed));
return new DenseVector(Enumerable.Range(0, size).Select(k => new Complex32((float) dist.Sample(), (float) dist.Sample())).ToArray());
}
[Datapoints]
Complex32[] scalars = new[] { new Complex32(2f, 0f), new Complex32(-1.5f, 3.5f), Complex32.Zero };
}
}

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

@ -28,11 +28,7 @@
// OTHER DEALINGS IN THE SOFTWARE.
// </copyright>
using System.Linq;
using MathNet.Numerics.Distributions;
using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Double;
using MathNet.Numerics.Random;
using NUnit.Framework;
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
@ -42,53 +38,26 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
{
[Datapoints]
Matrix<double>[] _matrices = new Matrix<double>[]
{
DenseMatrix.OfArray(new[,] {{1d, 1d, 2d}, {1d, 1d, 2d}, {1d, 1d, 2d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d}, {0d, 1.1d, 2.2d}, {-4.4d, 5.5d, 6.6d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d, -4.4d}, {0d, 1.1d, 2.2d, 3.3d}, {1d, 2.1d, 6.2d, 4.3d}, {-4.4d, 5.5d, 6.6d, -7.7d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d}, {0d, 1.1d}, {-4.4d, 5.5d}}),
DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d}, {0d, 1.1d, 2.2d}}),
DenseMatrix.OfArray(new[,] {{1d, 2d, 3d}, {2d, 2d, 0d}, {3d, 0d, 3d}}),
SparseMatrix.OfArray(new[,] {{7d, 1d, 2d}, {1d, 1d, 2d}, {1d, 1d, 2d}}),
SparseMatrix.OfArray(new[,] {{7d, 1d, 2d}, {1d, 0d, 0d}, {-2d, 0d, 0d}}),
SparseMatrix.OfArray(new[,] {{-1.1d, 0d, 0d}, {0d, 1.1d, 2.2d}}),
new DiagonalMatrix(3, 3, new[] {1d, -2d, 1.5d}),
new DiagonalMatrix(3, 3, new[] {1d, 0d, -1.5d}),
new UserDefinedMatrix(new[,] {{0d, 1d, 2d}, {-1d, 7.7d, 0d}, {-2d, 0d, 0d}})
};
[Datapoints]
double[] _scalars = new[] {2d, -1.5d, 0d};
protected override Matrix<double> CreateDenseZero(int rows, int columns)
{
return new DenseMatrix(rows, columns);
}
Matrix<double>.Build.DenseOfArray(new[,] { { 1d, 1d, 2d }, { 1d, 1d, 2d }, { 1d, 1d, 2d } }),
Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d }, { 0d, 1.1d, 2.2d }, { -4.4d, 5.5d, 6.6d } }),
Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d, -4.4d }, { 0d, 1.1d, 2.2d, 3.3d }, { 1d, 2.1d, 6.2d, 4.3d }, { -4.4d, 5.5d, 6.6d, -7.7d } }),
Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d } }),
Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d }, { 0d, 1.1d }, { -4.4d, 5.5d } }),
Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d }, { 0d, 1.1d, 2.2d } }),
Matrix<double>.Build.DenseOfArray(new[,] { { 1d, 2d, 3d }, { 2d, 2d, 0d }, { 3d, 0d, 3d } }),
protected override Matrix<double> CreateDenseRandom(int rows, int columns, int seed)
{
var dist = new Normal(new MersenneTwister(seed));
return new DenseMatrix(rows, columns, dist.Samples().Take(rows*columns).ToArray());
}
Matrix<double>.Build.SparseOfArray(new[,] { { 7d, 1d, 2d }, { 1d, 1d, 2d }, { 1d, 1d, 2d } }),
Matrix<double>.Build.SparseOfArray(new[,] { { 7d, 1d, 2d }, { 1d, 0d, 0d }, { -2d, 0d, 0d } }),
Matrix<double>.Build.SparseOfArray(new[,] { { -1.1d, 0d, 0d }, { 0d, 1.1d, 2.2d } }),
protected override Matrix<double> CreateSparseZero(int rows, int columns)
{
return new SparseMatrix(rows, columns);
}
Matrix<double>.Build.Diagonal(3, 3, new[] { 1d, -2d, 1.5d }),
Matrix<double>.Build.Diagonal(3, 3, new[] { 1d, 0d, -1.5d }),
protected override Vector<double> CreateVectorZero(int size)
{
return new DenseVector(size);
}
new UserDefinedMatrix(new[,] { { 0d, 1d, 2d }, { -1d, 7.7d, 0d }, { -2d, 0d, 0d } })
};
protected override Vector<double> CreateVectorRandom(int size, int seed)
{
var dist = new Normal(new MersenneTwister(seed));
return new DenseVector(dist.Samples().Take(size).ToArray());
}
[Datapoints]
double[] _scalars = new[] { 2d, -1.5d, 0d };
}
}

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

@ -75,7 +75,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanGetRowIntoResult(Matrix<T> matrix)
{
var row = CreateVectorZero(matrix.ColumnCount);
var row = Vector<T>.Build.Dense(matrix.ColumnCount);
matrix.Row(0, row);
for (var j = 0; j < matrix.ColumnCount; j++)
@ -126,7 +126,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanGetRowWithRangeIntoResult(Matrix<T> matrix)
{
var row = CreateVectorZero(matrix.ColumnCount - 1);
var row = Vector<T>.Build.Dense(matrix.ColumnCount - 1);
matrix.Row(0, 1, matrix.ColumnCount - 1, row);
for (var j = 0; j < matrix.ColumnCount - 1; j++)
@ -167,7 +167,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanGetColumnIntoResult(Matrix<T> matrix)
{
var col = CreateVectorZero(matrix.RowCount);
var col = Vector<T>.Build.Dense(matrix.RowCount);
matrix.Column(0, col);
for (var i = 0; i < matrix.RowCount; i++)
@ -218,7 +218,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanGetColumnWithRangeIntoResult(Matrix<T> matrix)
{
var col = CreateVectorZero(matrix.RowCount - 1);
var col = Vector<T>.Build.Dense(matrix.RowCount - 1);
matrix.Column(0, 1, matrix.RowCount - 1, col);
for (var i = 0; i < matrix.RowCount - 1; i++)
@ -261,10 +261,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid Rows
Assert.That(() => matrix.SetRow(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
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);
Assert.That(() => matrix.SetRow(-1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(matrix.RowCount, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetRow(0, Vector<T>.Build.Dense(matrix.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetRow(0, Vector<T>.Build.Dense(matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory]
@ -272,7 +272,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
// First Row
var m = matrix.Clone();
m.SetRow(0, CreateVectorZero(matrix.ColumnCount).ToArray());
m.SetRow(0, Vector<T>.Build.Dense(matrix.ColumnCount).ToArray());
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
@ -329,10 +329,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid Rows
Assert.That(() => matrix.SetColumn(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
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);
Assert.That(() => matrix.SetColumn(-1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(matrix.ColumnCount, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.SetColumn(0, Vector<T>.Build.Dense(matrix.RowCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetColumn(0, Vector<T>.Build.Dense(matrix.RowCount + 1)), Throws.ArgumentException);
}
[Theory]
@ -340,7 +340,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
// First Column
var m = matrix.Clone();
m.SetColumn(0, CreateVectorZero(matrix.RowCount).ToArray());
m.SetColumn(0, Vector<T>.Build.Dense(matrix.RowCount).ToArray());
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
@ -384,7 +384,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanGetUpperTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
matrix.UpperTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -394,7 +394,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
}
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
matrix.UpperTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -405,8 +405,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
Assert.That(() => matrix.UpperTriangle(null), Throws.Exception);
Assert.That(() => matrix.UpperTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.UpperTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => matrix.UpperTriangle(Matrix<T>.Build.Sparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.UpperTriangle(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory]
@ -425,7 +425,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanGetLowerTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
matrix.LowerTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -435,7 +435,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
}
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
matrix.LowerTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -446,8 +446,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
Assert.That(() => matrix.LowerTriangle(null), Throws.Exception);
Assert.That(() => matrix.LowerTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.LowerTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => matrix.LowerTriangle(Matrix<T>.Build.Sparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.LowerTriangle(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory]
@ -466,7 +466,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanGetStrictlyUpperTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyUpperTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -476,7 +476,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
}
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyUpperTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -487,8 +487,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
Assert.That(() => matrix.StrictlyUpperTriangle(null), Throws.Exception);
Assert.That(() => matrix.StrictlyUpperTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyUpperTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyUpperTriangle(Matrix<T>.Build.Sparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyUpperTriangle(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory]
@ -507,7 +507,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanGetStrictlyLowerTriangleIntoResult(Matrix<T> matrix)
{
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyLowerTriangle(dense);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -517,7 +517,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
}
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
matrix.StrictlyLowerTriangle(sparse);
for (var i = 0; i < matrix.RowCount; i++)
{
@ -528,8 +528,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
}
Assert.That(() => matrix.StrictlyLowerTriangle(null), Throws.Exception);
Assert.That(() => matrix.StrictlyLowerTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyLowerTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyLowerTriangle(Matrix<T>.Build.Sparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.StrictlyLowerTriangle(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory]
@ -559,8 +559,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => matrix.SetDiagonal(default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
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);
Assert.That(() => matrix.SetDiagonal(Vector<T>.Build.Dense(Math.Min(matrix.RowCount, matrix.ColumnCount) - 1)), Throws.ArgumentException);
Assert.That(() => matrix.SetDiagonal(Vector<T>.Build.Dense(Math.Min(matrix.RowCount, matrix.ColumnCount) + 1)), Throws.ArgumentException);
}
[Theory]
@ -654,16 +654,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
m = matrix.Clone();
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, default(Matrix<T>)), Throws.InstanceOf<NullReferenceException>());
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>());
Assert.That(() => m.SetSubMatrix(-1, 1, 0, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(matrix.RowCount, 1, 0, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 0, 0, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, -1, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, matrix.ColumnCount, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => m.SetSubMatrix(0, 1, 0, 0, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
// Usually invalid, but not for SetSubMatrix (since size is explicitly provided)
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);
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, Matrix<T>.Build.Dense(1, 2)), Throws.Nothing);
Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, Matrix<T>.Build.Dense(2, 1)), Throws.Nothing);
}
}
}

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

@ -98,7 +98,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanInsertRow(Matrix<T> matrix)
{
var row = CreateVectorRandom(matrix.ColumnCount, 0);
var row = Vector<T>.Build.Random(matrix.ColumnCount, 0);
for (var position = 0; position < matrix.RowCount + 1; position++)
{
var result = matrix.InsertRow(position, row);
@ -125,16 +125,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => matrix.InsertRow(0, default(Vector<T>)), Throws.Exception);
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);
Assert.That(() => matrix.InsertRow(-1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertRow(0, Vector<T>.Build.Dense(matrix.ColumnCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertRow(0, Vector<T>.Build.Dense(matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory]
public void CanInsertColumn(Matrix<T> matrix)
{
var column = CreateVectorRandom(matrix.RowCount, 0);
var column = Vector<T>.Build.Random(matrix.RowCount, 0);
for (var position = 0; position < matrix.ColumnCount + 1; position++)
{
var result = matrix.InsertColumn(position, column);
@ -161,10 +161,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => matrix.InsertColumn(0, default(Vector<T>)), Throws.Exception);
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);
Assert.That(() => matrix.InsertColumn(-1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
Assert.That(() => matrix.InsertColumn(0, Vector<T>.Build.Dense(matrix.RowCount - 1)), Throws.ArgumentException);
Assert.That(() => matrix.InsertColumn(0, Vector<T>.Build.Dense(matrix.RowCount + 1)), Throws.ArgumentException);
}
[Theory]
@ -196,7 +196,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assume.That(left.RowCount, Is.EqualTo(right.RowCount));
// THEN
var result = CreateDenseZero(left.RowCount, left.ColumnCount + right.ColumnCount);
var result = Matrix<T>.Build.Dense(left.RowCount, left.ColumnCount + right.ColumnCount);
left.Append(right, result);
Assert.That(result.ColumnCount, Is.EqualTo(left.ColumnCount + right.ColumnCount));
@ -210,10 +210,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => left.Append(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
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);
Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
}
[Theory]
@ -245,7 +245,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assume.That(top.ColumnCount, Is.EqualTo(bottom.ColumnCount));
// THEN
var result = CreateDenseZero(top.RowCount + bottom.RowCount, top.ColumnCount);
var result = Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount, top.ColumnCount);
top.Stack(bottom, result);
Assert.That(result.RowCount, Is.EqualTo(top.RowCount + bottom.RowCount));
@ -259,10 +259,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => top.Stack(bottom, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
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);
Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount + 1, top.ColumnCount)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount - 1, top.ColumnCount)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount, top.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount, top.ColumnCount - 1)), Throws.ArgumentException);
}
[Theory]
@ -294,7 +294,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanDiagonalStackIntoResult(Matrix<T> left, Matrix<T> right)
{
var result = CreateDenseZero(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount);
var result = Matrix<T>.Build.Dense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount);
left.DiagonalStack(right, result);
Assert.That(result.RowCount, Is.EqualTo(left.RowCount + right.RowCount));
@ -316,10 +316,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
// Invalid
Assert.That(() => left.DiagonalStack(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
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);
Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
}
}
}

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

@ -28,9 +28,9 @@
// OTHER DEALINGS IN THE SOFTWARE.
// </copyright>
using System;
using MathNet.Numerics.LinearAlgebra;
using NUnit.Framework;
using System;
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
@ -38,31 +38,20 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public abstract partial class MatrixStructureTheory<T>
where T : struct, IEquatable<T>, IFormattable
{
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 readonly T Zero;
protected MatrixStructureTheory()
{
Zero = Matrix<T>.Build.Zero;
}
protected readonly T Zero = Matrix<T>.Build.Zero;
protected Matrix<T> CreateDenseFor(Matrix<T> m, int rows = -1, int columns = -1, int seed = 1)
{
return m.Storage.IsFullyMutable
? CreateDenseRandom(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount, seed)
: CreateDenseZero(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount);
? Matrix<T>.Build.Random(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount, seed)
: Matrix<T>.Build.Dense(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount);
}
protected Vector<T> CreateVectorFor(Matrix<T> m, int size, int seed = 1)
{
return m.Storage.IsFullyMutable
? CreateVectorRandom(size, seed)
: CreateVectorZero(size);
? Vector<T>.Build.Random(size, seed)
: Vector<T>.Build.Dense(size);
}
[Theory]
@ -126,11 +115,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Theory]
public void CanCopyTo(Matrix<T> matrix)
{
var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
matrix.CopyTo(dense);
Assert.That(dense, Is.EqualTo(matrix));
var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
matrix.CopyTo(sparse);
Assert.That(sparse, Is.EqualTo(matrix));
@ -138,8 +127,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
Assert.That(() => matrix.CopyTo(null), Throws.InstanceOf<ArgumentNullException>());
// bad arg
Assert.That(() => matrix.CopyTo(CreateDenseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.CopyTo(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
Assert.That(() => matrix.CopyTo(Matrix<T>.Build.Dense(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
Assert.That(() => matrix.CopyTo(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
}
[Theory]
@ -211,7 +200,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
public void CanCreateSameKind(Matrix<T> matrix)
{
var empty = Matrix<T>.Build.SameAs(matrix, 5, 6);
Assert.That(empty, Is.EqualTo(CreateDenseZero(5, 6)));
Assert.That(empty, Is.EqualTo(Matrix<T>.Build.Dense(5, 6)));
Assert.That(empty.Storage.IsDense, Is.EqualTo(matrix.Storage.IsDense));
Assert.That(() => Matrix<T>.Build.SameAs(matrix, 0, 2), Throws.InstanceOf<ArgumentOutOfRangeException>());
@ -222,7 +211,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test]
public void CanCreateDenseFromMultiDimArray()
{
T[,] array = CreateDenseRandom(4, 3, 0).ToArray();
T[,] array = Matrix<T>.Build.Random(4, 3, 0).ToArray();
var matrix = Matrix<T>.Build.DenseOfArray(array);
Assert.That(matrix.GetType().Name, Is.EqualTo("DenseMatrix"));
Assert.That(matrix.RowCount, Is.EqualTo(4));
@ -235,7 +224,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test]
public void CanCreateSparseFromMultiDimArray()
{
T[,] array = CreateDenseRandom(4, 3, 0).ToArray();
T[,] array = Matrix<T>.Build.Random(4, 3, 0).ToArray();
var matrix = Matrix<T>.Build.SparseOfArray(array);
Assert.That(matrix.GetType().Name, Is.EqualTo("SparseMatrix"));
Assert.That(matrix.RowCount, Is.EqualTo(4));
@ -250,9 +239,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
T[][] array = new[]
{
CreateVectorRandom(4, 0).ToArray(),
CreateVectorRandom(4, 1).ToArray(),
CreateVectorRandom(4, 3).ToArray()
Vector<T>.Build.Random(4, 0).ToArray(),
Vector<T>.Build.Random(4, 1).ToArray(),
Vector<T>.Build.Random(4, 3).ToArray()
};
var matrix = Matrix<T>.Build.DenseOfRows(3, 4, array);
Assert.That(matrix.GetType().Name, Is.EqualTo("DenseMatrix"));
@ -268,9 +257,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
T[][] array = new[]
{
CreateVectorRandom(4, 0).ToArray(),
CreateVectorRandom(4, 1).ToArray(),
CreateVectorRandom(4, 3).ToArray()
Vector<T>.Build.Random(4, 0).ToArray(),
Vector<T>.Build.Random(4, 1).ToArray(),
Vector<T>.Build.Random(4, 3).ToArray()
};
var matrix = Matrix<T>.Build.SparseOfRows(3, 4, array);
Assert.That(matrix.GetType().Name, Is.EqualTo("SparseMatrix"));
@ -286,9 +275,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
var columns = new[]
{
CreateVectorRandom(4, 0),
CreateVectorRandom(4, 1),
CreateVectorRandom(4, 3)
Vector<T>.Build.Random(4, 0),
Vector<T>.Build.Random(4, 1),
Vector<T>.Build.Random(4, 3)
};
var matrix = Matrix<T>.Build.DenseOfColumns(4, 3, columns);
Assert.That(matrix.GetType().Name, Is.EqualTo("DenseMatrix"));
@ -304,9 +293,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
var columns = new[]
{
CreateVectorRandom(4, 0),
CreateVectorRandom(4, 1),
CreateVectorRandom(4, 3)
Vector<T>.Build.Random(4, 0),
Vector<T>.Build.Random(4, 1),
Vector<T>.Build.Random(4, 3)
};
var matrix = Matrix<T>.Build.SparseOfColumns(4, 3, columns);
Assert.That(matrix.GetType().Name, Is.EqualTo("SparseMatrix"));
@ -322,9 +311,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
var rows = new[]
{
CreateVectorRandom(4, 0),
CreateVectorRandom(4, 1),
CreateVectorRandom(4, 3)
Vector<T>.Build.Random(4, 0),
Vector<T>.Build.Random(4, 1),
Vector<T>.Build.Random(4, 3)
};
var matrix = Matrix<T>.Build.DenseOfRows(3, 4, rows);
Assert.That(matrix.GetType().Name, Is.EqualTo("DenseMatrix"));
@ -340,9 +329,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
{
var rows = new[]
{
CreateVectorRandom(4, 0),
CreateVectorRandom(4, 1),
CreateVectorRandom(4, 3)
Vector<T>.Build.Random(4, 0),
Vector<T>.Build.Random(4, 1),
Vector<T>.Build.Random(4, 3)
};
var matrix = Matrix<T>.Build.SparseOfRows(3, 4, rows);
Assert.That(matrix.GetType().Name, Is.EqualTo("SparseMatrix"));
@ -356,7 +345,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
[Test]
public void CanEnumerateWithIndex()
{
var dense = CreateDenseRandom(2, 3, 0);
var dense = Matrix<T>.Build.Random(2, 3, 0);
int rowIdxSum = 0, colIdxSum = 0;
foreach (var value in dense.EnumerateIndexed())
{

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

@ -28,11 +28,7 @@
// OTHER DEALINGS IN THE SOFTWARE.
// </copyright>
using System.Linq;
using MathNet.Numerics.Distributions;
using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Single;
using MathNet.Numerics.Random;
using NUnit.Framework;
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
@ -42,53 +38,26 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
{
[Datapoints]
Matrix<float>[] _matrices = new Matrix<float>[]
{
DenseMatrix.OfArray(new[,] {{1f, 1f, 2f}, {1f, 1f, 2f}, {1f, 1f, 2f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f}, {0f, 1.1f, 2.2f}, {-4.4f, 5.5f, 6.6f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f, -4.4f}, {0f, 1.1f, 2.2f, 3.3f}, {1f, 2.1f, 6.2f, 4.3f}, {-4.4f, 5.5f, 6.6f, -7.7f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f}, {0f, 1.1f}, {-4.4f, 5.5f}}),
DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f}, {0f, 1.1f, 2.2f}}),
DenseMatrix.OfArray(new[,] {{1f, 2f, 3f}, {2f, 2f, 0f}, {3f, 0f, 3f}}),
SparseMatrix.OfArray(new[,] {{7f, 1f, 2f}, {1f, 1f, 2f}, {1f, 1f, 2f}}),
SparseMatrix.OfArray(new[,] {{7f, 1f, 2f}, {1f, 0f, 0f}, {-2f, 0f, 0f}}),
SparseMatrix.OfArray(new[,] {{-1.1f, 0f, 0f}, {0f, 1.1f, 2.2f}}),
new DiagonalMatrix(3, 3, new[] {1f, -2f, 1.5f}),
new DiagonalMatrix(3, 3, new[] {1f, 0f, -1.5f}),
new UserDefinedMatrix(new[,] {{0f, 1f, 2f}, {-1f, 7.7f, 0f}, {-2f, 0f, 0f}})
};
[Datapoints]
float[] _scalars = new[] {2f, -1.5f, 0f};
protected override Matrix<float> CreateDenseZero(int rows, int columns)
{
return new DenseMatrix(rows, columns);
}
Matrix<float>.Build.DenseOfArray(new[,] { { 1f, 1f, 2f }, { 1f, 1f, 2f }, { 1f, 1f, 2f } }),
Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f }, { 0f, 1.1f, 2.2f }, { -4.4f, 5.5f, 6.6f } }),
Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f, -4.4f }, { 0f, 1.1f, 2.2f, 3.3f }, { 1f, 2.1f, 6.2f, 4.3f }, { -4.4f, 5.5f, 6.6f, -7.7f } }),
Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f } }),
Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f }, { 0f, 1.1f }, { -4.4f, 5.5f } }),
Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f }, { 0f, 1.1f, 2.2f } }),
Matrix<float>.Build.DenseOfArray(new[,] { { 1f, 2f, 3f }, { 2f, 2f, 0f }, { 3f, 0f, 3f } }),
protected override Matrix<float> CreateDenseRandom(int rows, int columns, int seed)
{
var dist = new Normal(new MersenneTwister(seed));
return new DenseMatrix(rows, columns, dist.Samples().Select(d => (float) d).Take(rows*columns).ToArray());
}
Matrix<float>.Build.SparseOfArray(new[,] { { 7f, 1f, 2f }, { 1f, 1f, 2f }, { 1f, 1f, 2f } }),
Matrix<float>.Build.SparseOfArray(new[,] { { 7f, 1f, 2f }, { 1f, 0f, 0f }, { -2f, 0f, 0f } }),
Matrix<float>.Build.SparseOfArray(new[,] { { -1.1f, 0f, 0f }, { 0f, 1.1f, 2.2f } }),
protected override Matrix<float> CreateSparseZero(int rows, int columns)
{
return new SparseMatrix(rows, columns);
}
Matrix<float>.Build.Diagonal(3, 3, new[] { 1f, -2f, 1.5f }),
Matrix<float>.Build.Diagonal(3, 3, new[] { 1f, 0f, -1.5f }),
protected override Vector<float> CreateVectorZero(int size)
{
return new DenseVector(size);
}
new UserDefinedMatrix(new[,] { { 0f, 1f, 2f }, { -1f, 7.7f, 0f }, { -2f, 0f, 0f } })
};
protected override Vector<float> CreateVectorRandom(int size, int seed)
{
var dist = new Normal(new MersenneTwister(seed));
return new DenseVector(dist.Samples().Select(d => (float) d).Take(size).ToArray());
}
[Datapoints]
float[] _scalars = new[] { 2f, -1.5f, 0f };
}
}

Write Preview
Loading…
Cancel
Save