| public Solve ( double value ) : ].double[ | ||
| value | double | Right-hand-side matrix with as many rows as |
| return | ].double[ | |
public void QrDecompositionConstructorTest()
{
double[,] value =
{
{ 2, -1, 0 },
{ -1, 2, -1 },
{ 0, -1, 2 }
};
QrDecomposition target = new QrDecomposition(value);
// Decomposition Identity
var Q = target.OrthogonalFactor;
var QQt = Q.Multiply(Q.Transpose());
Assert.IsTrue(Matrix.IsEqual(QQt, Matrix.Identity(3), 0.0000001));
// Linear system solving
double[,] B = Matrix.ColumnVector(new double[] { 1, 2, 3 });
double[,] expected = Matrix.ColumnVector(new double[] { 2.5, 4.0, 3.5 });
double[,] actual = target.Solve(B);
Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0000000000001));
}
public void InverseTestNaN()
{
int n = 5;
var I = Matrix.Identity(n);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
double[,] value = Matrix.Magic(n);
value[i, j] = double.NaN;
var target = new QrDecomposition(value);
var solution = target.Solve(I);
var inverse = target.Inverse();
Assert.IsTrue(Matrix.IsEqual(solution, inverse));
}
}
}
public void SolveTest2()
{
// Example from Lecture notes for MATHS 370: Advanced Numerical Methods
// http://www.math.auckland.ac.nz/~sharp/370/qr-solving.pdf
double[,] value =
{
{ 1, 0, 0 },
{ 1, 7, 49 },
{ 1, 14, 196 },
{ 1, 21, 441 },
{ 1, 28, 784 },
{ 1, 35, 1225 },
};
// Matrices
{
double[,] b =
{
{ 4 },
{ 1 },
{ 0 },
{ 0 },
{ 2 },
{ 5 },
};
double[,] expected =
{
{ 3.9286 },
{ -0.5031 },
{ 0.0153 },
};
QrDecomposition target = new QrDecomposition(value);
double[,] actual = target.Solve(b);
Assert.IsTrue(Matrix.IsEqual(expected, actual, 1e-4));
}
// Vectors
{
double[] b = { 4, 1, 0, 0, 2, 5 };
double[] expected = { 3.9286, -0.5031, 0.0153 };
QrDecomposition target = new QrDecomposition(value);
double[] actual = target.Solve(b);
Assert.IsTrue(Matrix.IsEqual(expected, actual, 1e-4));
}
}
public void SolveTest()
{
double[,] value =
{
{ 2, -1, 0 },
{ -1, 2, -1 },
{ 0, -1, 2 }
};
double[] b = { 1, 2, 3 };
double[] expected = { 2.5000, 4.0000, 3.5000 };
QrDecomposition target = new QrDecomposition(value);
double[] actual = target.Solve(b);
Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0000000000001));
}
public void SolveTest3()
{
double[][] value =
{
new double[] { 41.9, 29.1, 1 },
new double[] { 43.4, 29.3, 1 },
new double[] { 43.9, 29.5, 0 },
new double[] { 44.5, 29.7, 0 },
new double[] { 47.3, 29.9, 0 },
new double[] { 47.5, 30.3, 0 },
new double[] { 47.9, 30.5, 0 },
new double[] { 50.2, 30.7, 0 },
new double[] { 52.8, 30.8, 0 },
new double[] { 53.2, 30.9, 0 },
new double[] { 56.7, 31.5, 0 },
new double[] { 57.0, 31.7, 0 },
new double[] { 63.5, 31.9, 0 },
new double[] { 65.3, 32.0, 0 },
new double[] { 71.1, 32.1, 0 },
new double[] { 77.0, 32.5, 0 },
new double[] { 77.8, 32.9, 0 }
};
double[][] b =
{
new double[] { 251.3 },
new double[] { 251.3 },
new double[] { 248.3 },
new double[] { 267.5 },
new double[] { 273.0 },
new double[] { 276.5 },
new double[] { 270.3 },
new double[] { 274.9 },
new double[] { 285.0 },
new double[] { 290.0 },
new double[] { 297.0 },
new double[] { 302.5 },
new double[] { 304.5 },
new double[] { 309.3 },
new double[] { 321.7 },
new double[] { 330.7 },
new double[] { 349.0 }
};
double[][] expected =
{
new double[] { 1.7315235669547167 },
new double[] { 6.25142110500275 },
new double[] { -5.0909763966987178 },
};
var target = new JaggedQrDecomposition(value);
double[][] actual = target.Solve(b);
Assert.IsTrue(Matrix.IsEqual(expected, actual, atol: 1e-4));
var reconstruct = value.Dot(expected);
Assert.IsTrue(Matrix.IsEqual(reconstruct, b, rtol: 1e-1));
double[] b2 = b.GetColumn(0);
double[] expected2 = expected.GetColumn(0);
var target2 = new JaggedQrDecomposition(value);
double[] actual2 = target2.Solve(b2);
Assert.IsTrue(Matrix.IsEqual(expected2, actual2, atol: 1e-4));
var targetMat = new QrDecomposition(value.ToMatrix());
double[,] actualMat = targetMat.Solve(b.ToMatrix());
Assert.IsTrue(Matrix.IsEqual(expected, actualMat, atol: 1e-4));
var reconstructMat = value.ToMatrix().Dot(expected);
Assert.IsTrue(Matrix.IsEqual(reconstruct, b, rtol: 1e-1));
var targetMat2 = new QrDecomposition(value.ToMatrix());
double[] actualMat2 = targetMat2.Solve(b2);
Assert.IsTrue(Matrix.IsEqual(expected2, actualMat2, atol: 1e-4));
}
