Rogue Wave banner
Previous fileTop of DocumentContentsIndexNext file

{type}CODecomp



Data Type and Member Function Indexes
(exclusive of constructors and destructors)

Synopsis

#include <rw/dco.h>          // DoubleCODecomp
#include <rw/fco.h>          // FloatCODecomp
#include <rw/cdo.h>          // DComplexCODecomp

DoubleCODecomp QTZ(A);       // A is an RWGenMat<double>

Description

The classes {TYPE}CODecomp encapsulate a complete orthogonal decomposition. A complete orthogonal decomposition decomposes a general rectangular matrix A into the form:

where P is a permutation, Q and Z are orthogonal matrices, and T is an upper triangular matrix. This transformation is closely related to the QR transformation. The difference is that an extra orthogonal transformation, Z, is applied to zero out the columns to the right of T.

Example

This decomposition is commonly used in the solution of least squares problems. The implementation of the LAPACK class group {TYPE}LeastSqQR uses the complete orthogonal transformation.

Public Constructors

DoubleCODecomp();
FloatCODecomp();
DComplexCODecomp();
DoubleCODecomp(const DoubleCODecomp& A);
FloatCODecomp(const FloatCODecomp& A);
DComplexCODecomp(const DComplexCODecomp& A);
DoubleCODecomp(const DoubleQRDecomp& A, double tol=0);
FloatCODecomp(const FloatQRDecomp& A, double tol=0);
DComplexCODecomp(const DComplexQRDecomp& A, double tol=0);
DoubleCODecomp(const RWGenMat<double>& A, double tol=0);
FloatCODecomp(const RWGenMat<float>& A, double tol=0);
DComplexCODecomp(const RWGenMat<DComplex>& A, double tol=0);

Public Member Functions

unsigned
FloatCODecomp::cols();
unsigned
DoubleCODecomp::cols();
unsigned
DComplexCODecomp::cols();
void
DoubleCODecomp::factor(const DoubleQRDecomp& A, double tol=0);
void
FloatCODecomp::factor(const FloatQRDecomp& A, double tol=0);
void
DComplexCODecomp::factor(const DComplexQRDecomp& A, 
                         double tol=0);
void
DoubleCODecomp::factor(const RWGenMat<double>& A, double tol=0);
void
FloatCODecomp::factor(const RWGenMat<float>& A, double tol=0);
void
DComplexCODecomp::factor(const RWGenMat<DComplex>& A, double tol=0);
RWGenMat<float>
FloatCODecomp::P();
RWGenMat<double>
DoubleCODecomp::P();
RWGenMat<DComplex>
DComplexCODecomp::P();
RWMathVec<float>
FloatCODecomp::Px(const RWMathVec<float>& x);
RWMathVec<float>
FloatCODecomp::PTx(const RWMathVec<float>& x);
RWMathVec<double>
DoubleCODecomp::Px(const RWMathVec<double>& x);
RWMathVec<double>
DoubleCODecomp::PTx(const RWMathVec<double>& x);
RWMathVec<DComplex>
DComplexCODecomp::Px(const RWMathVec<DComplex>& x);
RWMathVec<DComplex>
DComplexCODecomp::PTx(const RWMathVec<DComplex>& x);
RWGenMat<float>
FloatCODecomp::Q();
RWGenMat<double>
DoubleCODecomp::Q();
RWGenMat<DComplex>
DComplexCODecomp::Q();
RWMathVec<float>
FloatCODecomp::Qx(const RWMathVec<float>& x);
RWMathVec<float>
FloatCODecomp::QTx(const RWMathVec<float>& x);
RWMathVec<double>
DoubleCODecomp::Qx(const RWMathVec<double>& x);
RWMathVec<double>
DoubleCODecomp::QTx(const RWMathVec<double>& x);
RWMathVec<DComplex>
DComplexCODecomp::Qx(const RWMathVec<DComplex>& x);
RWMathVec<DComplex>
DComplexCODecomp::QTx(const RWMathVec<DComplex>& x);
unsigned
FloatCODecomp::rank();
unsigned
DoubleCODecomp::rank();
unsigned
DComplexCODecomp::rank();
unsigned
FloatCODecomp::rows();
unsigned
DoubleCODecomp::rows();
unsigned
DComplexCODecomp::rows();
RWGenMat<float>
FloatCODecomp::T();
RWGenMat<double>
DoubleCODecomp::T();
RWGenMat<DComplex>
DComplexCODecomp::T();
RWMathVec<float>
FloatCODecomp::Tx(const RWMathVec<float>& x);
RWMathVec<float>
FloatCODecomp::TTx(const RWMathVec<float>& x);
RWMathVec<float>
FloatCODecomp::Tinvx(const RWMathVec<float>& x);
RWMathVec<float>
FloatCODecomp::TTinvx(const RWMathVec<float>& x);
RWMathVec<double>
DoubleCODecomp::Tx(const RWMathVec<double>& x);
RWMathVec<double>
DoubleCODecomp::TTx(const RWMathVec<double>& x);
RWMathVec<double>
DoubleCODecomp::Tinvx(const RWMathVec<double>& x);
RWMathVec<double>
DoubleCODecomp::TTinvx(const RWMathVec<double>& x);
RWMathVec<DComplex> 
DComplexCODecomp::Tx(const RWMathVec<DComplex>& x);
RWMathVec<DComplex>
DComplexCODecomp::TTx(const RWMathVec<DComplex>& x);
RWMathVec<DComplex>
DComplexCODecomp::Tinvx(const RWMathVec<DComplex>& x);
RWMathVec<DComplex>
DComplexCODecomp::TTinvx(const RWMathVec<DComplex>& x);
RWGenMat<float>
FloatCODecomp::Z();
RWGenMat<double>
DoubleCODecomp::Z();
RWGenMat<DComplex>
DComplexCODecomp::Z();
RWMathVec<float>
FloatCODecomp::Zx(const RWMathVec<float>& x);
RWMathVec<float>
FloatCODecomp::ZTx(const RWMathVec<float>& x);
RWMathVec<double>
DoubleCODecomp::Zx(const RWMathVec<double>& x);
RWMathVec<double>
DoubleCODecomp::ZTx(const RWMathVec<double>& x);
RWMathVec<DComplex>
DComplexCODecomp::Zx(const RWMathVec<DComplex>& x);
RWMathVec<DComplex>
DComplexCODecomp::ZTx(const RWMathVec<DComplex>& x);


Previous fileTop of DocumentContentsIndexNext file

©Copyright 1999, Rogue Wave Software, Inc.
Send mail to report errors or comment on the documentation.