sgemv, dgemv, cgemv, zgemv 

Matrix-vector product for a general matrix

FORMAT

  {S,D,C,Z}GEMV (trans, m, n, 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.

  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.
                      On exit, a is unchanged.

  lda                 integer*4
                      On entry, the first dimension of array A; lda >=
                      MAX(1,m).
                      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 _GEMV subprograms compute a matrix-vector product for either a general
  matrix or its transpose: y  =  alpha*Ax + beta*y
    y  =  alpha*transp(A)*x + beta*y

  In addition to these operations, the CGEMV and ZGEMV subprograms compute
  the 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 matrix.

EXAMPLES

  REAL*8 A(20,20), X(20), Y(20), alpha, beta
  INCX = 1
  INCY = 1
  LDA = 20
  M = 20
  N = 20
  alpha = 1.0D0
  beta = 0.0D0
  CALL DGEMV('T',M,N,alpha,A,LDA,X,INCX,beta,Y,INCY)

  This FORTRAN code computes the product y  =  transp(A)*x.

  COMPLEX*8 A(20,20), X(20), Y(20), alpha, beta
  INCX = 1
  INCY = 1
  LDA = 20
  M = 20
  N = 20
  alpha = (1.0, 1.0)
  beta = (0.0, 0.0)
  CALL CGEMV('T',M,N,alpha,A,LDA,X,INCX,beta,Y,INCY)

  This FORTRAN code computes the product y  =  transp(A)*x.