MB04QC

Premultiplying a real matrix with an orthogonal symplectic block reflector

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.

      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,*)

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.

  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'.

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

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

  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

Program Text

  None

  None

  None