SLARZB(3)      LAPACK routine of NEC Numeric Library Collection      SLARZB(3)



NAME
       SLARZB

SYNOPSIS
       SUBROUTINE SLARZB (SIDE, TRANS, DIRECT, STOREV, M, N, K, L, V, LDV, T,
           LDT, C, LDC, WORK, LDWORK)



PURPOSE
            SLARZB applies a real block reflector H or its transpose H**T to
            a real distributed M-by-N  C from the left or the right.

            Currently, only STOREV = 'R' and DIRECT = 'B' are supported.




ARGUMENTS
           SIDE      (input)
                     SIDE is CHARACTER*1
                     = 'L': apply H or H**T from the Left
                     = 'R': apply H or H**T from the Right

           TRANS     (input)
                     TRANS is CHARACTER*1
                     = 'N': apply H (No transpose)
                     = 'C': apply H**T (Transpose)

           DIRECT    (input)
                     DIRECT is CHARACTER*1
                     Indicates how H is formed from a product of elementary
                     reflectors
                     = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)
                     = 'B': H = H(k) . . . H(2) H(1) (Backward)

           STOREV    (input)
                     STOREV is CHARACTER*1
                     Indicates how the vectors which define the elementary
                     reflectors are stored:
                     = 'C': Columnwise                        (not supported yet)
                     = 'R': Rowwise

           M         (input)
                     M is INTEGER
                     The number of rows of the matrix C.

           N         (input)
                     N is INTEGER
                     The number of columns of the matrix C.

           K         (input)
                     K is INTEGER
                     The order of the matrix T (= the number of elementary
                     reflectors whose product defines the block reflector).

           L         (input)
                     L is INTEGER
                     The number of columns of the matrix V containing the
                     meaningful part of the Householder reflectors.
                     If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.

           V         (input)
                     V is REAL array, dimension (LDV,NV).
                     If STOREV = 'C', NV = K; if STOREV = 'R', NV = L.

           LDV       (input)
                     LDV is INTEGER
                     The leading dimension of the array V.
                     If STOREV = 'C', LDV >= L; if STOREV = 'R', LDV >= K.

           T         (input)
                     T is REAL array, dimension (LDT,K)
                     The triangular K-by-K matrix T in the representation of the
                     block reflector.

           LDT       (input)
                     LDT is INTEGER
                     The leading dimension of the array T. LDT >= K.

           C         (input/output)
                     C is REAL array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.

           LDC       (input)
                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK      (output)
                     WORK is REAL array, dimension (LDWORK,K)

           LDWORK    (input)
                     LDWORK is INTEGER
                     The leading dimension of the array WORK.
                     If SIDE = 'L', LDWORK >= max(1,N);
                     if SIDE = 'R', LDWORK >= max(1,M).



LAPACK routine                  31 October 2017                      SLARZB(3)