naginterfaces.library.lapackeig.dtpmqrt

naginterfaces.library.lapackeig.dtpmqrt(side, trans, l, v, t, c1, c2)

dtpmqrt multiplies an arbitrary real matrix $C$ by the real orthogonal matrix $Q$ from a $QR$ factorization computed by dtpqrt().

For full information please refer to the NAG Library document for f08bc

https://support.nag.com/numeric/nl/nagdoc_30.2/flhtml/f08/f08bcf.html

Parameters

sidestr, length 1

Indicates how $Q$ or $Q^T$ is to be applied to $C$.

$side=\text{'L'}$

$Q$ or $Q^T$ is applied to $C$ from the left.

$side=\text{'R'}$

$Q$ or $Q^T$ is applied to $C$ from the right.

transstr, length 1

Indicates whether $Q$ or $Q^T$ is to be applied to $C$.

$trans=\text{'N'}$

$Q$ is applied to $C$.

$trans=\text{'T'}$

$Q^T$ is applied to $C$.

lint

$l$, the number of rows of the upper trapezoidal part of the pentagonal composite matrix $V$, passed (as $\text{b}$) in a previous call to dtpqrt(). This must be the same value used in the previous call to dtpqrt() (see $\text{l}$ in dtpqrt()).

vfloat, array-like, shape $(:,k)$

Note: the required extent for this argument in dimension 1 is determined as follows: if $side=\text{'L'}$: $m$; if $side=\text{'R'}$: $n$; otherwise: $0$.

The $m_v\times n_v$ matrix $V$; this should remain unchanged from the array $\text{b}$ returned by a previous call to dtpqrt().

tfloat, array-like, shape $(\text{nb},k)$

This must remain unchanged from a previous call to dtpqrt() (see $\text{t}$ in dtpqrt()).

c1float, array-like, shape $(:,:)$

Note: the required extent for this argument in dimension 1 is determined as follows: if $side=\text{'L'}$: $k$; if $side=\text{'R'}$: $m$; otherwise: $0$.

Note: the required extent for this argument in dimension 2 is determined as follows: if $side=\text{'L'}$: $n$; if $side=\text{'R'}$: $k$; otherwise: $0$.

$C_1$, the first part of the composite matrix $C$:

if $side=\text{'L'}$

then $c1$ contains the first $k$ rows of $C$;

if $side=\text{'R'}$

then $c1$ contains the first $k$ columns of $C$.

c2float, array-like, shape $(m,n)$

$C_2$, the second part of the composite matrix $C$.

if $side=\text{'L'}$

then $c2$ contains the remaining $m_v$ rows of $C$;

if $side=\text{'R'}$

then $c2$ contains the remaining $m_v$ columns of $C$;

Returns

c1float, ndarray, shape $(:,:)$

$c1$ is overwritten by the corresponding block of $QC$ or $Q^{T}C$ or $CQ$ or $C{Q}^T$.

c2float, ndarray, shape $(m,n)$

$c2$ is overwritten by the corresponding block of $QC$ or $Q^{T}C$ or $CQ$ or $C{Q}^T$.

Raises

NagValueError

(errno $-1$)

On entry, error in parameter $side$.

Constraint: $side=\text{'L'}$ or $\text{'R'}$.

(errno $-2$)

On entry, error in parameter $trans$.

Constraint: $trans=\text{'N'}$ or $\text{'T'}$.

(errno $-3$)

On entry, error in parameter $\text{m}$.

Constraint: $m\ge 0$.

(errno $-4$)

On entry, error in parameter $\text{n}$.

Constraint: $n\ge 0$.

(errno $-5$)

On entry, error in parameter $\text{k}$.

Constraint: $k\ge 0$.

(errno $-6$)

On entry, error in parameter $l$.

Constraint: $0\le l\le k$.

(errno $-7$)

On entry, error in parameter $\text{nb}$.

Constraint: $\text{nb}\ge 1$.

(errno $-7$)

On entry, error in parameter $\text{nb}$.

Constraint: $\text{nb}\le k$.

Notes

dtpmqrt is intended to be used after a call to dtpqrt() which performs a $QR$ factorization of a triangular-pentagonal matrix containing an upper triangular matrix $A$ over a pentagonal matrix $B$. The orthogonal matrix $Q$ is represented as a product of elementary reflectors.

This function may be used to form the matrix products

$$QC,Q^{T}C,CQ\text{or}C{Q}^T\text{,}$$

where the real rectangular $m_c\times n_c$ matrix $C$ is split into component matrices $C_1$ and $C_2$.

If $Q$ is being applied from the left ($QC$ or $Q^{T}C$) then

$$\begin{array}{c}C=\left(\begin{array}{c}{C}_1\\ C_2\end{array}\right)\end{array}$$

where $C_1$ is $k\times n_c$, $C_2$ is $m_v\times n_c$, $m_c=k+m_v$ is fixed and $m_v$ is the number of rows of the matrix $V$ containing the elementary reflectors (i.e., $\text{m}$ as passed to dtpqrt()); the number of columns of $V$ is $n_v$ (i.e., $\text{n}$ as passed to dtpqrt()).

If $Q$ is being applied from the right ($CQ$ or $C{Q}^T$) then

$$C=\left(\begin{array}{cc}{C}_1& C_2\end{array}\right)$$

where $C_1$ is $m_c\times k$, and $C_2$ is $m_c\times m_v$ and $n_c=k+m_v$ is fixed.

The matrices $C_1$ and $C_2$ are overwriten by the result of the matrix product.

A common application of this routine is in updating the solution of a linear least squares problem.

References

Golub, G H and Van Loan, C F, 2012, Matrix Computations, (4th Edition), Johns Hopkins University Press, Baltimore