Packages

class Fac_QR_H[MatT <: MatriD] extends Fac_QR[MatT]

The Fac_QR_H class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:

'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix

such that 'a = q * r'. It uses uses Householder orthogonalization.

See also

www.stat.wisc.edu/~larget/math496/qr.html ------------------------------------------------------------------------------- This implementation improves upon Fac_QR_H2 by working with the transpose the original matrix and reorders operations to facilitate parallelism (see par directory). Caveat: for m < n use Fac_LQ. -------------------------------------------------------------------------------

QRDecomposition.java in Jama

5.1 and 5.2 in Matrix Computations

Linear Supertypes
Fac_QR[MatT], Error, Factorization, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Fac_QR_H
  2. Fac_QR
  3. Error
  4. Factorization
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Fac_QR_H(aa: MatT, needQ: Boolean = true)

    aa

    the matrix to be factor into q and r

    needQ

    flag indicating whether a full 'q' matrix is needed

Value Members

  1. def computeQ(): Unit

    Compute the full 'q' orthogonal matrix based on updated values in 'at'.

    Compute the full 'q' orthogonal matrix based on updated values in 'at'.

    Definition Classes
    Fac_QR_HFac_QR
  2. def factor(): Unit

    Perform QR Factorization and store the result in a single matrix which contains Householder vectors of each column in the lower triangle of the 'aa' matrix.

    Perform QR Factorization and store the result in a single matrix which contains Householder vectors of each column in the lower triangle of the 'aa' matrix. This algorithm uses Householder orthogonalization.

    Definition Classes
    Fac_QR_HFactorization
    See also

    QRDecomposition.java in Jama

    5.1 and 5.2 in Matrix Computations

  3. def factor1(): MatriD

    Factor a matrix into the product of two matrices, e.g., 'a = l * l.t', returning only the first matrix.

    Factor a matrix into the product of two matrices, e.g., 'a = l * l.t', returning only the first matrix.

    Definition Classes
    Factorization
  4. def factor12(): (MatriD, MatriD)

    Factor a matrix into the product of two matrices, e.g., 'a = l * l.t' or a = q * r, returning both the first and second matrices.

    Factor a matrix into the product of two matrices, e.g., 'a = l * l.t' or a = q * r, returning both the first and second matrices.

    Definition Classes
    Factorization
  5. def factor2(): MatriD

    Factor a matrix into the product of two matrices, e.g., 'a = l * l.t', returning only the second matrix.

    Factor a matrix into the product of two matrices, e.g., 'a = l * l.t', returning only the second matrix.

    Definition Classes
    Factorization
  6. def factors: (MatriD, MatriD)

    Return both the orthogonal 'q' matrix and the right upper triangular 'r' matrix.

    Return both the orthogonal 'q' matrix and the right upper triangular 'r' matrix.

    Definition Classes
    Fac_QRFactorization
  7. final def flaw(method: String, message: String): Unit

    Show the flaw by printing the error message.

    Show the flaw by printing the error message.

    method

    the method where the error occurred

    message

    the error message

    Definition Classes
    Error
  8. def nullspace(rank: Int): MatriD

    Compute the nullspace of matrix 'a: { x | a*x = 0 }' using QR Factorization 'q*r*x = 0'.

    Compute the nullspace of matrix 'a: { x | a*x = 0 }' using QR Factorization 'q*r*x = 0'. Gives a basis of dimension 'n - rank' for the nullspace

    rank

    the rank of the matrix (number of linearly independent column vectors)

    Definition Classes
    Fac_QR_HFac_QR
  9. def nullspaceV(x: VectoD): VectoD

    Compute the nullspace of matrix 'a: { x | a*x = 0 }' using QR Factorization 'q*r*x = 0'.

    Compute the nullspace of matrix 'a: { x | a*x = 0 }' using QR Factorization 'q*r*x = 0'. Gives only one vector in the nullspace.

    x

    a vector with the correct dimension

  10. def solve(b: VectorD): VectoD
  11. def solve(b: VectoD): VectoD

    Solve for 'x' in 'aa*x = b' using the QR Factorization 'aa = q*r' via 'r*x = q.t * b' without actually calculating the 'q' matrix.

    Solve for 'x' in 'aa*x = b' using the QR Factorization 'aa = q*r' via 'r*x = q.t * b' without actually calculating the 'q' matrix. The overriding method is more efficient.

    b

    the constant vector

    Definition Classes
    Fac_QR_HFac_QRFactorization
  12. def transformB(b: Array[Double]): Array[Double]

    Transform 'b' into 'q.t * b', i.e., perform the right side of the equation 'r*x = q.t * b' not using a full 'q' matrix.

    Transform 'b' into 'q.t * b', i.e., perform the right side of the equation 'r*x = q.t * b' not using a full 'q' matrix.

    b

    the constant vector