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



NAME
       SLARFB

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



PURPOSE
            SLARFB applies a real block reflector H or its transpose H**T to a
            real m by n matrix C, from either the left or the right.




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)
                     = 'T': 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)
                     = '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 REAL array, dimension
                                           (LDV,K) if STOREV = 'C'
                                           (LDV,M) if STOREV = 'R' and SIDE = 'L'
                                           (LDV,N) if STOREV = 'R' and SIDE = 'R'
                     The matrix V. 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 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).






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                      SLARFB(3)