gemv(3F)

NAME
     SGEMV, DGEMV, CGEMV, ZGEMV - Multiplies a real or complex vector by a
     real or complex general matrix

SYNOPSIS
     Real

        CALL SGEMV (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

     Double precision

        CALL DGEMV (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

     Complex

        CALL CGEMV (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

     Double complex

        CALL ZGEMV (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

DESCRIPTION
     SGEMV and DGEMV multiply a real vector by a real general matrix.

     CGEMV and ZGEMV multiply a complex vector by a complex general matrix.

     These routines perform one of the following matrix-vector operations:

          y <-  alpha Ax + beta y

          y <-  alpha ATx + beta y

          y <-  alpha AHx + beta y

     where

     * where alpha and beta are scalars,

     * x and y are vectors

     * A is an m-by-n general matrix

     * AT is the transpose of A

     * AH is the conjugate transpose of A

     These routines have the following arguments:

     trans     Character*1.  (input)
               Specifies the operation to be performed:

               trans = 'N' or 'n':  y <- alpha Ax + beta y


               trans = 'T' or 't':  y  <-  alpha ATx + beta y


               trans = 'C' or 'c':  y <- alpha ATx + beta y (SGEMV, DGEMV),
               or

               y  <-  alpha AHx + beta y (CGEMV, ZGEMV)

     m         Integer.  (input)
               Specifies the number of rows in matrix A.  m >= 0.

     n         Integer.  (input)
               Specifies the number of columns in matrix A.  n >= 0.

     alpha     Scalar alpha.  (input)
               SGEMV: Real.
               DGEMV: Double precision.
               CGEMV: Complex.
               ZGEMV: Double complex.

     a         array of dimension (lda,n).  (input)
               SGEMV: Real array.
               DGEMV: Double precision array.
               CGEMV: Complex array.
               ZGEMV: Double complex array.
               Before entry, the leading m-by-n part of array a must
               contain the matrix of coefficients.

     lda       Integer.  (input)
               Specifies the first dimension of a as declared in the
               calling program.  lda >= MAX(1,m).

     x         Array of dimension 1+(n-1) * |incx| when trans = 'N' or 'n',
               and at least 1+(m-1) * |incx| otherwise.  (input)
               SGEMV: Real array.
               DGEMV: Double precision array.
               CGEMV: Complex array.
               ZGEMV: Double complex array.
               Contains the vector x.  Before entry, the incremented array
               x must contain the vector x.

     incx      Integer.  (input)
               Specifies the increment for the elements of x.  incx must
               not be 0.

     beta      Scalar beta.  (input)
               SGEMV: Real.
               DGEMV: Double precision.
               CGEMV: Complex.
               ZGEMV: Double complex.
               When beta is supplied as 0, y need not be set on input.

     y         Array of dimension 1+(m-1) * |incy| when trans = 'N' or 'n',
               and at least 1+(n-1) * |incy| otherwise.  (input) (input and
               output)
               SGEMV: Real array.
               DGEMV: Double precision array.
               CGEMV: Complex array.
               ZGEMV: Double complex array.
               Contains the vector y.  Before entry with beta as non-zero,
               the incremented array y must contain the vector y.  On exit,
               y is overwritten by the updated vector y.

     incy      Integer.  (input)
               Specifies the increment for the elements of y.  incy must
               not be 0.

NOTES
     SGEMV, DGEMV and CGEMV, ZGEMV are Level 2 Basic Linear Algebra
     Subprograms (Level 2 BLAS).

     When working backward (incx < 0 or incy < 0), each routine starts at
     the end of the vector and moves backward, as follows:

          x(1-incx * (n-1)), x(1-incx * (n-2)) , ..., x(1)

          y(1-incy * (n-1)), y(1-incy * (n-2)) , ..., y(1)