gbmv(3F)

dgbmv, sgbmv, zgbmv, cgbmv - BLAS Level Two Matrix-Vector Product

As shipped in IRIX 6.5. First release of IRIX 6.5.

NAME
     dgbmv, sgbmv, zgbmv, cgbmv - BLAS Level Two Matrix-Vector Product


FORTRAN 77 SYNOPSIS
     subroutine dgbmv( trans,m,n,kl,ku,alpha,a,lda,x,incx,beta,y,incy )
           character*1        trans
           integer            n, m, kl, ku, lda, incx, incy
           double precision   alpha, beta
           double precision   a( lda,*), x(*), y(*)

     subroutine sgbmv( trans,m,n,kl,ku,alpha,a,lda,x,incx,beta,y,incy )
           character*1        trans
           integer            n, m, kl, ku, lda, incx, incy
           real               alpha, beta
           real               a( lda,*), x(*), y(*)

     subroutine zgbmv( trans,m,n,kl,ku,alpha,a,lda,x,incx,beta,y,incy )
           character*1        trans
           integer            n, m, kl, ku, lda, incx, incy
           double complex     alpha, beta
           double complex     a( lda,*), x(*), y(*)

     subroutine cgbmv( trans,m,n,kl,ku,alpha,a,lda,x,incx,beta,y,incy )
           character*1        trans
           integer            n, m, kl, ku, lda, incx, incy
           complex            alpha, beta
           complex            a( lda,*), x(*), y(*)


C SYNOPSIS
     void dgbmv( trans,m,n,kl,ku,alpha,a,lda,x,incx,beta,y,incy )
           MatrixTranspose    trans;
           Integer            n, m, kl, ku, lda, incx, incy;
           double             alpha, beta;
           double             (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void sgbmv( trans,m,n,kl,ku,alpha,a,lda,x,incx,beta,y,incy )
           MatrixTranspose    trans;
           Integer            n, m, kl, ku, lda, incx, incy;
           float              alpha, beta;
           float              (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void zgbmv( trans,m,n,kl,ku,alpha,a,lda,x,incx,beta,y,incy )
           MatrixTranspose    trans;
           Integer            n, m, kl, ku, lda, incx, incy;
           Zomplex            alpha, beta;
           Zomplex            (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void cgbmv( trans,m,n,kl,ku,alpha,a,lda,x,incx,beta,y,incy )
           MatrixTranspose    trans;
           Integer            n, m, kl, ku, lda, incx, incy;
           Complex            alpha, beta;
           Complex            (*a)[lda*n], (*x)[ n ], (*y)[ n ];


DESCRIPTION
     dgbmv, sgbmv, zgbmv and cgbmv perform one of the matrix-vector
     operations:

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

           y := alpha*conjg( A' )*x + beta*y,

     where alpha and beta are scalars, x and y are vectors and A is an m by n
     band matrix, with kl sub-diagonals and ku super-diagonals.


PARAMETERS
     trans   On entry, trans specifies the operation to be performed as
             follows:

             FORTRAN
             trans = 'N' or 'n'       y := alpha*A*x + beta*y.
             trans = 'T' or 't'       y := alpha*A'*x + beta*y.
             trans = 'C' or 'c'       y := alpha*conjg( A' )*x + beta*y.

             C
             trans = NoTranspose           y := alpha*A*x + beta*y.
             trans = Transpose             y := alpha*A'*x + beta*y.
             trans = ConjugateTranspose    y := alpha*conjg( A' )*x + beta*y.

             Unchanged on exit.

     m       On entry, m specifies the number of rows of rows of the matrix A.
             m must be at least zero.
             Unchanged on exit.

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

     kl      On entry, kl specifies the number of sub-diagonals of the matrix
             A.  kl must satisfy 0 .le. kl.
             Unchanged on exit.

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

     alpha   On entry, alpha specifies the scalar alpha.
             Unchanged on exit.

     a       An array containing the matrix A.

             FORTRAN
             Array of dimension ( lda, n ).

             C
             A pointer to an array of size lda*n containing the matrix A.
             See note below about array storage convention for C.

             Before entry, the leading ( kl + ku + 1 ) by n part of the array
             a must contain the matrix of coefficients, supplied column by
             column, with the leading diagonal of the matrix in row ( ku + 1 )
             of the array, the first super-diagonal starting at position 2 in
             row ku, the first sub-diagonal starting at position 1 in row ( ku
             + 2 ), and so on.  Elements in the array a that do not correspond
             to elements in the band matrix (such as the top left ku by ku
             triangle) are not referenced.  The following program segment will
             transfer a band matrix from conventional full matrix storage to
             band storage:


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

             C
                         for ( j=0; j<n; j++ )
                         {
                               k = ku - j;
                               for (i = MAX(0, j-ku); i < MIN(m, j+kl); i++ )
                                     a(j*lda+k+i) = Matrix(j*ldm+i);
                         }

             Unchanged on exit.

     lda     On entry, lda specifies the first dimension of A as declared in
             the calling (sub) program.  lda must be at least ( kl + ku + 1 ).
             Unchanged on exit.

     x       Array of size at least ( 1 + ( n - 1 )*abs( incx ) ) when trans =
             'N' or 'n' or NoTranspose and at least ( 1 + ( m - 1 )*abs( incx
             ) ) otherwise.  Before entry, the incremented array x must
             contain the vector x.
             Unchanged on exit.

     incx    On entry, incx specifies the increment for the elements of x.
             incx must not be zero.
             Unchanged on exit.
     beta    On entry, beta specifies the scalar beta. When beta is supplied
             as zero then y need not be set on input.
             Unchanged on exit.

     y       Array of size at least ( 1 + ( m - 1 )*abs( incy ) ) when trans =
             'N' or 'n' or NoTranspose and at least ( 1 + ( n - 1 )*abs( incy
             ) ) otherwise.

             Before entry with beta non-zero, the incremented array y must
             contain the vector y. On exit, y is overwritten by the updated
             vector y.

     incy    On entry, incy specifies the increment for the elements of y.
             incy must not be zero.
             Unchanged on exit.


C ARRAY STORAGE CONVENTION
       The matrices  are assumed  to be stored in a  one dimensional C array
       in an analogous fashion as a Fortran array (column major). Therefore,
       the element  A(i+1,j)  of matrix A  is stored  immediately  after the
       element  A(i,j), while  A(i,j+1) is lda  elements apart from  A(i,j).
       The element A(i,j) of the matrix can be accessed directly by reference
       to  a[ (j-1)*lda + (i-1) ].


AUTHORS
          Jack Dongarra, Argonne National Laboratory.
          Iain Duff, AERE Harwell.
          Jeremy Du Croz, Numerical Algorithms Group Ltd.
          Sven Hammarling, Numerical Algorithms Group Ltd.


TUNING
          Optimized and parallelized for SGI R3000, R4x00 and R8000 platforms.