/// <summary>
/// Solves a system of linear equations, <b>Ax = b</b>, with A QR factorized.
/// </summary>
/// <param name="input">The right hand side vector, <b>b</b>.</param>
/// <param name="result">The left hand side <see cref="Matrix{T}"/>, <b>x</b>.</param>
public override void Solve(Vector <double> input, Vector <double> result)
{
// Ax=b where A is an m x n matrix
// Check that b is a column vector with m entries
if (Q.RowCount != input.Count)
{
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
// Check that x is a column vector with n entries
if (Q.ColumnCount != result.Count)
{
throw Matrix.DimensionsDontMatch <ArgumentException>(Q, result);
}
var inputCopy = input.Clone();
// Compute Y = transpose(Q)*B
var column = new double[Q.RowCount];
for (var k = 0; k < Q.RowCount; k++)
{
column[k] = inputCopy[k];
}
for (var i = 0; i < Q.ColumnCount; i++)
{
double s = 0;
for (var k = 0; k < Q.RowCount; k++)
{
s += Q.At(k, i) * column[k];
}
inputCopy[i] = s;
}
// Solve R*X = Y;
for (var k = Q.ColumnCount - 1; k >= 0; k--)
{
inputCopy[k] /= FullR.At(k, k);
for (var i = 0; i < k; i++)
{
inputCopy[i] -= inputCopy[k] * FullR.At(i, k);
}
}
for (var i = 0; i < FullR.ColumnCount; i++)
{
result[i] = inputCopy[i];
}
}
/// <summary>
/// Solves a system of linear equations, <b>Ax = b</b>, with A QR factorized.
/// </summary>
/// <param name="input">The right hand side vector, <b>b</b>.</param>
/// <param name="result">The left hand side <see cref="Matrix{T}"/>, <b>x</b>.</param>
public override void Solve(Vector <Complex32> input, Vector <Complex32> result)
{
// Ax=b where A is an m x n matrix
// Check that b is a column vector with m entries
if (FullR.RowCount != input.Count)
{
throw new ArgumentException("All vectors must have the same dimensionality.");
}
// Check that x is a column vector with n entries
if (FullR.ColumnCount != result.Count)
{
throw Matrix.DimensionsDontMatch <ArgumentException>(FullR, result);
}
var inputCopy = input.Clone();
// Compute Y = transpose(Q)*B
var column = new Complex32[FullR.RowCount];
for (var k = 0; k < FullR.RowCount; k++)
{
column[k] = inputCopy[k];
}
for (var i = 0; i < FullR.RowCount; i++)
{
var s = Complex32.Zero;
for (var k = 0; k < FullR.RowCount; k++)
{
s += Q.At(k, i).Conjugate() * column[k];
}
inputCopy[i] = s;
}
// Solve R*X = Y;
for (var k = FullR.ColumnCount - 1; k >= 0; k--)
{
inputCopy[k] /= FullR.At(k, k);
for (var i = 0; i < k; i++)
{
inputCopy[i] -= inputCopy[k] * FullR.At(i, k);
}
}
for (var i = 0; i < FullR.ColumnCount; i++)
{
result[i] = inputCopy[i];
}
}
/// <summary>
/// Solves a system of linear equations, <b>AX = B</b>, with A QR factorized.
/// </summary>
/// <param name="input">The right hand side <see cref="Matrix{T}"/>, <b>B</b>.</param>
/// <param name="result">The left hand side <see cref="Matrix{T}"/>, <b>X</b>.</param>
public override void Solve(Matrix <double> input, Matrix <double> result)
{
// The solution X should have the same number of columns as B
if (input.ColumnCount != result.ColumnCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension);
}
// The dimension compatibility conditions for X = A\B require the two matrices A and B to have the same number of rows
if (Q.RowCount != input.RowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension);
}
// The solution X row dimension is equal to the column dimension of A
if (Q.ColumnCount != result.RowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension);
}
var inputCopy = input.Clone();
// Compute Y = transpose(Q)*B
var column = new double[Q.RowCount];
for (var j = 0; j < input.ColumnCount; j++)
{
for (var k = 0; k < Q.RowCount; k++)
{
column[k] = inputCopy.At(k, j);
}
for (var i = 0; i < Q.ColumnCount; i++)
{
double s = 0;
for (var k = 0; k < Q.RowCount; k++)
{
s += Q.At(k, i) * column[k];
}
inputCopy.At(i, j, s);
}
}
// Solve R*X = Y;
for (var k = Q.ColumnCount - 1; k >= 0; k--)
{
for (var j = 0; j < input.ColumnCount; j++)
{
inputCopy.At(k, j, inputCopy.At(k, j) / FullR.At(k, k));
}
for (var i = 0; i < k; i++)
{
for (var j = 0; j < input.ColumnCount; j++)
{
inputCopy.At(i, j, inputCopy.At(i, j) - (inputCopy.At(k, j) * FullR.At(i, k)));
}
}
}
for (var i = 0; i < FullR.ColumnCount; i++)
{
for (var j = 0; j < input.ColumnCount; j++)
{
result.At(i, j, inputCopy.At(i, j));
}
}
}
/// <summary>
/// Solves a system of linear equations, <b>AX = B</b>, with A QR factorized.
/// </summary>
/// <param name="input">The right hand side <see cref="Matrix{T}"/>, <b>B</b>.</param>
/// <param name="result">The left hand side <see cref="Matrix{T}"/>, <b>X</b>.</param>
public override void Solve(Matrix <Complex32> input, Matrix <Complex32> result)
{
// The solution X should have the same number of columns as B
if (input.ColumnCount != result.ColumnCount)
{
throw new ArgumentException("Matrix column dimensions must agree.");
}
// The dimension compatibility conditions for X = A\B require the two matrices A and B to have the same number of rows
if (FullR.RowCount != input.RowCount)
{
throw new ArgumentException("Matrix row dimensions must agree.");
}
// The solution X row dimension is equal to the column dimension of A
if (FullR.ColumnCount != result.RowCount)
{
throw new ArgumentException("Matrix column dimensions must agree.");
}
var inputCopy = input.Clone();
// Compute Y = transpose(Q)*B
var column = new Complex32[FullR.RowCount];
for (var j = 0; j < input.ColumnCount; j++)
{
for (var k = 0; k < FullR.RowCount; k++)
{
column[k] = inputCopy.At(k, j);
}
for (var i = 0; i < FullR.RowCount; i++)
{
var s = Complex32.Zero;
for (var k = 0; k < FullR.RowCount; k++)
{
s += Q.At(k, i).Conjugate() * column[k];
}
inputCopy.At(i, j, s);
}
}
// Solve R*X = Y;
for (var k = FullR.ColumnCount - 1; k >= 0; k--)
{
for (var j = 0; j < input.ColumnCount; j++)
{
inputCopy.At(k, j, inputCopy.At(k, j) / FullR.At(k, k));
}
for (var i = 0; i < k; i++)
{
for (var j = 0; j < input.ColumnCount; j++)
{
inputCopy.At(i, j, inputCopy.At(i, j) - (inputCopy.At(k, j) * FullR.At(i, k)));
}
}
}
for (var i = 0; i < FullR.ColumnCount; i++)
{
for (var j = 0; j < inputCopy.ColumnCount; j++)
{
result.At(i, j, inputCopy.At(i, j));
}
}
}
