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



NAME
       ZLARFB

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



PURPOSE
            ZLARFB applies a complex block reflector H or its transpose H**H to a
            complex M-by-N matrix C, from either the left or the right.




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

           TRANS     (input)
                     TRANS is CHARACTER*1
                     = 'N': apply H (No transpose)
                     = 'C': apply H**H (Conjugate 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)
                     = '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
                     = '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).

           V         (input)
                     V is COMPLEX*16 array, dimension
                                           (LDV,K) if STOREV = 'C'
                                           (LDV,M) if STOREV = 'R' and SIDE = 'L'
                                           (LDV,N) if STOREV = 'R' and SIDE = 'R'
                     See Further Details.

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

           T         (input)
                     T is COMPLEX*16 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 COMPLEX*16 array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H.

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

           WORK      (output)
                     WORK is COMPLEX*16 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).






FURTHER DETAILS
             The shape of the matrix V and the storage of the vectors which define
             the H(i) is best illustrated by the following example with n = 5 and
             k = 3. The elements equal to 1 are not stored; the corresponding
             array elements are modified but restored on exit. The rest of the
             array is not used.

             DIRECT = 'F' and STOREV = 'C':         DIRECT = 'F' and STOREV = 'R':

                          V = (  1       )                 V = (  1 v1 v1 v1 v1 )
                              ( v1  1    )                     (     1 v2 v2 v2 )
                              ( v1 v2  1 )                     (        1 v3 v3 )
                              ( v1 v2 v3 )
                              ( v1 v2 v3 )

             DIRECT = 'B' and STOREV = 'C':         DIRECT = 'B' and STOREV = 'R':

                          V = ( v1 v2 v3 )                 V = ( v1 v1  1       )
                              ( v1 v2 v3 )                     ( v2 v2 v2  1    )
                              (  1 v2 v3 )                     ( v3 v3 v3 v3  1 )
                              (     1 v3 )
                              (        1 )



LAPACK routine                  31 October 2017                      ZLARFB(3)