/// <summary>
/// Initializes a new instance of the <see cref="UserQR"/> class. This object will compute the
/// QR factorization when the constructor is called and cache it's factorization.
/// </summary>
/// <param name="matrix">The matrix to factor.</param>
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
public UserQR(Matrix <double> matrix)
{
if (matrix == null)
{
throw new ArgumentNullException("matrix");
}
if (matrix.RowCount < matrix.ColumnCount)
{
throw Matrix.DimensionsDontMatch <ArgumentException>(matrix);
}
MatrixR = matrix.Clone();
MatrixQ = matrix.CreateMatrix(matrix.RowCount, matrix.RowCount);
for (var i = 0; i < matrix.RowCount; i++)
{
MatrixQ.At(i, i, 1.0);
}
var minmn = Math.Min(matrix.RowCount, matrix.ColumnCount);
var u = new double[minmn][];
for (var i = 0; i < minmn; i++)
{
u[i] = GenerateColumn(MatrixR, i, i);
ComputeQR(u[i], MatrixR, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
}
for (var i = minmn - 1; i >= 0; i--)
{
ComputeQR(u[i], MatrixQ, i, matrix.RowCount, i, matrix.RowCount, Control.NumberOfParallelWorkerThreads);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an unitary matrix
/// using the modified Gram-Schmidt method.
/// </summary>
/// <param name="matrix">The matrix to factor.</param>
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">If <paramref name="matrix"/> row count is less then column count</exception>
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is rank deficient</exception>
public UserGramSchmidt(Matrix <Complex32> matrix)
{
if (matrix == null)
{
throw new ArgumentNullException("matrix");
}
if (matrix.RowCount < matrix.ColumnCount)
{
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
}
MatrixQ = matrix.Clone();
MatrixR = matrix.CreateMatrix(matrix.ColumnCount, matrix.ColumnCount);
for (var k = 0; k < MatrixQ.ColumnCount; k++)
{
var norm = MatrixQ.Column(k).Norm(2).Real;
if (norm == 0.0f)
{
throw new ArgumentException(Resources.ArgumentMatrixNotRankDeficient);
}
MatrixR.At(k, k, norm);
for (var i = 0; i < MatrixQ.RowCount; i++)
{
MatrixQ.At(i, k, MatrixQ.At(i, k) / norm);
}
for (var j = k + 1; j < MatrixQ.ColumnCount; j++)
{
var dot = Complex32.Zero;
for (int i = 0; i < MatrixQ.RowCount; i++)
{
dot += MatrixQ.Column(k)[i].Conjugate() * MatrixQ.Column(j)[i];
}
MatrixR.At(k, j, dot);
for (var i = 0; i < MatrixQ.RowCount; i++)
{
var value = MatrixQ.At(i, j) - (MatrixQ.At(i, k) * dot);
MatrixQ.At(i, j, value);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an orthogonal matrix
/// using the modified Gram-Schmidt method.
/// </summary>
/// <param name="matrix">The matrix to factor.</param>
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">If <paramref name="matrix"/> row count is less then column count</exception>
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is rank deficient</exception>
public UserGramSchmidt(Matrix <float> matrix)
{
if (matrix == null)
{
throw new ArgumentNullException("matrix");
}
if (matrix.RowCount < matrix.ColumnCount)
{
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
}
MatrixQ = matrix.Clone();
MatrixR = matrix.CreateMatrix(matrix.ColumnCount, matrix.ColumnCount);
for (var k = 0; k < MatrixQ.ColumnCount; k++)
{
var norm = MatrixQ.Column(k).Norm(2);
if (norm == 0.0)
{
throw new ArgumentException(Resources.ArgumentMatrixNotRankDeficient);
}
MatrixR.At(k, k, norm);
for (var i = 0; i < MatrixQ.RowCount; i++)
{
MatrixQ.At(i, k, MatrixQ.At(i, k) / norm);
}
for (var j = k + 1; j < MatrixQ.ColumnCount; j++)
{
var dot = MatrixQ.Column(k).DotProduct(MatrixQ.Column(j));
MatrixR.At(k, j, dot);
for (var i = 0; i < MatrixQ.RowCount; i++)
{
var value = MatrixQ.At(i, j) - (MatrixQ.At(i, k) * dot);
MatrixQ.At(i, j, value);
}
}
}
}
/// <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)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
// Ax=b where A is an m x n matrix
// Check that b is a column vector with m entries
if (MatrixR.RowCount != input.Count)
{
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
// Check that x is a column vector with n entries
if (MatrixR.ColumnCount != result.Count)
{
throw Matrix.DimensionsDontMatch <ArgumentException>(MatrixR, result);
}
var inputCopy = input.Clone();
// Compute Y = transpose(Q)*B
var column = new double[MatrixR.RowCount];
for (var k = 0; k < MatrixR.RowCount; k++)
{
column[k] = inputCopy[k];
}
for (var i = 0; i < MatrixR.RowCount; i++)
{
double s = 0;
for (var k = 0; k < MatrixR.RowCount; k++)
{
s += MatrixQ.At(k, i) * column[k];
}
inputCopy[i] = s;
}
// Solve R*X = Y;
for (var k = MatrixR.ColumnCount - 1; k >= 0; k--)
{
inputCopy[k] /= MatrixR.At(k, k);
for (var i = 0; i < k; i++)
{
inputCopy[i] -= inputCopy[k] * MatrixR.At(i, k);
}
}
for (var i = 0; i < MatrixR.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)
{
// Check for proper arguments.
if (input == null)
{
throw new ArgumentNullException("input");
}
if (result == null)
{
throw new ArgumentNullException("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 (MatrixR.RowCount != input.RowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension);
}
// The solution X row dimension is equal to the column dimension of A
if (MatrixR.ColumnCount != result.RowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension);
}
var inputCopy = input.Clone();
// Compute Y = transpose(Q)*B
var column = new double[MatrixR.RowCount];
for (var j = 0; j < input.ColumnCount; j++)
{
for (var k = 0; k < MatrixR.RowCount; k++)
{
column[k] = inputCopy.At(k, j);
}
for (var i = 0; i < MatrixR.RowCount; i++)
{
double s = 0;
for (var k = 0; k < MatrixR.RowCount; k++)
{
s += MatrixQ.At(k, i) * column[k];
}
inputCopy.At(i, j, s);
}
}
// Solve R*X = Y;
for (var k = MatrixR.ColumnCount - 1; k >= 0; k--)
{
for (var j = 0; j < input.ColumnCount; j++)
{
inputCopy.At(k, j, inputCopy.At(k, j) / MatrixR.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) * MatrixR.At(i, k)));
}
}
}
for (var i = 0; i < MatrixR.ColumnCount; i++)
{
for (var j = 0; j < inputCopy.ColumnCount; j++)
{
result.At(i, j, inputCopy.At(i, j));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UserQR"/> class. This object will compute the
/// QR factorization when the constructor is called and cache it's factorization.
/// </summary>
/// <param name="matrix">The matrix to factor.</param>
/// <param name="method">The QR factorization method to use.</param>
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
public UserQR(Matrix <Complex32> matrix, QRMethod method = QRMethod.Full)
{
if (matrix == null)
{
throw new ArgumentNullException("matrix");
}
if (matrix.RowCount < matrix.ColumnCount)
{
throw Matrix.DimensionsDontMatch <ArgumentException>(matrix);
}
QrMethod = method;
var minmn = Math.Min(matrix.RowCount, matrix.ColumnCount);
var u = new Complex32[minmn][];
if (method == QRMethod.Full)
{
MatrixR = matrix.Clone();
MatrixQ = matrix.CreateMatrix(matrix.RowCount, matrix.RowCount);
for (var i = 0; i < matrix.RowCount; i++)
{
MatrixQ.At(i, i, 1.0f);
}
for (var i = 0; i < minmn; i++)
{
u[i] = GenerateColumn(MatrixR, i, i);
ComputeQR(u[i], MatrixR, i, matrix.RowCount, i + 1, matrix.ColumnCount,
Control.NumberOfParallelWorkerThreads);
}
for (var i = minmn - 1; i >= 0; i--)
{
ComputeQR(u[i], MatrixQ, i, matrix.RowCount, i, matrix.RowCount,
Control.NumberOfParallelWorkerThreads);
}
}
else
{
MatrixR = matrix.CreateMatrix(matrix.ColumnCount, matrix.ColumnCount);
MatrixQ = matrix.Clone();
for (var i = 0; i < minmn; i++)
{
u[i] = GenerateColumn(MatrixQ, i, i);
ComputeQR(u[i], MatrixQ, i, matrix.RowCount, i + 1, matrix.ColumnCount,
Control.NumberOfParallelWorkerThreads);
}
MatrixR = MatrixQ.SubMatrix(0, matrix.ColumnCount, 0, matrix.ColumnCount);
MatrixQ.Clear();
for (var i = 0; i < matrix.ColumnCount; i++)
{
MatrixQ.At(i, i, 1.0f);
}
for (var i = minmn - 1; i >= 0; i--)
{
ComputeQR(u[i], MatrixQ, i, matrix.RowCount, i, matrix.ColumnCount,
Control.NumberOfParallelWorkerThreads);
}
}
}
