Struct QR 

pub struct QR<T, R, C>
where
    DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
    T: Scalar,
    R: DimMin<C>,
    C: Dim,
{ /* private fields */ }

The QR decomposition of a rectangular matrix A ∈ R^(m × n) with m >= n.

Implementations

impl<T, R, C> QR<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>, T: Scalar, R: DimMin<C>, C: Dim,

pub fn new(m: OMatrix<T, R, C>) -> Result<Self, Error>

where T: QrScalar + Zero,

Computes the QR decomposition of the matrix m.

Trait Implementations

impl<T, R, C> Clone for QR<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>, T: Scalar + Clone, R: DimMin<C> + Clone, C: Dim + Clone,

fn clone(&self) -> QR<T, R, C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, R, C> Debug for QR<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>, T: Scalar + Debug, R: DimMin<C> + Debug, C: Dim + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, R, C> QrDecomposition<T, R, C> for QR<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>> + Allocator<C>, R: DimMin<C, Output = C>, C: Dim, T: Scalar + RealField + QrReal,

fn solve_mut<C2: Dim, S, S2>( &self, x: &mut Matrix<T, C, C2, S2>, b: Matrix<T, R, C2, S>, ) -> Result<(), Error>

where S: RawStorageMut<T, R, C2> + IsContiguous, S2: RawStorageMut<T, C, C2> + IsContiguous, T: Zero,

Solve the square or overdetermined system in A X = B, where X ∈ R^(n × k), B ∈ R^(m × k) in a least-squares sense, such that || A X - B||^2 is minimized. The solution is placed into the matrix X ∈ R^(n × k).

fn nrows(&self) -> usize

The number of rows of the original matrix A.

fn ncols(&self) -> usize

The number of columns of the original matrix A.

fn shape_generic(&self) -> (R, C)

Shape of the original matrix A.

fn solve<C2: Dim, S>( &self, rhs: Matrix<T, R, C2, S>, ) -> Result<OMatrix<T, C, C2>, Error>

where S: RawStorageMut<T, R, C2> + IsContiguous + Storage<T, R, C2>, T: Zero, DefaultAllocator: Allocator<C, C2> + Allocator<R, C2>,

Solve the overdetermined linear system with the given right hand side in a least squares sense, see the comments on Self::solve_mut.

fn q_mul_mut<C2, S>(&self, b: &mut Matrix<T, R, C2, S>) -> Result<(), Error>

where C2: Dim, S: RawStorageMut<T, R, C2> + IsContiguous,

Efficiently calculate the matrix product Q B of the factor Q with a given matrix B. Q acts as if it is a matrix of dimension m × m, so we require B ∈ R^(m × k). The product is calculated in place and must only be considered valid when the function returns without error.

fn q_tr_mul_mut<C2, S>(&self, b: &mut Matrix<T, R, C2, S>) -> Result<(), Error>

where C2: Dim, S: RawStorageMut<T, R, C2> + IsContiguous,

Efficiently calculate the matrix product Q^T B of the factor Q with a given matrix B. Q acts as if it is a matrix of dimension m × m, so we require B ∈ R^(m × k). The product is calculated in place and must only be considered valid when the function returns without error.

fn mul_q_mut<R2, S>(&self, b: &mut Matrix<T, R2, R, S>) -> Result<(), Error>

where R2: Dim, S: RawStorageMut<T, R2, R> + IsContiguous,

Efficiently calculate the matrix product B Q of the factor Q with a given matrix B. Q acts as if it is a matrix of dimension m × m, so we require B ∈ R^(k × m). The product is calculated in place and must only be considered valid when the function returns without error.

fn mul_q_tr_mut<R2, S>(&self, b: &mut Matrix<T, R2, R, S>) -> Result<(), Error>

where R2: Dim, S: RawStorageMut<T, R2, R> + IsContiguous,

Efficiently calculate the matrix product B Q^T of the factor Q with a given matrix B. Q acts as if it is a matrix of dimension m × m, so we require B ∈ R^(k × m). The product is calculated in place and must only be considered valid when the function returns without error.

fn r_mul_mut<C2, S2>(&self, b: &mut Matrix<T, C, C2, S2>) -> Result<(), Error>

where C2: Dim, S2: RawStorageMut<T, C, C2> + IsContiguous, T: ConstOne,

Multiply R*B and place the result in B. R is treated as an m × m upper triangular matrix. The product is calculated in place and must only be considered valid when the function returns without error.

fn r_tr_mul_mut<C2, S2>( &self, b: &mut Matrix<T, C, C2, S2>, ) -> Result<(), Error>

where C2: Dim, S2: RawStorageMut<T, C, C2> + IsContiguous, T: ConstOne,

Multiply R^T * B and place the result in B. R is treated as an m × m upper triangular matrix. The product is calculated in place and must only be considered valid when the function returns without error.

fn mul_r_mut<R2, S2>(&self, b: &mut Matrix<T, R2, C, S2>) -> Result<(), Error>

where R2: Dim, S2: RawStorageMut<T, R2, C> + IsContiguous, T: ConstOne,

Multiply B*R and place the result in B. R is treated as an m × m upper triangular matrix. The product is calculated in place and must only be considered valid when the function returns without error.

fn mul_r_tr_mut<R2, S2>( &self, b: &mut Matrix<T, R2, C, S2>, ) -> Result<(), Error>

where R2: Dim, S2: RawStorageMut<T, R2, C> + IsContiguous, T: ConstOne,

Multiply B*R^T and place the result in B. R is treated as an m × m upper triangular matrix. The product is calculated in place and must only be considered valid when the function returns without error.

fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>>

where DefaultAllocator: Allocator<R, <R as DimMin<C>>::Output>, T: Zero,

Computes the orthonormal matrix Q ∈ R^(m × n) of this decomposition. Note that this matrix has economy dimensions, which means it is not square unless A is square. It satisfies Q^T Q = I. Note further that it is typically not necessary to compute Q explicitly. Rather, check if some of the provided multiplication functions can help to calculate the matrix products Q B, B Q, Q^T B, B Q^T more efficiently.

fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C>

where DefaultAllocator: Allocator<R, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>, C> + Allocator<DimMinimum<R, C>>,

Retrieves the upper trapezoidal submatrix R of this decomposition. Note that it’s typically not necessary to construct this matrix directly and check if any of the provided multiplication functions can be used instead.

impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for QR<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>, OMatrix<T, R, C>: Copy, OVector<T, DimMinimum<R, C>>: Copy,