public void CanFactorizeRandomSymmetricMatrix(int order)
{
var matrixA = Matrix <Complex> .Build.RandomPositiveDefinite(order, 1);
MatrixHelpers.ForceConjugateSymmetric(matrixA);
var factorEvd = matrixA.Evd();
var eigenVectors = factorEvd.EigenVectors;
var d = factorEvd.D;
Assert.AreEqual(order, eigenVectors.RowCount);
Assert.AreEqual(order, eigenVectors.ColumnCount);
Assert.AreEqual(order, d.RowCount);
Assert.AreEqual(order, d.ColumnCount);
// Make sure the A = V*λ*VT
var matrix = eigenVectors * d * eigenVectors.ConjugateTranspose();
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
AssertHelpers.AlmostEqualRelative(matrix[i, j], matrixA[i, j], 7);
}
}
}
public void Question_8_10_BasicCases()
{
// Fill with same color
var image = new int[10, 10];
var expectedImage = (int[, ])image.Clone();
var point = new Point(5, 5);
var color = image[point.Row, point.Column];
Question_8_10.ColorFill(point, image, color);
TestHelpers.AssertMatricesEqual(expectedImage, image);
image = MatrixHelpers.CreateTwoDimensionalMatrix(3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1);
expectedImage = MatrixHelpers.CreateTwoDimensionalMatrix(3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2);
point = new Point(1, 1);
Question_8_10.ColorFill(point, image, 2);
TestHelpers.AssertMatricesEqual(expectedImage, image);
image = MatrixHelpers.CreateTwoDimensionalMatrix(3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1);
expectedImage = MatrixHelpers.CreateTwoDimensionalMatrix(3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2);
point = new Point(0, 0);
Question_8_10.ColorFill(point, image, 2);
TestHelpers.AssertMatricesEqual(expectedImage, image);
image = MatrixHelpers.CreateTwoDimensionalMatrix(3, 3, 1, 1, 1, 2, 2, 2, 3, 4, 5);
expectedImage = MatrixHelpers.CreateTwoDimensionalMatrix(3, 3, 1, 1, 1, 6, 6, 6, 3, 4, 5);
point = new Point(1, 1);
Question_8_10.ColorFill(point, image, 6);
TestHelpers.AssertMatricesEqual(expectedImage, image);
image = MatrixHelpers.CreateTwoDimensionalMatrix(3, 3, 1, 1, 1, 2, 2, 2, 3, 4, 5);
expectedImage = MatrixHelpers.CreateTwoDimensionalMatrix(3, 3, 1, 1, 1, 2, 2, 2, 3, 6, 5);
point = new Point(2, 1);
Question_8_10.ColorFill(point, image, 6);
TestHelpers.AssertMatricesEqual(expectedImage, image);
}
public void CanFactorizeRandomSymmetricMatrix([Values(1, 2, 5, 10)] int order)
{
var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
MatrixHelpers.ForceConjugateSymmetric(matrixA);
var factorEvd = matrixA.Evd();
var eigenVectors = factorEvd.EigenVectors;
var d = factorEvd.D;
Assert.AreEqual(order, eigenVectors.RowCount);
Assert.AreEqual(order, eigenVectors.ColumnCount);
Assert.AreEqual(order, d.RowCount);
Assert.AreEqual(order, d.ColumnCount);
// Make sure the A = V*λ*VT
var matrix = eigenVectors * d * eigenVectors.ConjugateTranspose();
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
AssertHelpers.AlmostEqualRelative(matrix[i, j], matrixA[i, j], 3);
}
}
}
public void SolveWithGaussianElimination_WithValidInput_ReturnsCorrecty()
{
// Arrange
double[,] M = new double[, ] // Example taken from https://en.wikipedia.org/wiki/Gaussian_elimination
{
{ 2, 1, -1, 8 },
{ -3, -1, 2, -11 },
{ -2, 1, 2, -3 }
};
double[] correctSolution = new double[]
{
2,
3,
-1
};
// Act
double[] actualSolution = MatrixHelpers.SolveWithGaussianElimination(ref M);
bool solutionIsCorrect =
(actualSolution[0] == correctSolution[0]) &&
(actualSolution[1] == correctSolution[1]) &&
(actualSolution[2] == correctSolution[2]);
//Assert
Assert.IsTrue(solutionIsCorrect);
}
public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
{
var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
MatrixHelpers.ForceConjugateSymmetric(matrixA);
var matrixACopy = matrixA.Clone();
var factorEvd = matrixA.Evd();
var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
var resultx = factorEvd.Solve(vectorb);
Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
var matrixBReconstruct = matrixA * resultx;
// Check the reconstruction.
for (var i = 0; i < vectorb.Count; i++)
{
Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, 1e-3f);
Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, 1e-3f);
}
// Make sure A didn't change.
for (var i = 0; i < matrixA.RowCount; i++)
{
for (var j = 0; j < matrixA.ColumnCount; j++)
{
Assert.AreEqual(matrixACopy[i, j], matrixA[i, j]);
}
}
}
public void CanFactorizeRandomSymmetricMatrix([Values(1, 2, 5, 10, 50)] int order)
{
var matrixA = Matrix <float> .Build.RandomPositiveDefinite(order, 1);
MatrixHelpers.ForceSymmetric(matrixA);
var factorEvd = matrixA.Evd();
var eigenVectors = factorEvd.EigenVectors;
var d = factorEvd.D;
Assert.AreEqual(order, eigenVectors.RowCount);
Assert.AreEqual(order, eigenVectors.ColumnCount);
Assert.AreEqual(order, d.RowCount);
Assert.AreEqual(order, d.ColumnCount);
// Make sure the A = V*λ*VT
var matrix = eigenVectors * d * eigenVectors.Transpose();
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], matrixA[i, j], 1e-3);
}
}
}
public void CanSolveForRandomMatrixAndSymmetricMatrix([Values(1, 2, 5, 10, 50, 100)] int order)
{
var A = new UserDefinedMatrix(Matrix <Complex32> .Build.RandomPositiveDefinite(order, 1).ToArray());
MatrixHelpers.ForceHermitian(A);
var ACopy = A.Clone();
var evd = A.Evd();
var B = new UserDefinedMatrix(Matrix <Complex32> .Build.Random(order, order, 1).ToArray());
var BCopy = B.Clone();
var X = evd.Solve(B);
// The solution X row dimension is equal to the column dimension of A
Assert.AreEqual(A.ColumnCount, X.RowCount);
// The solution X has the same number of columns as B
Assert.AreEqual(B.ColumnCount, X.ColumnCount);
var BReconstruct = A * X;
// Check the reconstruction.
AssertHelpers.AlmostEqual(B, BReconstruct, 1);
// Make sure A/B didn't change.
AssertHelpers.AlmostEqual(ACopy, A, 14);
AssertHelpers.AlmostEqual(BCopy, B, 14);
}
public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven([Values(1, 2, 5, 10, 50, 100)] int order)
{
var A = Matrix <double> .Build.RandomPositiveDefinite(order, 1);
MatrixHelpers.ForceSymmetric(A);
var ACopy = A.Clone();
var evd = A.Evd();
var b = Vector <double> .Build.Random(order, 2);
var bCopy = b.Clone();
var x = new DenseVector(order);
evd.Solve(b, x);
var bReconstruct = A * x;
// Check the reconstruction.
AssertHelpers.AlmostEqual(b, bReconstruct, 8);
// Make sure A/B didn't change.
AssertHelpers.AlmostEqual(ACopy, A, 14);
AssertHelpers.AlmostEqual(bCopy, b, 14);
}
public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven([Values(1, 2, 5, 10, 50, 100)] int order)
{
var A = Matrix <double> .Build.RandomPositiveDefinite(order, 1);
MatrixHelpers.ForceSymmetric(A);
var ACopy = A.Clone();
var evd = A.Evd();
var B = Matrix <double> .Build.Random(order, order, 2);
var BCopy = B.Clone();
var X = Matrix <double> .Build.Dense(order, order);
evd.Solve(B, X);
// The solution X row dimension is equal to the column dimension of A
Assert.AreEqual(A.ColumnCount, X.RowCount);
// The solution X has the same number of columns as B
Assert.AreEqual(B.ColumnCount, X.ColumnCount);
var BReconstruct = A * X;
// Check the reconstruction.
AssertHelpers.AlmostEqual(B, BReconstruct, 8);
// Make sure A/B didn't change.
AssertHelpers.AlmostEqual(ACopy, A, 14);
AssertHelpers.AlmostEqual(BCopy, B, 14);
}
public void CanFactorizeRandomSymmetricMatrix(int order)
{
var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
MatrixHelpers.ForceSymmetric(matrixA);
var factorEvd = matrixA.Evd();
var eigenVectors = factorEvd.EigenVectors;
var d = factorEvd.D;
Assert.AreEqual(order, eigenVectors.RowCount);
Assert.AreEqual(order, eigenVectors.ColumnCount);
Assert.AreEqual(order, d.RowCount);
Assert.AreEqual(order, d.ColumnCount);
// Make sure the A = V*λ*VT
var matrix = eigenVectors * d * eigenVectors.Transpose();
for (var i = 0; i < matrix.RowCount; i++)
{
for (var j = 0; j < matrix.ColumnCount; j++)
{
Assert.AreEqual(matrix[i, j], matrixA[i, j], 1.0e-10);
}
}
}
public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
{
var matrixA = Matrix <Complex> .Build.RandomPositiveDefinite(order, 1);
MatrixHelpers.ForceConjugateSymmetric(matrixA);
var matrixACopy = matrixA.Clone();
var factorEvd = matrixA.Evd();
var vectorb = Vector <Complex> .Build.Random(order, 1);
var resultx = factorEvd.Solve(vectorb);
Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
var matrixBReconstruct = matrixA * resultx;
// Check the reconstruction.
for (var i = 0; i < vectorb.Count; i++)
{
AssertHelpers.AlmostEqual(vectorb[i], matrixBReconstruct[i], 10);
}
// Make sure A didn't change.
for (var i = 0; i < matrixA.RowCount; i++)
{
for (var j = 0; j < matrixA.ColumnCount; j++)
{
Assert.AreEqual(matrixACopy[i, j], matrixA[i, j]);
}
}
}
public void SolveWithGaussianElimination_WithInvalidDimensionalMatrixAsInput_ThrowsArgumentException()
{
// Arrange
double[,] M = new double[1, 3];
// Act and assert
Assert.ThrowsException <ArgumentException>(() => MatrixHelpers.SolveWithGaussianElimination(ref M));
}
public void Question_1_7_EdgeCases()
{
var image = MatrixHelpers.CreateTwoDimensionalMatrix(1, 1, 'a');
var expected = MatrixHelpers.CreateTwoDimensionalMatrix(1, 1, 'a');
Question_1_7.Rotate(image);
TestHelpers.AssertMatricesEqual(expected, image, "1x1");
}
private void ValidateResult(int[,] expected, int[,] input)
{
var inputCopy = MatrixHelpers.CreateTwoDimensionalMatrix(input.GetLength(0), input.GetLength(1), input.Cast <int>().ToArray());
Question_1_8.PropogateZeros(input);
TestHelpers.AssertMatricesEqual(expected, input);
Question_1_8.PropogateZerosInPlace(inputCopy);
TestHelpers.AssertMatricesEqual(expected, inputCopy);
}
public void Question_1_8_EdgeCases()
{
// Zero in the middle
// 0
var matrix = MatrixHelpers.CreateTwoDimensionalMatrix(1, 1, 0);
var expected = MatrixHelpers.CreateTwoDimensionalMatrix(1, 1, 0);
this.ValidateResult(expected, matrix);
}
/// <summary>
/// Solves for the source panel strengths required to guarantee
/// tangential flow at the centre of each rectangular source panel.
/// </summary>
/// <param name="sourcePanels">
/// The array of source panels.
/// </param>
/// <param name="vPanels">
/// A vector representing the velocity vector of the panels (the
/// negative far-field flow velocity).
/// </param>
/// <returns>
/// An array whose each element corresponds to the required strength of
/// the source panel with that index.
/// </returns>
public static double[] SolveForSourcePanelStrengths(
UnitStrengthRectangularSourcePanel[] sourcePanels, Vector3 vPanels)
{
double[,] equationMatrix =
CreateEquationMatrix(sourcePanels, vPanels);
double[] sourcePanelStrengths =
MatrixHelpers.SolveWithGaussianElimination(ref equationMatrix);
return(sourcePanelStrengths);
}
public void MatrixRotate1CompleteTest1()
{
var actual = new[, ] {
{ 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }
};
var expected = new[, ] {
{ 7, 4, 1 }, { 8, 5, 2 }, { 9, 6, 3 }
};
MatrixRotate1Complete.Rotate(ref actual);
Assert.IsTrue(MatrixHelpers.Compare(actual, expected));
}
public void MatrixRotate1CompleteTest3()
{
var actual = new[, ] {
{ 1 }
};
var expected = new[, ] {
{ 1 }
};
MatrixRotate1Complete.Rotate(ref actual);
Assert.IsTrue(MatrixHelpers.Compare(actual, expected));
}
public void PaintFill1RecursiveCompleteTest2NoUpdate()
{
var actual = new[, ] {
{ 3, 0, 3, 3 }, { 0, 0, 0, 3 }, { 3, 3, 3, 3 }
};
var expected = new[, ] {
{ 3, 0, 3, 3 }, { 0, 0, 0, 3 }, { 3, 3, 3, 3 }
};
Assert.IsFalse(PaintFill1RecursiveComplete.PaintFill(actual, 1, 1, 0));
Assert.IsTrue(MatrixHelpers.Compare(actual, expected));
}
public void MatrixRotate1CompleteTest4()
{
var actual = new[, ] {
{ 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 }
};
var expected = new[, ] {
{ 13, 9, 5, 1 }, { 14, 10, 6, 2 }, { 15, 11, 7, 3 }, { 16, 12, 8, 4 }
};
MatrixRotate1Complete.Rotate(ref actual);
Assert.IsTrue(MatrixHelpers.Compare(actual, expected));
}
public void PaintFill1RecursiveCompleteTest3IrregularImage()
{
var actual = new[, ] {
{ 3, 0, 3, 3 }, { 0, 0, 0, 3 }, { 3, 3, 3, 3 }
};
var expected = new[, ] {
{ 3, -1, 3, 3 }, { -1, -1, -1, 3 }, { 3, 3, 3, 3 }
};
Assert.IsTrue(PaintFill1RecursiveComplete.PaintFill(actual, 1, 1, -1));
Assert.IsTrue(MatrixHelpers.Compare(actual, expected));
}
public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
{
var matrixA = Matrix <Complex32> .Build.RandomPositiveDefinite(order, 1);
MatrixHelpers.ForceConjugateSymmetric(matrixA);
var matrixACopy = matrixA.Clone();
var factorEvd = matrixA.Evd();
var matrixB = Matrix <Complex32> .Build.Random(order, order, 1);
var matrixBCopy = matrixB.Clone();
var matrixX = new DenseMatrix(order, order);
factorEvd.Solve(matrixB, matrixX);
// The solution X row dimension is equal to the column dimension of A
Assert.AreEqual(matrixA.ColumnCount, matrixX.RowCount);
// The solution X has the same number of columns as B
Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
var matrixBReconstruct = matrixA * matrixX;
// Check the reconstruction.
for (var i = 0; i < matrixB.RowCount; i++)
{
for (var j = 0; j < matrixB.ColumnCount; j++)
{
Assert.AreEqual(matrixB[i, j].Real, matrixBReconstruct[i, j].Real, 1e-2f);
Assert.AreEqual(matrixB[i, j].Imaginary, matrixBReconstruct[i, j].Imaginary, 1e-2f);
}
}
// Make sure A didn't change.
for (var i = 0; i < matrixA.RowCount; i++)
{
for (var j = 0; j < matrixA.ColumnCount; j++)
{
Assert.AreEqual(matrixACopy[i, j], matrixA[i, j]);
}
}
// Make sure B didn't change.
for (var i = 0; i < matrixB.RowCount; i++)
{
for (var j = 0; j < matrixB.ColumnCount; j++)
{
Assert.AreEqual(matrixBCopy[i, j], matrixB[i, j]);
}
}
}
/// <summary>
/// Gets a row vector from a matrix.
/// </summary>
///
public static T[] GetRow <T> (this T[][] m, int index, T[] result = null)
{
index = MatrixHelpers.index(index, m.Rows());
if (result == null)
{
return((T[])m[index].Clone());
}
else
{
m[index].CopyTo(result, 0);
return(result);
}
}
/// <summary>
/// Gets a row vector from a matrix.
/// </summary>
///
public static T[] GetRow <T> (this T[,] m, int index, T[] result = null)
{
if (result == null)
{
result = new T[m.GetLength(1)];
}
index = MatrixHelpers.index(index, m.Rows());
for (int i = 0; i < result.Length; i++)
{
result[i] = m[index, i];
}
return(result);
}
public void FindFirstRowOfNonZeroElementInColumn_WithAllNonZeroesInColumn_ReturnsZero()
{
// Arrange
double[,] M = new double[, ]
{
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 6, 9 }
};
// Act
int result = MatrixHelpers.FindFirstRowOfNonZeroElementInColumn(1, M);
// Assert
Assert.AreEqual(0, result);
}
public void FindFirstRowOfNonZeroElementInColumn_WithAllZeroesInColumnButStartingAtRowOne_ReturnsMinusOne()
{
// Arrange
double[,] M = new double[, ]
{
{ 1, 0, 3 },
{ 4, 0, 6 },
{ 7, 0, 9 }
};
// Act
int result = MatrixHelpers.FindFirstRowOfNonZeroElementInColumn(1, M, startAtRow: 1);
// Assert
Assert.AreEqual(-1, result);
}
public void FindFirstRowOfNonZeroElementInColumn_WithAllZeroesInColumnExceptAtRowOne_ReturnsOne()
{
// Arrange
double[,] M = new double[, ]
{
{ 1, 0, 3 },
{ 4, 1, 6 },
{ 7, 0, 9 }
};
// Act
int result = MatrixHelpers.FindFirstRowOfNonZeroElementInColumn(1, M);
// Assert
Assert.AreEqual(1, result);
}
public void FindFirstRowOfNonZeroElementInColumn_WithNonZeroInTheFirstButZeroesInLowerRowsOfTheColumn_ReturnsZero()
{
// Arrange
double[,] M = new double[, ]
{
{ 1, 2, 3 },
{ 4, 0, 6 },
{ 7, 0, 9 }
};
// Act
int result = MatrixHelpers.FindFirstRowOfNonZeroElementInColumn(1, M);
// Assert
Assert.AreEqual(0, result);
}
public FeedForwardLayer(ExecutionContext executionContext, FeedForwardLayerOptions options, ushort[] previousLayerDimensionality)
{
_options = options;
Dimensionality = options.Dimensionality;
_weightLength = MatrixHelpers.GetWeightCardinality(previousLayerDimensionality, options.Dimensionality);
NodeCount = MatrixHelpers.GetCardinality(options.Dimensionality);
_previousLayerNodeCount = MatrixHelpers.GetCardinality(previousLayerDimensionality);
_activation = (options.ActivationOptions ?? new ReluActivationOptions())
.Create();
_update = (options.UpdateOptions ?? new FeedForwardUpdateOptions())
.Create(executionContext);
CompileKernels(executionContext);
AllocateBuffers(executionContext, options);
SetForwardPassArgs();
SetBackwardPassArgs();
}
public void CanFactorizeRandomSymmetricMatrix([Values(1, 2, 5, 10, 50, 100)] int order)
{
var A = Matrix <double> .Build.RandomPositiveDefinite(order, 1);
MatrixHelpers.ForceSymmetric(A);
var factorEvd = A.Evd();
var V = factorEvd.EigenVectors;
var λ = factorEvd.D;
Assert.AreEqual(order, V.RowCount);
Assert.AreEqual(order, V.ColumnCount);
Assert.AreEqual(order, λ.RowCount);
Assert.AreEqual(order, λ.ColumnCount);
// Verify A = V*λ*VT
var matrix = V * λ * V.Transpose();
AssertHelpers.AlmostEqual(matrix, A, 10);
AssertHelpers.AlmostEqualRelative(matrix, A, 9);
}
