## MB04QC

### Premultiplying a real matrix with an orthogonal symplectic block reflector

[Specification] [Arguments] [Method] [References] [Comments] [Example]

Purpose

```  To apply the orthogonal symplectic block reflector

[  I+V*T*V'  V*R*S*V'  ]
Q =  [                      ]
[ -V*R*S*V'  I+V*T*V'  ]

or its transpose to a real 2m-by-n matrix [ op(A); op(B) ] from
the left.
The k-by-k upper triangular blocks of the matrices

[ S1 ]       [ T11 T12 T13 ]
R  = [ R1 R2 R3 ],  S = [ S2 ],  T = [ T21 T22 T23 ],
[ S3 ]       [ T31 T32 T33 ]

with R2 unit and S1, R3, T21, T31, T32 strictly upper triangular,
are stored rowwise in the arrays RS and T, respectively.

```
Specification
```      SUBROUTINE MB04QC( STRAB, TRANA, TRANB, TRANQ, DIRECT, STOREV,
\$                   STOREW, M, N, K, V, LDV, W, LDW, RS, LDRS, T,
\$                   LDT, A, LDA, B, LDB, DWORK )
C     .. Scalar Arguments ..
CHARACTER         DIRECT, STOREV, STOREW, STRAB, TRANA, TRANB,
\$                  TRANQ
INTEGER           K, LDA, LDB, LDRS, LDT, LDV, LDW, M, N
C     .. Array Arguments ..
DOUBLE PRECISION  A(LDA,*), B(LDB,*), DWORK(*), RS(LDRS,*),
\$                  T(LDT,*), V(LDV,*), W(LDW,*)

```
Arguments

Mode Parameters

```  STRAB   CHARACTER*1
Specifies the structure of the first blocks of A and B:
= 'Z':  the leading K-by-N submatrices of op(A) and op(B)
are (implicitly) assumed to be zero;
= 'N';  no structure to mention.

TRANA   CHARACTER*1
Specifies the form of op( A ) as follows:
= 'N':  op( A ) = A;
= 'T':  op( A ) = A';
= 'C':  op( A ) = A'.

TRANB   CHARACTER*1
Specifies the form of op( B ) as follows:
= 'N':  op( B ) = B;
= 'T':  op( B ) = B';
= 'C':  op( B ) = B'.

DIRECT  CHARACTER*1
This is a dummy argument, which is reserved for future
extensions of this subroutine. Not referenced.

TRANQ   CHARACTER*1
= 'N':  apply Q;
= 'T':  apply Q'.

STOREV  CHARACTER*1
Specifies how the vectors which define the concatenated
Householder reflectors contained in V are stored:
= 'C':  columnwise;
= 'R':  rowwise.

STOREW  CHARACTER*1
Specifies how the vectors which define the concatenated
Householder reflectors contained in W are stored:
= 'C':  columnwise;
= 'R':  rowwise.

```
Input/Output Parameters
```  M       (input) INTEGER
The number of rows of the matrices op(A) and op(B).
M >= 0.

N       (input) INTEGER
The number of columns of the matrices op(A) and op(B).
N >= 0.

K       (input) INTEGER
The order of the triangular matrices defining R, S and T.
M >= K >= 0.

V       (input) DOUBLE PRECISION array, dimension
(LDV,K) if STOREV = 'C',
(LDV,M) if STOREV = 'R'
On entry with STOREV = 'C', the leading M-by-K part of
this array must contain in its columns the vectors which
define the elementary reflector used to form parts of Q.
On entry with STOREV = 'R', the leading K-by-M part of
this array must contain in its rows the vectors which
define the elementary reflector used to form parts of Q.

LDV     INTEGER
The leading dimension of the array V.
LDV >= MAX(1,M),  if STOREV = 'C';
LDV >= MAX(1,K),  if STOREV = 'R'.

W       (input) DOUBLE PRECISION array, dimension
(LDW,K) if STOREW = 'C',
(LDW,M) if STOREW = 'R'
On entry with STOREW = 'C', the leading M-by-K part of
this array must contain in its columns the vectors which
define the elementary reflector used to form parts of Q.
On entry with STOREW = 'R', the leading K-by-M part of
this array must contain in its rows the vectors which
define the elementary reflector used to form parts of Q.

LDW     INTEGER
The leading dimension of the array W.
LDW >= MAX(1,M),  if STOREW = 'C';
LDW >= MAX(1,K),  if STOREW = 'R'.

RS      (input) DOUBLE PRECISION array, dimension (K,6*K)
On entry, the leading K-by-6*K part of this array must
contain the upper triangular matrices defining the factors
R and S of the symplectic block reflector Q. The
(strictly) lower portions of this array are not
referenced.

LDRS    INTEGER
The leading dimension of the array RS.  LDRS >= MAX(1,K).

T       (input) DOUBLE PRECISION array, dimension (K,9*K)
On entry, the leading K-by-9*K part of this array must
contain the upper triangular matrices defining the factor
T of the symplectic block reflector Q. The (strictly)
lower portions of this array are not referenced.

LDT     INTEGER
The leading dimension of the array T.  LDT >= MAX(1,K).

A       (input/output) DOUBLE PRECISION array, dimension
(LDA,N) if TRANA = 'N',
(LDA,M) if TRANA = 'C' or TRANA = 'T'
On entry with TRANA = 'N', the leading M-by-N part of this
array must contain the matrix A.
On entry with TRANA = 'T' or TRANA = 'C', the leading
N-by-M part of this array must contain the matrix A.

LDA     INTEGER
The leading dimension of the array A.
LDA >= MAX(1,M),  if TRANA = 'N';
LDA >= MAX(1,N),  if TRANA = 'C' or TRANA = 'T'.

B       (input/output) DOUBLE PRECISION array, dimension
(LDB,N) if TRANB = 'N',
(LDB,M) if TRANB = 'C' or TRANB = 'T'
On entry with TRANB = 'N', the leading M-by-N part of this
array must contain the matrix B.
On entry with TRANB = 'T' or TRANB = 'C', the leading
N-by-M part of this array must contain the matrix B.

LDB     INTEGER
The leading dimension of the array B.
LDB >= MAX(1,M),  if TRANB = 'N';
LDB >= MAX(1,N),  if TRANB = 'C' or TRANB = 'T'.

```
Workspace
```  DWORK   DOUBLE PRECISION array, dimension (LDWORK), where
LDWORK >= 8*N*K,   if STRAB = 'Z',
LDWORK >= 9*N*K,   if STRAB = 'N'.

```
References
```   Kressner, D.
Block algorithms for orthogonal symplectic factorizations.
BIT, 43 (4), pp. 775-790, 2003.

```
Numerical Aspects
```  The algorithm requires 16*( M - K )*N + ( 26*K - 4 )*K*N floating
point operations if STRAB = 'Z' and additional ( 12*K + 2 )*K*N
floating point operations if STRAB = 'N'.

```
```  None
```
Example

Program Text

```  None
```
Program Data
```  None
```
Program Results
```  None
```