///<summary>Solves a system on linear equations, AX=B, where A is the factored matrixed.</summary>
///<param name="B">RHS side of the system.</param>
///<returns>the solution matrix, X.</returns>
///<exception cref="ArgumentNullException">B is null.</exception>
///<exception cref="SingularMatrixException">Ais singular.</exception>
///<exception cref="ArgumentException">The number of rows of A and B must be the same.</exception>
public ComplexDoubleMatrix Solve(IROComplexDoubleMatrix B)
{
if (B == null)
{
throw new System.ArgumentNullException("B cannot be null.");
}
Compute();
if (singular)
{
throw new SingularMatrixException();
}
else
{
if (B.Rows != order)
{
throw new System.ArgumentException("Matrix row dimensions must agree.");
}
#if MANAGED
// Copy right hand side with pivoting
int nx = B.Columns;
ComplexDoubleMatrix X = Pivot(B);
// Solve L*Y = B(piv,:)
for (int k = 0; k < order; k++)
{
for (int i = k + 1; i < order; i++)
{
for (int j = 0; j < nx; j++)
{
X.data[i][j] -= X.data[k][j] * factor[i][k];
}
}
}
// Solve U*X = Y;
for (int k = order - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X.data[k][j] /= factor[k][k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X.data[i][j] -= X.data[k][j] * factor[i][k];
}
}
}
return(X);
#else
Complex[] rhs = ComplexDoubleMatrix.ToLinearComplexArray(B);
Lapack.Getrs.Compute(Lapack.Transpose.NoTrans, order, B.Columns, factor, order, pivots, rhs, B.Rows);
ComplexDoubleMatrix ret = new ComplexDoubleMatrix(order, B.Columns);
ret.data = rhs;
return(ret);
#endif
}
}
///<summary>Solves a system on linear equations, AX=B, where A is the factored matrixed.</summary>
///<param name="B">RHS side of the system.</param>
///<returns>the solution matrix, X.</returns>
///<exception cref="ArgumentNullException">B is null.</exception>
///<exception cref="NotPositiveDefiniteException">A is not positive definite.</exception>
///<exception cref="ArgumentException">The number of rows of A and B must be the same.</exception>
public ComplexDoubleMatrix Solve(IROComplexDoubleMatrix B)
{
if (B == null)
{
throw new System.ArgumentNullException("B cannot be null.");
}
Compute();
if (!ispd)
{
throw new NotPositiveDefiniteException();
}
else
{
if (B.Rows != order)
{
throw new System.ArgumentException("Matrix row dimensions must agree.");
}
#if MANAGED
// Copy right hand side.
int cols = B.Columns;
var X = new ComplexDoubleMatrix(B);
for (int c = 0; c < cols; c++)
{
// Solve L*Y = B;
for (int i = 0; i < order; i++)
{
Complex sum = B[i, c];
for (int k = i - 1; k >= 0; k--)
{
sum -= l.data[i][k] * X.data[k][c];
}
X.data[i][c] = sum / l.data[i][i];
}
// Solve L'*X = Y;
for (int i = order - 1; i >= 0; i--)
{
Complex sum = X.data[i][c];
for (int k = i + 1; k < order; k++)
{
sum -= ComplexMath.Conjugate(l.data[k][i]) * X.data[k][c];
}
X.data[i][c] = sum / ComplexMath.Conjugate(l.data[i][i]);
}
}
return(X);
#else
Complex[] rhs = ComplexDoubleMatrix.ToLinearComplexArray(B);
Lapack.Potrs.Compute(Lapack.UpLo.Lower, order, B.Columns, l.data, order, rhs, B.Rows);
ComplexDoubleMatrix ret = new ComplexDoubleMatrix(order, B.Columns);
ret.data = rhs;
return(ret);
#endif
}
}
///<summary>Solves a system on linear equations, AX=B, where A is the factored matrixed.</summary>
///<param name="B">RHS side of the system.</param>
///<returns>the solution vector, X.</returns>
///<exception cref="ArgumentNullException">B is null.</exception>
///<exception cref="NotPositiveDefiniteException">A is not positive definite.</exception>
///<exception cref="ArgumentException">The number of rows of A and the length of B must be the same.</exception>
public ComplexDoubleVector Solve(IROComplexDoubleVector B)
{
if (B == null)
{
throw new System.ArgumentNullException("B cannot be null.");
}
Compute();
if (!ispd)
{
throw new NotPositiveDefiniteException();
}
else
{
if (B.Length != order)
{
throw new System.ArgumentException("The length of B must be the same as the order of the matrix.");
}
#if MANAGED
// Copy right hand side.
var X = new ComplexDoubleVector(B);
// Solve L*Y = B;
for (int i = 0; i < order; i++)
{
Complex sum = B[i];
for (int k = i - 1; k >= 0; k--)
{
sum -= l.data[i][k] * X.data[k];
}
X.data[i] = sum / l.data[i][i];
}
// Solve L'*X = Y;
for (int i = order - 1; i >= 0; i--)
{
Complex sum = X.data[i];
for (int k = i + 1; k < order; k++)
{
sum -= ComplexMath.Conjugate(l.data[k][i]) * X.data[k];
}
X.data[i] = sum / ComplexMath.Conjugate(l.data[i][i]);
}
return(X);
#else
Complex[] rhs = ComplexDoubleMatrix.ToLinearComplexArray(B);
Lapack.Potrs.Compute(Lapack.UpLo.Lower, order, 1, l.data, order, rhs, B.Length);
ComplexDoubleVector ret = new ComplexDoubleVector(order, B.Length);
ret.data = rhs;
return(ret);
#endif
}
}
///<summary>Solves a system on linear equations, AX=B, where A is the factored matrixed.</summary>
///<param name="B">RHS side of the system.</param>
///<returns>the solution vector, X.</returns>
///<exception cref="ArgumentNullException">B is null.</exception>
///<exception cref="SingularMatrixException">A is singular.</exception>
///<exception cref="ArgumentException">The number of rows of A and the length of B must be the same.</exception>
public ComplexDoubleVector Solve(IROComplexDoubleVector B)
{
if (B == null)
{
throw new System.ArgumentNullException("B cannot be null.");
}
Compute();
if (singular)
{
throw new SingularMatrixException();
}
else
{
if (B.Length != order)
{
throw new System.ArgumentException("The length of B must be the same as the order of the matrix.");
}
#if MANAGED
// Copy right hand side with pivoting
ComplexDoubleVector X = Pivot(B);
// Solve L*Y = B(piv,:)
for (int k = 0; k < order; k++)
{
for (int i = k + 1; i < order; i++)
{
X[i] -= X[k] * factor[i][k];
}
}
// Solve U*X = Y;
for (int k = order - 1; k >= 0; k--)
{
X[k] /= factor[k][k];
for (int i = 0; i < k; i++)
{
X[i] -= X[k] * factor[i][k];
}
}
return(X);
#else
Complex[] rhs = ComplexDoubleMatrix.ToLinearComplexArray(B);
Lapack.Getrs.Compute(Lapack.Transpose.NoTrans, order, 1, factor, order, pivots, rhs, rhs.Length);
return(new ComplexDoubleVector(rhs));
#endif
}
}
/// <summary>Performs the QR factorization.</summary>
protected override void InternalCompute()
{
int m = matrix.Rows;
int n = matrix.Columns;
#if MANAGED
int minmn = m < n ? m : n;
r_ = new ComplexDoubleMatrix(matrix); // create a copy
ComplexDoubleVector[] u = new ComplexDoubleVector[minmn];
for (int i = 0; i < minmn; i++)
{
u[i] = Householder.GenerateColumn(r_, i, m - 1, i);
Householder.UA(u[i], r_, i, m - 1, i + 1, n - 1);
}
q_ = ComplexDoubleMatrix.CreateIdentity(m);
for (int i = minmn - 1; i >= 0; i--)
{
Householder.UA(u[i], q_, i, m - 1, i, m - 1);
}
#else
qr = ComplexDoubleMatrix.ToLinearComplexArray(matrix);
jpvt = new int[n];
jpvt[0] = 1;
Lapack.Geqp3.Compute(m, n, qr, m, jpvt, out tau);
r_ = new ComplexDoubleMatrix(m, n);
// Populate R
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i <= j)
{
r_.data[j * m + i] = qr[(jpvt[j] - 1) * m + i];
}
else
{
r_.data[j * m + i] = Complex.Zero;
}
}
}
q_ = new ComplexDoubleMatrix(m, m);
for (int i = 0; i < m; i++)
{
for (int j = 0; j < m; j++)
{
if (j < n)
{
q_.data[j * m + i] = qr[j * m + i];
}
else
{
q_.data[j * m + i] = Complex.Zero;
}
}
}
if (m < n)
{
Lapack.Ungqr.Compute(m, m, m, q_.data, m, tau);
}
else
{
Lapack.Ungqr.Compute(m, m, n, q_.data, m, tau);
}
#endif
for (int i = 0; i < m; i++)
{
if (q_[i, i] == 0)
{
isFullRank = false;
}
}
}
