zgemv (3p)

Name

zgemv - vector operations y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y, or y := alpha*conjg( A' )*x + beta*y

Synopsis

SUBROUTINE ZGEMV(TRANSA, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)

CHARACTER*1 TRANSA
DOUBLE COMPLEX ALPHA, BETA
DOUBLE COMPLEX A(LDA,*), X(*), Y(*)
INTEGER M, N, LDA, INCX, INCY

SUBROUTINE ZGEMV_64(TRANSA, M, N, ALPHA, A, LDA, X, INCX, BETA, Y,
INCY)

CHARACTER*1 TRANSA
DOUBLE COMPLEX ALPHA, BETA
DOUBLE COMPLEX A(LDA,*), X(*), Y(*)
INTEGER*8 M, N, LDA, INCX, INCY




F95 INTERFACE
SUBROUTINE GEMV(TRANSA, M, N, ALPHA, A, LDA, X, INCX, BETA,
Y, INCY)

CHARACTER(LEN=1) :: TRANSA
COMPLEX(8) :: ALPHA, BETA
COMPLEX(8), DIMENSION(:) :: X, Y
COMPLEX(8), DIMENSION(:,:) :: A
INTEGER :: M, N, LDA, INCX, INCY

SUBROUTINE GEMV_64(TRANSA, M, N, ALPHA, A, LDA, X, INCX,
BETA, Y, INCY)

CHARACTER(LEN=1) :: TRANSA
COMPLEX(8) :: ALPHA, BETA
COMPLEX(8), DIMENSION(:) :: X, Y
COMPLEX(8), DIMENSION(:,:) :: A
INTEGER(8) :: M, N, LDA, INCX, INCY




C INTERFACE
#include <sunperf.h>

void  zgemv(char transa, int m, int n, doublecomplex *alpha, doublecom-
plex *a, int lda, doublecomplex *x, int  incx,  doublecomplex
*beta, doublecomplex *y, int incy);

void  zgemv_64(char  transa, long m, long n, doublecomplex *alpha, dou-
blecomplex *a, long lda, doublecomplex *x, long incx, double-
complex *beta, doublecomplex *y, long incy);

Description

Oracle Solaris Studio Performance Library                            zgemv(3P)



NAME
       zgemv  - 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


SYNOPSIS
       SUBROUTINE ZGEMV(TRANSA, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)

       CHARACTER*1 TRANSA
       DOUBLE COMPLEX ALPHA, BETA
       DOUBLE COMPLEX A(LDA,*), X(*), Y(*)
       INTEGER M, N, LDA, INCX, INCY

       SUBROUTINE ZGEMV_64(TRANSA, M, N, ALPHA, A, LDA, X, INCX, BETA, Y,
             INCY)

       CHARACTER*1 TRANSA
       DOUBLE COMPLEX ALPHA, BETA
       DOUBLE COMPLEX A(LDA,*), X(*), Y(*)
       INTEGER*8 M, N, LDA, INCX, INCY




   F95 INTERFACE
       SUBROUTINE GEMV(TRANSA, M, N, ALPHA, A, LDA, X, INCX, BETA,
              Y, INCY)

       CHARACTER(LEN=1) :: TRANSA
       COMPLEX(8) :: ALPHA, BETA
       COMPLEX(8), DIMENSION(:) :: X, Y
       COMPLEX(8), DIMENSION(:,:) :: A
       INTEGER :: M, N, LDA, INCX, INCY

       SUBROUTINE GEMV_64(TRANSA, M, N, ALPHA, A, LDA, X, INCX,
              BETA, Y, INCY)

       CHARACTER(LEN=1) :: TRANSA
       COMPLEX(8) :: ALPHA, BETA
       COMPLEX(8), DIMENSION(:) :: X, Y
       COMPLEX(8), DIMENSION(:,:) :: A
       INTEGER(8) :: M, N, LDA, INCX, INCY




   C INTERFACE
       #include <sunperf.h>

       void  zgemv(char transa, int m, int n, doublecomplex *alpha, doublecom-
                 plex *a, int lda, doublecomplex *x, int  incx,  doublecomplex
                 *beta, doublecomplex *y, int incy);

       void  zgemv_64(char  transa, long m, long n, doublecomplex *alpha, dou-
                 blecomplex *a, long lda, doublecomplex *x, long incx, double-
                 complex *beta, doublecomplex *y, long incy);



PURPOSE
       zgemv  performs  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 matrix.


ARGUMENTS
       TRANSA (input)
                 On entry, TRANSA specifies the operation to be  performed  as
                 follows:

                 TRANSA = 'N' or 'n'   y := alpha*A*x + beta*y.

                 TRANSA = 'T' or 't'   y := alpha*A'*x + beta*y.

                 TRANSA = 'C' or 'c'   y := alpha*conjg( A' )*x + beta*y.

                 Unchanged on exit.


       M (input)
                 On  entry, M specifies the number of rows of the matrix A.  M
                 >= 0.  Unchanged on exit.


       N (input)
                 On entry, N specifies the number of columns of the matrix  A.
                 N >= 0.  Unchanged on exit.


       ALPHA (input)
                 On  entry,  ALPHA  specifies  the scalar alpha.  Unchanged on
                 exit.


       A (input)
                 Before entry, the leading m by n part of  the  array  A  must
                 contain the matrix of coefficients.  Unchanged on exit.


       LDA (input)
                 On  entry, LDA specifies the first dimension of A as declared
                 in the calling (sub) program. LDA >= max( 1, m ).   Unchanged
                 on exit.


       X (input)
                 ( 1 + ( n - 1 )*abs( INCX ) ) when TRANSA = 'N' or 'n' and at
                 least ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.  Before entry,
                 the incremented array X must contain the vector x.  Unchanged
                 on exit.


       INCX (input)
                 On entry, INCX specifies the increment for the elements of X.
                 INCX must not be zero.  Unchanged on exit.


       BETA (input)
                 On  entry,  BETA specifies the scalar beta. When BETA is sup-
                 plied as zero then Y need not be set on input.  Unchanged  on
                 exit.


       Y (input/output)
                 ( 1 + ( m - 1 )*abs( INCY ) ) when TRANSA = 'N' or 'n' 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 (input)
                 On entry, INCY specifies the increment for the elements of Y.
                 INCY must not be zero.  Unchanged on exit.




                                  7 Nov 2015                         zgemv(3P)