public IMatrix <double> GetSolution(IROMatrix <double> B)
{
var result = new JaggedArrayMatrix(m, B.ColumnCount);
Solve(B, result);
return(result);
}
/** Return the upper triangular factor
* @return R
*/
public JaggedArrayMatrix GetR()
{
var X = new JaggedArrayMatrix(n, n);
double[][] R = X.Array;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (i < j)
{
R[i][j] = QR[i][j];
}
else if (i == j)
{
R[i][j] = Rdiag[i];
}
else
{
R[i][j] = 0.0;
}
}
}
return(X);
}
/** Generate and return the (economy-sized) orthogonal factor
* @return Q
*/
public JaggedArrayMatrix GetQ()
{
var X = new JaggedArrayMatrix(m, n);
double[][] Q = X.Array;
for (int k = n - 1; k >= 0; k--)
{
for (int i = 0; i < m; i++)
{
Q[i][k] = 0.0;
}
Q[k][k] = 1.0;
for (int j = k; j < n; j++)
{
if (QR[k][k] != 0)
{
double s = 0.0;
for (int i = k; i < m; i++)
{
s += QR[i][k] * Q[i][j];
}
s = -s / QR[k][k];
for (int i = k; i < m; i++)
{
Q[i][j] += s * QR[i][k];
}
}
}
}
return(X);
}
/** Return the Householder vectors
* @return Lower trapezoidal matrix whose columns define the reflections
*/
public JaggedArrayMatrix GetH()
{
var X = new JaggedArrayMatrix(m, n);
double[][] H = X.Array;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i >= j)
{
H[i][j] = QR[i][j];
}
else
{
H[i][j] = 0.0;
}
}
}
return(X);
}
/** Least squares solution of A*X = B
* @param B A Matrix with as many rows as A and any number of columns.
* @return X that minimizes the two norm of Q*R*X-B.
* @exception IllegalArgumentException Matrix row dimensions must agree.
* @exception RuntimeException Matrix is rank deficient.
*/
public void Solve(IROMatrix <double> B, IMatrix <double> result)
{
if (B.RowCount != m)
{
throw new ArgumentException("Matrix row dimensions must agree.");
}
if (!IsFullRank())
{
throw new Exception("Matrix is rank deficient.");
}
// Copy right hand side
int nx = B.ColumnCount;
double[][] X;
if (_solveMatrixWorkspace != null && _solveMatrixWorkspace.RowCount == B.RowCount && _solveMatrixWorkspace.ColumnCount == B.ColumnCount)
{
X = _solveMatrixWorkspace.Array;
MatrixMath.Copy(B, _solveMatrixWorkspace);
}
else
{
X = JaggedArrayMath.GetMatrixCopy(B);
_solveMatrixWorkspace = new JaggedArrayMatrix(X, B.RowCount, B.ColumnCount);
}
// Compute Y = transpose(Q)*B
for (int k = 0; k < n; k++)
{
for (int j = 0; j < nx; j++)
{
double s = 0.0;
for (int i = k; i < m; i++)
{
s += QR[i][k] * X[i][j];
}
s = -s / QR[k][k];
for (int i = k; i < m; i++)
{
X[i][j] += s * QR[i][k];
}
}
}
// Solve R*X = Y;
for (int k = n - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k][j] /= Rdiag[k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * QR[i][k];
}
}
}
MatrixMath.Submatrix(_solveMatrixWorkspace, result, 0, 0);
}
public static void CalculatePRESS(
IROMatrix matrixX,
IROMatrix xLoads,
IROMatrix yLoads,
IROMatrix xScores,
IROVector crossProduct,
int numberOfFactors,
out IROVector PRESS)
{
IMatrix predictedY = new JaggedArrayMatrix(yLoads.Rows,yLoads.Columns);
IVector press = VectorMath.CreateExtensibleVector(numberOfFactors+1);
PRESS = press;
press[0] = MatrixMath.SumOfSquares(yLoads);
for(int nf=0;nf<numberOfFactors;nf++)
{
Predict(matrixX,xLoads,yLoads,xScores,crossProduct,nf,predictedY,null);
press[nf+1] = MatrixMath.SumOfSquaredDifferences(yLoads,predictedY);
}
}
/** Least squares solution of A*X = B
@param B A Matrix with as many rows as A and any number of columns.
@return X that minimizes the two norm of Q*R*X-B.
@exception IllegalArgumentException Matrix row dimensions must agree.
@exception RuntimeException Matrix is rank deficient.
*/
public void Solve(IROMatrix B, IMatrix result)
{
if (B.Rows != m)
{
throw new ArgumentException("Matrix row dimensions must agree.");
}
if (!this.IsFullRank())
{
throw new Exception("Matrix is rank deficient.");
}
// Copy right hand side
int nx = B.Columns;
double[][] X;
if (_solveMatrixWorkspace != null && _solveMatrixWorkspace.Rows == B.Rows && _solveMatrixWorkspace.Columns == B.Columns)
{
X = _solveMatrixWorkspace.Array;
MatrixMath.Copy(B, _solveMatrixWorkspace);
}
else
{
X = JaggedArrayMath.GetMatrixCopy(B);
_solveMatrixWorkspace = new JaggedArrayMatrix(X, B.Rows, B.Columns);
}
// Compute Y = transpose(Q)*B
for (int k = 0; k < n; k++)
{
for (int j = 0; j < nx; j++)
{
double s = 0.0;
for (int i = k; i < m; i++)
{
s += QR[i][k] * X[i][j];
}
s = -s / QR[k][k];
for (int i = k; i < m; i++)
{
X[i][j] += s * QR[i][k];
}
}
}
// Solve R*X = Y;
for (int k = n - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k][j] /= Rdiag[k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * QR[i][k];
}
}
}
MatrixMath.Submatrix(_solveMatrixWorkspace, result, 0, 0);
}
public IMatrix GetSolution(IROMatrix A, IROMatrix B)
{
Decompose(A);
JaggedArrayMatrix result = new JaggedArrayMatrix(m, B.Columns);
Solve(B, result);
return result;
}
/** Generate and return the (economy-sized) orthogonal factor
@return Q
*/
public JaggedArrayMatrix GetQ()
{
JaggedArrayMatrix X = new JaggedArrayMatrix(m, n);
double[][] Q = X.Array;
for (int k = n - 1; k >= 0; k--)
{
for (int i = 0; i < m; i++)
{
Q[i][k] = 0.0;
}
Q[k][k] = 1.0;
for (int j = k; j < n; j++)
{
if (QR[k][k] != 0)
{
double s = 0.0;
for (int i = k; i < m; i++)
{
s += QR[i][k] * Q[i][j];
}
s = -s / QR[k][k];
for (int i = k; i < m; i++)
{
Q[i][j] += s * QR[i][k];
}
}
}
}
return X;
}
/** Return the upper triangular factor
@return R
*/
public JaggedArrayMatrix GetR()
{
JaggedArrayMatrix X = new JaggedArrayMatrix(n, n);
double[][] R = X.Array;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (i < j)
{
R[i][j] = QR[i][j];
}
else if (i == j)
{
R[i][j] = Rdiag[i];
}
else
{
R[i][j] = 0.0;
}
}
}
return X;
}
/** Return the Householder vectors
@return Lower trapezoidal matrix whose columns define the reflections
*/
public JaggedArrayMatrix GetH()
{
JaggedArrayMatrix X = new JaggedArrayMatrix(m, n);
double[][] H = X.Array;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i >= j)
{
H[i][j] = QR[i][j];
}
else
{
H[i][j] = 0.0;
}
}
}
return X;
}