dagemv.f

Go to the documentation of this file.

      SUBROUTINE dagemv( TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y,
     $                   INCY )
*
*  -- PBLAS auxiliary routine (version 2.0) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     April 1, 1998
*
*     .. Scalar Arguments ..
      CHARACTER*1        TRANS
      INTEGER            INCX, INCY, LDA, M, N
      DOUBLE PRECISION   ALPHA, BETA
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   A( LDA, * ), X( * ), Y( * )
*     ..
*
*  Purpose
*  =======
*
*  DAGEMV performs one of the matrix-vector operations
*
*     y := abs( alpha )*abs( A )*abs( x )+ abs( beta*y ),
*
*     or
*
*     y := abs( alpha )*abs( A' )*abs( x ) + abs( beta*y ),
*
*  where  alpha  and  beta  are real scalars, y is a real vector, x is a
*  vector and A is an m by n matrix.
*
*  Arguments
*  =========
*
*  TRANS   (input) CHARACTER*1
*          On entry,  TRANS  specifies the  operation to be performed as
*          follows:
*
*             TRANS = 'N' or 'n':
*                y := abs( alpha )*abs( A )*abs( x )+ abs( beta*y )
*
*             TRANS = 'T' or 't':
*                y := abs( alpha )*abs( A' )*abs( x ) + abs( beta*y )
*
*             TRANS = 'C' or 'c':
*                y := abs( alpha )*abs( A' )*abs( x ) + abs( beta*y )
*
*  M       (input) INTEGER
*          On entry, M  specifies the number of rows of the matrix  A. M
*          must be at least zero.
*
*  N       (input) INTEGER
*          On entry, N  specifies the number of columns of the matrix A.
*          N must be at least zero.
*
*  ALPHA   (input) DOUBLE PRECISION
*          On entry, ALPHA specifies the real scalar alpha.
*
*  A       (input) DOUBLE PRECISION array of dimension ( LDA, n ).
*          On entry, A  is an array of dimension ( LDA, N ). The leading
*          m by n part of the array  A  must contain the matrix of coef-
*          ficients.
*
*  LDA     (input) INTEGER
*          On entry, LDA specifies the leading dimension of the array A.
*          LDA must be at least max( 1, M ).
*
*  X       (input) DOUBLE PRECISION array of dimension at least
*          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' and  at
*          least ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.  Before entry,
*          the incremented array X must contain the vector x.
*
*  INCX    (input) INTEGER
*          On entry, INCX specifies the increment for the elements of X.
*          INCX must not be zero.
*
*  BETA    (input) DOUBLE PRECISION
*          On entry,  BETA  specifies the real scalar beta. When BETA is
*          supplied as zero then Y need not be set on input.
*
*  Y       (input/output) DOUBLE PRECISION array of dimension at least
*          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = '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, the incremented array  Y is overwritten by
*          the updated vector y.
*
*  INCY    (input) INTEGER
*          On entry, INCY specifies the increment for the elements of Y.
*          INCY must not be zero.
*
*  -- Written on April 1, 1998 by
*     Antoine Petitet, University  of  Tennessee, Knoxville 37996, USA.
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ONE, ZERO
      parameter( one = 1.0d+0, zero = 0.0d+0 )
*     ..
*     .. Local Scalars ..
      INTEGER            I, INFO, IX, IY, J, JX, JY, KX, KY, LENX, LENY
      DOUBLE PRECISION   ABSX, TALPHA, TEMP
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      EXTERNAL           lsame
*     ..
*     .. External Subroutines ..
      EXTERNAL           xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, max
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
      IF( .NOT.lsame( trans, 'N' ) .AND.
     $    .NOT.lsame( trans, 'T' ) .AND.
     $    .NOT.lsame( trans, 'C' ) ) THEN
         info = 1
      ELSE IF( m.LT.0 ) THEN
         info = 2
      ELSE IF( n.LT.0 ) THEN
         info = 3
      ELSE IF( lda.LT.max( 1, m ) ) THEN
         info = 6
      ELSE IF( incx.EQ.0 ) THEN
         info = 8
      ELSE IF( incy.EQ.0 ) THEN
         info = 11
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'DAGEMV', info )
         RETURN
      END IF
*
*     Quick return if possible.
*
      IF( ( m.EQ.0 ).OR.( n.EQ.0 ).OR.
     $    ( ( alpha.EQ.zero ).AND.( beta.EQ.one ) ) )
     $   RETURN
*
*     Set  LENX  and  LENY, the lengths of the vectors x and y, and set
*     up the start points in  X  and  Y.
*
      IF( lsame( trans, 'N' ) ) THEN
         lenx = n
         leny = m
      ELSE
         lenx = m
         leny = n
      END IF
      IF( incx.GT.0 ) THEN
         kx = 1
      ELSE
         kx = 1 - ( lenx - 1 )*incx
      END IF
      IF( incy.GT.0 ) THEN
         ky = 1
      ELSE
         ky = 1 - ( leny - 1 )*incy
      END IF
*
*     Start the operations. In this version the elements of A are
*     accessed sequentially with one pass through A.
*
*     First form  y := abs( beta*y ).
*
      IF( incy.EQ.1 ) THEN
         IF( beta.EQ.zero ) THEN
            DO 10, i = 1, leny
               y( i ) = zero
   10       CONTINUE
         ELSE IF( beta.EQ.one ) THEN
            DO 20, i = 1, leny
               y( i ) = abs( y( i ) )
   20       CONTINUE
         ELSE
            DO 30, i = 1, leny
               y( i ) = abs( beta * y( i ) )
   30       CONTINUE
         END IF
      ELSE
         iy = ky
         IF( beta.EQ.zero ) THEN
            DO 40, i = 1, leny
               y( iy ) = zero
               iy      = iy + incy
   40       CONTINUE
         ELSE IF( beta.EQ.one ) THEN
            DO 50, i = 1, leny
               y( iy ) = abs( y( iy ) )
               iy      = iy + incy
   50       CONTINUE
         ELSE
            DO 60, i = 1, leny
               y( iy ) = abs( beta * y( iy ) )
               iy      = iy + incy
   60       CONTINUE
         END IF
      END IF
*
      IF( alpha.EQ.zero )
     $   RETURN
*
      talpha = abs( alpha )
*
      IF( lsame( trans, 'N' ) ) THEN
*
*        Form  y := abs( alpha ) * abs( A ) * abs( x ) + y.
*
         jx = kx
         IF( incy.EQ.1 ) THEN
            DO 80, j = 1, n
               absx = abs( x( jx ) )
               IF( absx.NE.zero ) THEN
                  temp = talpha * absx
                  DO 70, i = 1, m
                     y( i ) = y( i ) + temp * abs( a( i, j ) )
   70             CONTINUE
               END IF
               jx = jx + incx
   80       CONTINUE
         ELSE
            DO 100, j = 1, n
               absx = abs( x( jx ) )
               IF( absx.NE.zero ) THEN
                  temp = talpha * absx
                  iy   = ky
                  DO 90, i = 1, m
                     y( iy ) = y( iy ) + temp * abs( a( i, j ) )
                     iy      = iy      + incy
   90             CONTINUE
               END IF
               jx = jx + incx
  100       CONTINUE
         END IF
*
      ELSE
*
*        Form  y := abs( alpha ) * abs( A' ) * abs( x ) + y.
*
         jy = ky
         IF( incx.EQ.1 ) THEN
            DO 120, j = 1, n
               temp = zero
               DO 110, i = 1, m
                  temp = temp + abs( a( i, j ) * x( i ) )
  110          CONTINUE
               y( jy ) = y( jy ) + talpha * temp
               jy      = jy      + incy
  120       CONTINUE
         ELSE
            DO 140, j = 1, n
               temp = zero
               ix   = kx
               DO 130, i = 1, m
                  temp = temp + abs( a( i, j ) * x( ix ) )
                  ix   = ix   + incx
  130          CONTINUE
               y( jy ) = y( jy ) + talpha * temp
               jy      = jy      + incy
  140       CONTINUE
         END IF
      END IF
*
      RETURN
*
*     End of DAGEMV
*
      END