Contents


NAME

     clarzt - form the triangular factor T  of  a  complex  block
     reflector H of order > n, which is defined as a product of k
     elementary reflectors

SYNOPSIS

     SUBROUTINE CLARZT(DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)

     CHARACTER * 1 DIRECT, STOREV
     COMPLEX V(LDV,*), TAU(*), T(LDT,*)
     INTEGER N, K, LDV, LDT

     SUBROUTINE CLARZT_64(DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)

     CHARACTER * 1 DIRECT, STOREV
     COMPLEX V(LDV,*), TAU(*), T(LDT,*)
     INTEGER*8 N, K, LDV, LDT

  F95 INTERFACE
     SUBROUTINE LARZT(DIRECT, STOREV, N, K, V, [LDV], TAU, T, [LDT])

     CHARACTER(LEN=1) :: DIRECT, STOREV
     COMPLEX, DIMENSION(:) :: TAU
     COMPLEX, DIMENSION(:,:) :: V, T
     INTEGER :: N, K, LDV, LDT

     SUBROUTINE LARZT_64(DIRECT, STOREV, N, K, V, [LDV], TAU, T, [LDT])

     CHARACTER(LEN=1) :: DIRECT, STOREV
     COMPLEX, DIMENSION(:) :: TAU
     COMPLEX, DIMENSION(:,:) :: V, T
     INTEGER(8) :: N, K, LDV, LDT

  C INTERFACE
     #include <sunperf.h>

     void clarzt(char direct, char storev, int n, int k,  complex
               *v, int ldv, complex *tau, complex *t, int ldt);

     void clarzt_64(char direct, char storev,  long  n,  long  k,
               complex  *v,  long  ldv, complex *tau, complex *t,
               long ldt);

PURPOSE

     clarzt forms the triangular factor  T  of  a  complex  block
     reflector H of order > n, which is defined as a product of k
     elementary reflectors.

     If DIRECT = 'F', H = H(1) H(2) . . . H(k)  and  T  is  upper
     triangular;

     If DIRECT = 'B', H = H(k) . . . H(2) H(1)  and  T  is  lower
     triangular.

     If STOREV = 'C', the vector  which  defines  the  elementary
     reflector  H(i) is stored in the i-th column of the array V,
     and

        H  =  I - V * T * V'

     If STOREV = 'R', the vector  which  defines  the  elementary
     reflector H(i) is stored in the i-th row of the array V, and

        H  =  I - V' * T * V

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

ARGUMENTS

     DIRECT (input)
               Specifies  the  order  in  which  the   elementary
               reflectors   are  multiplied  to  form  the  block
               reflector:
               = 'F': H = H(1) H(2) . . . H(k) (Forward, not sup-
               ported yet)
               = 'B': H = H(k) . . . H(2) H(1) (Backward)

     STOREV (input)
               Specifies how the vectors which define the elemen-
               tary  reflectors  are  stored  (see  also  Further
               Details):
               = 'R': rowwise

     N (input) The order of the block reflector H. N >= 0.

     K (input) The order of the triangular factor T (= the number
               of elementary reflectors). K >= 1.

     V (input) (LDV,K) if STOREV = 'C' (LDV,N) if  STOREV  =  'R'
               The matrix V. See further details.

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

     TAU (input)
               TAU(i) must contain the scalar factor of the  ele-
               mentary reflector H(i).

     T (input) The k by  k  triangular  factor  T  of  the  block
               reflector.   If  DIRECT = 'F', T is upper triangu-
               lar; if DIRECT = 'B', T is lower  triangular.  The
               rest of the array is not used.

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

FURTHER DETAILS

     Based on contributions by
       A. Petitet, Computer Science Dept., Univ. of Tenn.,  Knox-
     ville, USA

     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_____
            (    v1    v2    v3    )                            /
     ( v1 v2 v3 )                      ( v1 v1 v1 v1 v1 . . . . 1
     )
        V = ( v1 v2 v3 )                      ( v2 v2 v2 v2 v2  .
     . . 1   )
            ( v1 v2 v3 )                      ( v3 v3 v3 v3 v3  .
     . 1     )
            ( v1 v2 v3 )
               .  .  .
               1  .  .
                  1  .
                     1

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

                                                           ______V_____
               1                                                /
     .  1                           ( 1 . . . . v1 v1 v1 v1 v1 )
               .  .  1                        ( . 1 . . .  v2  v2
     v2 v2 v2 )
               .  .  .                        ( . . 1 . .  v3  v3
     v3 v3 v3 )
               .  .  .
            ( v1 v2 v3 )
        V = ( v1 v2 v3 )
            ( v1 v2 v3 )