ztrmvt()

subroutine ztrmvt	(	character	uplo,
		integer	n,
		complex*16, dimension( ldt, * )	t,
		integer	ldt,
		complex*16, dimension( * )	x,
		integer	incx,
		complex*16, dimension( * )	y,
		integer	incy,
		complex*16, dimension( * )	w,
		integer	incw,
		complex*16, dimension( * )	z,
		integer	incz
	)

Definition at line 1 of file ztrmvt.f.

*
*  -- ScaLAPACK routine (version 1.7) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     March 13, 2000
*
*     .. Scalar Arguments ..
      CHARACTER          UPLO
      INTEGER            INCW, INCX, INCY, INCZ, LDT, N
*     ..
*     .. Array Arguments ..
      COMPLEX*16         T( LDT, * ), W( * ), X( * ), Y( * ), Z( * )
*     ..
*
*  Purpose
*  =======
*
*  ZTRMVT  performs the matrix-vector operations
*
*     x := conjg( T' ) *y, and w := T *z,
*
*  where x is an n element vector and  T is an n by n
*  upper or lower triangular matrix.
*
*  Arguments 
*  =========
*
*  UPLO   - CHARACTER*1.
*           On entry, UPLO specifies whether the matrix is an upper or
*           lower triangular matrix as follows:
*
*              UPLO = 'U' or 'u'   A is an upper triangular matrix.
*
*              UPLO = 'L' or 'l'   A is a lower triangular matrix.
*
*           Unchanged on exit.
*
*  N      - INTEGER.
*           On entry, N specifies the order of the matrix A.
*           N must be at least zero.
*           Unchanged on exit.
*
*  T      - COMPLEX*16 array of DIMENSION ( LDT, n ).
*           Before entry with  UPLO = 'U' or 'u', the leading n by n
*           upper triangular part of the array T must contain the upper
*           triangular matrix and the strictly lower triangular part of
*           T is not referenced.
*           Before entry with UPLO = 'L' or 'l', the leading n by n
*           lower triangular part of the array T must contain the lower
*           triangular matrix and the strictly upper triangular part of
*           T is not referenced.
*
*  LDT    - INTEGER.
*           On entry, LDA specifies the first dimension of A as declared
*           in the calling (sub) program. LDA must be at least
*           max( 1, n ).
*           Unchanged on exit.
*
*  X      - COMPLEX*16 array of dimension at least
*           ( 1 + ( n - 1 )*abs( INCX ) ).
*           On exit, X = T' * y
*
*  INCX   - INTEGER.
*           On entry, INCX specifies the increment for the elements of
*           X. INCX must not be zero.
*           Unchanged on exit.
*
*  Y      - COMPLEX*16 array of dimension at least
*           ( 1 + ( n - 1 )*abs( INCY ) ).
*           Before entry, the incremented array Y must contain the n
*           element vector y.  Unchanged on exit.
*
*  INCY   - INTEGER.
*           On entry, INCY specifies the increment for the elements of
*           Y. INCY must not be zero.
*           Unchanged on exit.
*
*  W      - COMPLEX*16 array of dimension at least
*           ( 1 + ( n - 1 )*abs( INCW ) ).
*           On exit, W = T * z
*
*  INCW   - INTEGER.
*           On entry, INCW specifies the increment for the elements of
*           W. INCW must not be zero.
*           Unchanged on exit.
*
*  Z      - COMPLEX*16 array of dimension at least
*           ( 1 + ( n - 1 )*abs( INCZ ) ).
*           Before entry, the incremented array Z must contain the n
*           element vector z.  Unchanged on exit.
*
*  INCY   - INTEGER.
*           On entrz, INCY specifies the increment for the elements of
*           Y. INCY must not be zero.
*           Unchanged on exit.
*
*
*  Level 2 Blas routine.
*
*
*     .. Local Scalars ..
      INTEGER            INFO
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      EXTERNAL           lsame
*     ..
*     .. External Subroutines ..
      EXTERNAL           xerbla, zcopy, ztrmv
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
      IF( .NOT.lsame( uplo, 'U' ) .AND. .NOT.lsame( uplo, 'L' ) ) THEN
         info = 1
      ELSE IF( n.LT.0 ) THEN
         info = 2
      ELSE IF( ldt.LT.max( 1, n ) ) THEN
         info = 4
      ELSE IF( incw.EQ.0 ) THEN
         info = 6
      ELSE IF( incx.EQ.0 ) THEN
         info = 8
      ELSE IF( incy.EQ.0 ) THEN
         info = 10
      ELSE IF( incz.EQ.0 ) THEN
         info = 12
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'ZTRMVT', info )
         RETURN
      END IF
*
*     Quick return if possible.
*
      IF( n.EQ.0 )
     $   RETURN
*
*
*
      IF( incx.NE.1 .OR. incy.NE.1 .OR. incw.NE.1 .OR. incz.NE.1 .OR.
     $    .true. ) THEN
         CALL zcopy( n, y, incy, x, incx )
         CALL ztrmv( uplo, 'C', 'N', n, t, ldt, x, incx )
         CALL zcopy( n, z, incz, w, incw )
         CALL ztrmv( uplo, 'N', 'N', n, t, ldt, w, incw )
         RETURN
      END IF
*
      RETURN
*
*     End of ZTRMVT.
*

Here is the caller graph for this function: