subroutine csbmv	(	character	UPLO,
		integer	N,
		integer	K,
		complex	ALPHA,
		complex, dimension( lda, * )	A,
		integer	LDA,
		complex, dimension( * )	X,
		integer	INCX,
		complex	BETA,
		complex, dimension( * )	Y,
		integer	INCY
	)

CSBMV

Purpose:

 CSBMV  performs the matrix-vector  operation

    y := alpha*A*x + beta*y,

 where alpha and beta are scalars, x and y are n element vectors and
 A is an n by n symmetric band matrix, with k super-diagonals.

  UPLO   - CHARACTER*1
           On entry, UPLO specifies whether the upper or lower
           triangular part of the band matrix A is being supplied as
           follows:

              UPLO = 'U' or 'u'   The upper triangular part of A is
                                  being supplied.

              UPLO = 'L' or 'l'   The lower triangular part of A is
                                  being supplied.

           Unchanged on exit.

  N      - INTEGER
           On entry, N specifies the order of the matrix A.
           N must be at least zero.
           Unchanged on exit.

  K      - INTEGER
           On entry, K specifies the number of super-diagonals of the
           matrix A. K must satisfy  0 .le. K.
           Unchanged on exit.

  ALPHA  - COMPLEX
           On entry, ALPHA specifies the scalar alpha.
           Unchanged on exit.

  A      - COMPLEX array, dimension( LDA, N )
           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
           by n part of the array A must contain the upper triangular
           band part of the symmetric matrix, supplied column by
           column, with the leading diagonal of the matrix in row
           ( k + 1 ) of the array, the first super-diagonal starting at
           position 2 in row k, and so on. The top left k by k triangle
           of the array A is not referenced.
           The following program segment will transfer the upper
           triangular part of a symmetric band matrix from conventional
           full matrix storage to band storage:

                 DO 20, J = 1, N
                    M = K + 1 - J
                    DO 10, I = MAX( 1, J - K ), J
                       A( M + I, J ) = matrix( I, J )
              10    CONTINUE
              20 CONTINUE

           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
           by n part of the array A must contain the lower triangular
           band part of the symmetric matrix, supplied column by
           column, with the leading diagonal of the matrix in row 1 of
           the array, the first sub-diagonal starting at position 1 in
           row 2, and so on. The bottom right k by k triangle of the
           array A is not referenced.
           The following program segment will transfer the lower
           triangular part of a symmetric band matrix from conventional
           full matrix storage to band storage:

                 DO 20, J = 1, N
                    M = 1 - J
                    DO 10, I = J, MIN( N, J + K )
                       A( M + I, J ) = matrix( I, J )
              10    CONTINUE
              20 CONTINUE

           Unchanged on exit.

  LDA    - INTEGER
           On entry, LDA specifies the first dimension of A as declared
           in the calling (sub) program. LDA must be at least
           ( k + 1 ).
           Unchanged on exit.

  X      - COMPLEX array, dimension at least
           ( 1 + ( N - 1 )*abs( INCX ) ).
           Before entry, the incremented array X must contain the
           vector x.
           Unchanged on exit.

  INCX   - INTEGER
           On entry, INCX specifies the increment for the elements of
           X. INCX must not be zero.
           Unchanged on exit.

  BETA   - COMPLEX
           On entry, BETA specifies the scalar beta.
           Unchanged on exit.

  Y      - COMPLEX array, dimension at least
           ( 1 + ( N - 1 )*abs( INCY ) ).
           Before entry, the incremented array Y must contain the
           vector y. On exit, Y is overwritten by the updated vector y.

  INCY   - INTEGER
           On entry, INCY specifies the increment for the elements of
           Y. INCY must not be zero.
           Unchanged on exit.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

November 2011

Definition at line 154 of file csbmv.f.

*
*  -- LAPACK test routine (version 3.4.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2011
*
*     .. Scalar Arguments ..
      CHARACTER          uplo
      INTEGER            incx, incy, k, lda, n
      COMPLEX            alpha, beta
*     ..
*     .. Array Arguments ..
      COMPLEX            a( lda, * ), x( * ), y( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      COMPLEX            one
      parameter                ( one = ( 1.0e+0, 0.0e+0 ) )
      COMPLEX            zero
      parameter                ( zero = ( 0.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      INTEGER            i, info, ix, iy, j, jx, jy, kplus1, kx, ky, l
      COMPLEX            temp1, temp2
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      EXTERNAL           lsame
*     ..
*     .. External Subroutines ..
      EXTERNAL           xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min
*     ..
*     .. 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( k.LT.0 ) THEN
         info = 3
      ELSE IF( lda.LT.( k+1 ) ) THEN
         info = 6
      ELSE IF( incx.EQ.0 ) THEN
         info = 8
      ELSE IF( incy.EQ.0 ) THEN
         info = 11
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'CSBMV ', info )
         RETURN
      END IF
*
*     Quick return if possible.
*
      IF( ( n.EQ.0 ) .OR. ( ( alpha.EQ.zero ) .AND. ( beta.EQ.one ) ) )
     $   RETURN
*
*     Set up the start points in  X  and  Y.
*
      IF( incx.GT.0 ) THEN
         kx = 1
      ELSE
         kx = 1 - ( n-1 )*incx
      END IF
      IF( incy.GT.0 ) THEN
         ky = 1
      ELSE
         ky = 1 - ( n-1 )*incy
      END IF
*
*     Start the operations. In this version the elements of the array A
*     are accessed sequentially with one pass through A.
*
*     First form  y := beta*y.
*
      IF( beta.NE.one ) THEN
         IF( incy.EQ.1 ) THEN
            IF( beta.EQ.zero ) THEN
               DO 10 i = 1, n
                  y( i ) = zero
   10          CONTINUE
            ELSE
               DO 20 i = 1, n
                  y( i ) = beta*y( i )
   20          CONTINUE
            END IF
         ELSE
            iy = ky
            IF( beta.EQ.zero ) THEN
               DO 30 i = 1, n
                  y( iy ) = zero
                  iy = iy + incy
   30          CONTINUE
            ELSE
               DO 40 i = 1, n
                  y( iy ) = beta*y( iy )
                  iy = iy + incy
   40          CONTINUE
            END IF
         END IF
      END IF
      IF( alpha.EQ.zero )
     $   RETURN
      IF( lsame( uplo, 'U' ) ) THEN
*
*        Form  y  when upper triangle of A is stored.
*
         kplus1 = k + 1
         IF( ( incx.EQ.1 ) .AND. ( incy.EQ.1 ) ) THEN
            DO 60 j = 1, n
               temp1 = alpha*x( j )
               temp2 = zero
               l = kplus1 - j
               DO 50 i = max( 1, j-k ), j - 1
                  y( i ) = y( i ) + temp1*a( l+i, j )
                  temp2 = temp2 + a( l+i, j )*x( i )
   50          CONTINUE
               y( j ) = y( j ) + temp1*a( kplus1, j ) + alpha*temp2
   60       CONTINUE
         ELSE
            jx = kx
            jy = ky
            DO 80 j = 1, n
               temp1 = alpha*x( jx )
               temp2 = zero
               ix = kx
               iy = ky
               l = kplus1 - j
               DO 70 i = max( 1, j-k ), j - 1
                  y( iy ) = y( iy ) + temp1*a( l+i, j )
                  temp2 = temp2 + a( l+i, j )*x( ix )
                  ix = ix + incx
                  iy = iy + incy
   70          CONTINUE
               y( jy ) = y( jy ) + temp1*a( kplus1, j ) + alpha*temp2
               jx = jx + incx
               jy = jy + incy
               IF( j.GT.k ) THEN
                  kx = kx + incx
                  ky = ky + incy
               END IF
   80       CONTINUE
         END IF
      ELSE
*
*        Form  y  when lower triangle of A is stored.
*
         IF( ( incx.EQ.1 ) .AND. ( incy.EQ.1 ) ) THEN
            DO 100 j = 1, n
               temp1 = alpha*x( j )
               temp2 = zero
               y( j ) = y( j ) + temp1*a( 1, j )
               l = 1 - j
               DO 90 i = j + 1, min( n, j+k )
                  y( i ) = y( i ) + temp1*a( l+i, j )
                  temp2 = temp2 + a( l+i, j )*x( i )
   90          CONTINUE
               y( j ) = y( j ) + alpha*temp2
  100       CONTINUE
         ELSE
            jx = kx
            jy = ky
            DO 120 j = 1, n
               temp1 = alpha*x( jx )
               temp2 = zero
               y( jy ) = y( jy ) + temp1*a( 1, j )
               l = 1 - j
               ix = jx
               iy = jy
               DO 110 i = j + 1, min( n, j+k )
                  ix = ix + incx
                  iy = iy + incy
                  y( iy ) = y( iy ) + temp1*a( l+i, j )
                  temp2 = temp2 + a( l+i, j )*x( ix )
  110          CONTINUE
               y( jy ) = y( jy ) + alpha*temp2
               jx = jx + incx
               jy = jy + incy
  120       CONTINUE
         END IF
      END IF
*
      RETURN
*
*     End of CSBMV
*

Here is the call graph for this function: