MB04QC - SLICOT Library Routine Documentation

## 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

      [1] 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'.

Further Comments

      None

Example

Program Text

      None

Program Data

      None

Program Results

      None

Return to Supporting Routines index