Packages

class Fac_QR_RR[MatT <: MatriD] extends Fac_QR_H[MatT] with Pivoting

The Fac_QR_RR 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 extends Fac_QR_H and adds column pivoting for greater robustness and resonably accurate rank determination (Rank Revealing QR). Caveat: for m < n use Fac_LQ. -------------------------------------------------------------------------------

QRDecomposition.java in Jama

5.1 and 5.2 in Matrix Computations

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

Instance Constructors

  1. new Fac_QR_RR(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. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. val at: MatrixD
    Attributes
    protected
    Definition Classes
    Fac_QR_H
  6. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  7. def colHouse(k: Int): Unit

    Calculate the 'k'th Householder vector and perform the 'k'th Householder reflection.

    Calculate the 'k'th Householder vector and perform the 'k'th Householder reflection.

    k

    the index of the column performing the Householder reflection

    Attributes
    protected
    Definition Classes
    Fac_QR_H
  8. 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
  9. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  10. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  11. def factor(): Fac_QR_RR[MatT]

    Perform QR Factorization and result in a single matrix which contains Householder vectors of each columns in lower triangular of 'aa' matrix.

    Perform QR Factorization and result in a single matrix which contains Householder vectors of each columns in lower triangular of 'aa' matrix. This Rank Revealing algorithm uses Householder orthogonalization and pivoting.

    Definition Classes
    Fac_QR_RRFac_QR_HFactorization
    See also

    QRDecomposition.java in Jama

    5.1 and 5.2 in Matrix Computations

  12. 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
  13. 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
  14. 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
  15. val factored: Boolean

    Flag indicating whether the matrix has been factored

    Flag indicating whether the matrix has been factored

    Attributes
    protected
    Definition Classes
    Factorization
  16. 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
  17. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  18. 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
  19. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  20. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  21. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  22. val m: Int
    Attributes
    protected
    Definition Classes
    Fac_QR
  23. val n: Int
    Attributes
    protected
    Definition Classes
    Fac_QR
  24. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  25. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  26. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  27. 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
  28. 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

    Definition Classes
    Fac_QR_H
  29. val p: Int
    Attributes
    protected
    Definition Classes
    Fac_QR
  30. def piv: VectorI

    Return the pivot vector.

  31. val q: MatrixD
    Attributes
    protected
    Definition Classes
    Fac_QR
  32. val r: MatriD
    Attributes
    protected
    Definition Classes
    Fac_QR
  33. def rank: Int

    Return the rank (number of independent columns) in matrix 'aa'.

  34. def reorderCols(a: MatriD, piv: VectorI): MatriD

    Reorder the columns of matrix 'a' according to the pivot vector 'piv'.

    Reorder the columns of matrix 'a' according to the pivot vector 'piv'.

    a

    the matrix to reorder

    Definition Classes
    Pivoting
  35. def reorderRows(a: MatriD, piv: VectorI): MatriD

    Reorder the rows of matrix 'a' according to the pivot vector 'piv'.

    Reorder the rows of matrix 'a' according to the pivot vector 'piv'.

    a

    the matrix to reorder

    Definition Classes
    Pivoting
  36. def solve(b: VectorD): VectoD
    Definition Classes
    Fac_QR_H
  37. 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
  38. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  39. def toString(): String
    Definition Classes
    AnyRef → Any
  40. 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

    Definition Classes
    Fac_QR_H
  41. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  42. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  43. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )

Inherited from Pivoting

Inherited from Fac_QR_H[MatT]

Inherited from Fac_QR[MatT]

Inherited from Error

Inherited from Factorization

Inherited from AnyRef

Inherited from Any

Ungrouped