slarft.f

Go to the documentation of this file.

      SUBROUTINE slarft( DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT )
      IMPLICIT NONE
*
*  -- LAPACK auxiliary routine (version 3.2) --
*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
*     November 2006
*
*     .. Scalar Arguments ..
      CHARACTER          direct, storev
      INTEGER            k, ldt, ldv, n
*     ..
*     .. Array Arguments ..
      REAL               t( ldt, * ), tau( * ), v( ldv, * )
*     ..
*
*  Purpose
*  =======
*
*  SLARFT forms the triangular factor T of a real 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
*
*  Arguments
*  =========
*
*  DIRECT  (input) CHARACTER*1
*          Specifies the order in which the elementary reflectors are
*          multiplied to form the block reflector:
*          = 'F': H = H(1) H(2) . . . H(k) (Forward)
*          = 'B': H = H(k) . . . H(2) H(1) (Backward)
*
*  STOREV  (input) CHARACTER*1
*          Specifies how the vectors which define the elementary
*          reflectors are stored (see also Further Details):
*          = 'C': columnwise
*          = 'R': rowwise
*
*  N       (input) INTEGER
*          The order of the block reflector H. N >= 0.
*
*  K       (input) INTEGER
*          The order of the triangular factor T (= the number of
*          elementary reflectors). K >= 1.
*
*  V       (input/output) REAL array, dimension
*                               (LDV,K) if STOREV = 'C'
*                               (LDV,N) if STOREV = 'R'
*          The matrix V. See further details.
*
*  LDV     (input) INTEGER
*          The leading dimension of the array V.
*          If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K.
*
*  TAU     (input) REAL array, dimension (K)
*          TAU(i) must contain the scalar factor of the elementary
*          reflector H(i).
*
*  T       (output) REAL array, dimension (LDT,K)
*          The k by k triangular factor T of the block reflector.
*          If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is
*          lower triangular. The rest of the array is not used.
*
*  LDT     (input) INTEGER
*          The leading dimension of the array T. LDT >= K.
*
*  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 )
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               one, zero
      parameter( one = 1.0e+0, zero = 0.0e+0 )
*     ..
*     .. Local Scalars ..
      INTEGER            i, j, prevlastv, lastv
      REAL               vii
*     ..
*     .. External Subroutines ..
      EXTERNAL           sgemv, strmv
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      EXTERNAL           lsame
*     ..
*     .. Executable Statements ..
*
*     Quick return if possible
*
      IF( n.EQ.0 )
     $   return
*
      IF( lsame( direct, 'F' ) ) THEN
         prevlastv = n
         DO 20 i = 1, k
            prevlastv = max( i, prevlastv )
            IF( tau( i ).EQ.zero ) THEN
*
*              H(i)  =  I
*
               DO 10 j = 1, i
                  t( j, i ) = zero
   10          continue
            ELSE
*
*              general case
*
               vii = v( i, i )
               v( i, i ) = one
               IF( lsame( storev, 'C' ) ) THEN
!                 Skip any trailing zeros.
                  DO 50 lastv = n, i+1, -1
                     IF( v( lastv, i ).NE.zero ) goto 55
   50             continue
   55             continue
                  j = min( lastv, prevlastv )
*
*                 T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i)
*
                  CALL sgemv( 'Transpose', j-i+1, i-1, -tau( i ),
     $                        v( i, 1 ), ldv, v( i, i ), 1, zero,
     $                        t( 1, i ), 1 )
               ELSE
!                 Skip any trailing zeros.
                  DO 60 lastv = n, i+1, -1
                     IF( v( i, lastv ).NE.zero ) goto 65
   60             continue
   65             continue
                  j = min( lastv, prevlastv )
*
*                 T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)'
*
                  CALL sgemv( 'No transpose', i-1, j-i+1, -tau( i ),
     $                        v( 1, i ), ldv, v( i, i ), ldv, zero,
     $                        t( 1, i ), 1 )
               END IF
               v( i, i ) = vii
*
*              T(1:i-1,i) := T(1:i-1,1:i-1) * T(1:i-1,i)
*
               CALL strmv( 'Upper', 'No transpose', 'Non-unit', i-1, t,
     $                     ldt, t( 1, i ), 1 )
               t( i, i ) = tau( i )
               IF( i.GT.1 ) THEN
                  prevlastv = max( prevlastv, lastv )
               ELSE
                  prevlastv = lastv
               END IF
            END IF
   20    continue
      ELSE
         prevlastv = 1
         DO 40 i = k, 1, -1
            IF( tau( i ).EQ.zero ) THEN
*
*              H(i)  =  I
*
               DO 30 j = i, k
                  t( j, i ) = zero
   30          continue
            ELSE
*
*              general case
*
               IF( i.LT.k ) THEN
                  IF( lsame( storev, 'C' ) ) THEN
                     vii = v( n-k+i, i )
                     v( n-k+i, i ) = one
!                    Skip any leading zeros.
                     DO 70 lastv = 1, i-1
                        IF( v( lastv, i ).NE.zero ) goto 75
   70                continue
   75                continue
                     j = max( lastv, prevlastv )
*
*                    T(i+1:k,i) :=
*                            - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i)
*
                     CALL sgemv( 'Transpose', n-k+i-j+1, k-i, -tau( i ),
     $                           v( j, i+1 ), ldv, v( j, i ), 1, zero,
     $                           t( i+1, i ), 1 )
                     v( n-k+i, i ) = vii
                  ELSE
                     vii = v( i, n-k+i )
                     v( i, n-k+i ) = one
!                    Skip any leading zeros.
                     DO 80 lastv = 1, i-1
                        IF( v( i, lastv ).NE.zero ) goto 85
   80                continue
   85                continue
                     j = max( lastv, prevlastv )
*
*                    T(i+1:k,i) :=
*                            - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)'
*
                     CALL sgemv( 'No transpose', k-i, n-k+i-j+1,
     $                    -tau( i ), v( i+1, j ), ldv, v( i, j ), ldv,
     $                    zero, t( i+1, i ), 1 )
                     v( i, n-k+i ) = vii
                  END IF
*
*                 T(i+1:k,i) := T(i+1:k,i+1:k) * T(i+1:k,i)
*
                  CALL strmv( 'Lower', 'No transpose', 'Non-unit', k-i,
     $                        t( i+1, i+1 ), ldt, t( i+1, i ), 1 )
                  IF( i.GT.1 ) THEN
                     prevlastv = min( prevlastv, lastv )
                  ELSE
                     prevlastv = lastv
                  END IF
               END IF
               t( i, i ) = tau( i )
            END IF
   40    continue
      END IF
      return
*
*     End of SLARFT
*
      END