sgbmv, ddbmv, cgbmv, zgbmv 

Matrix-vector product for a general band matrix

FORMAT

  {S,D,C,Z}GBMV (trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)

Arguments

  trans               character*1
                      On entry, specifies the operation to be performed:

                      If trans = 'N' or 'n', the operation is y  =  alpha*Ax
                      + beta*y.

                      If trans = 'T' or 't', the operation is y  =
                      alpha*transp(A)*x + beta*y.

                      If trans = 'C' or 'c', the operation is y  =
                      alpha*conjug_transp(A)*x + beta*y.
                      On exit, trans is unchanged.

  m                   integer*4
                      On entry, the number of rows of the matrix A; m >= 0.
                      On exit, m is unchanged.

  n                   integer*4
                      On entry, the number of columns of the matrix A; n >=
                      0.
                      On exit, n is unchanged.

  kl                  integer*4
                      On entry, the number of sub-diagonals of the matrix A;
                      kl >= 0.
                      On exit, kl is unchanged.

  ku                  integer*4
                      On entry, the number of super-diagonals of the matrix
                      A; ku >= 0.
                      On exit, ku is unchanged.

  alpha               real*4 | real*8 | complex*8 | complex*16
                      On entry, the scalar alpha*.
                      On exit, alpha is unchanged.

  a                   real*4 | real*8 | complex*8 | complex*16
                      On entry, a two-dimensional array with dimensions lda
                      by n. The leading m by n part of the array contains the
                      elements of the matrix A, supplied column by column.
                      The leading diagonal of the matrix is stored in row (ku
                      + 1) of the array, the first super-diagonal is stored
                      in row ku starting at position 2,  the first sub-
                      diagonal is stored in row (ku + 2) starting at position
                      1,  and so on. Elements in the array A that do not
                      correspond to elements in the matrix (such as the top
                      left ku by ku triangle) are not referenced.
                      On exit, a is unchanged.

  lda                 integer*4
                      On entry, the first dimension of array A; lda >=
                      (kl+ku+1).
                      On exit, lda is unchanged.

  x                   real*4 | real*8 | complex*8 | complex*16
                      On entry, a one-dimensional array containing the vector
                      x.  When trans is equal to 'N' or (1+(n-1)*|incx|).
                      Otherwise, the length is at least (1+(m-1)*|incx|).
                      On exit, x is unchanged.

  incx                integer*4
                      On entry, the increment for the elements of X; incx
                      must not equal zero.
                      On exit, incx is unchanged.

  beta                real*4 | real*8 | complex*8 | complex*16
                      On entry, the scalar beta.
                      On exit, beta is unchanged.

  y                   real*4 | real*8 | complex*8 | complex*16
                      On entry, a one-dimensional array containing the vector
                      x.  When trans is equal to 'N' or (1+(m-1)*|incy|).
                      Otherwise, the length is at least (1+(n-1)*|incy|).

                      If beta= 0, y need not be set. If beta is not equal to
                      zero, the incremented array Y must contain the vector
                      y.
                      On exit, y is overwritten by the updated vector y.

  incy                integer*4
                      On entry, the increment for the elements of Y; incy
                      must not equal zero.
                      On exit, incy is unchanged.

Description

  The _GBMV subprograms compute a matrix-vector product for either a general
  band matrix or its transpose: y  =  alpha*Ax + beta*y
    y  =  alpha*transp(A)*x + beta*y

  In addition to these operations, the CGBMV and ZGBMV subprograms compute a
  matrix-vector product for the conjugate transpose:
    y  =  alpha*conjug_transp(A)*x + beta*y

  alphaand betaare scalars, x and y are vectors, and A is an m by n band
  matrix.

Example

  COMPLEX*16 A(5,20), X(20), Y(20), alpha, beta
  M = 5
  N = 20
  KL = 2
  KU = 2
  alpha = (1.0D0, 2.0D0)
  LDA = 5
  INCX = 1
  beta = (0.0D0, 0.0D0)
  INCY = 1
  CALL ZGBMV('N',M,N,KL,KU,alpha,A,LDA,X,INCX,beta,Y,INCY)

  This FORTRAN code multiplies a pentadiagonal matrix A by the vector x to
  get the vector y.  The operation is y  =  Ax.  where A is stored in banded
  storage form.