pdopbl3()

double precision function pdopbl3	(	character*7	subnam,
		integer	m,
		integer	n,
		integer	k
	)

Definition at line 1312 of file pblastim.f.

*
*  -- PBLAS test routine (version 2.0) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     April 1, 1998
*
*     .. Scalar Arguments ..
      CHARACTER*7        SUBNAM
      INTEGER            K, M, N
*     ..
*
*  Purpose
*  =======
*
*  PDOPBL3  computes  an  approximation  of the number of floating point
*  operations performed by a subroutine SUBNAM with the  given values of
*  the parameters M, N and K.
*
*  This version counts operations for the Level 3 PBLAS.
*
*  Arguments
*  =========
*
*  SUBNAM  (input) CHARACTER*7
*          On entry, SUBNAM specifies the name of the subroutine.
*
*  M       (input) INTEGER
*  N       (input) INTEGER
*  K       (input) INTEGER
*          On entry, M, N, and K  contain parameter  values  used by the
*          Level 3 PBLAS.  The output matrix is always M x N or N x N if
*          symmetric,  but  K  has different uses in different contexts.
*          For example, in the matrix-matrix multiply routine,  we  have
*          C = A * B where  C is M x N,  A is M x K, and  B is K x N. In
*          PxSYMM, PxHEMM, PxTRMM, and PxTRSM,  K  indicates whether the
*          matrix  A is applied on the left or right. If K <= 0, the ma-
*          trix is applied on the left, and if K > 0, on  the  right. In
*          PxTRADD, K  indicates  whether the matrix C is upper or lower
*          triangular. If K <= 0, the  matrix C is upper triangular, and
*          lower triangular otherwise.
*
*  -- Written on April 1, 1998 by
*     Antoine Petitet, University  of  Tennessee, Knoxville 37996, USA.
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ONE, SIX, TWO, ZERO
      parameter( one = 1.0d+0, six = 6.0d+0, two = 2.0d+0,
     $                   zero = 0.0d+0 )
*     ..
*     .. Local Scalars ..
      CHARACTER*1        C1
      CHARACTER*2        C2
      CHARACTER*3        C3
      DOUBLE PRECISION   ADDS, EK, EM, EN, MULTS
*     ..
*     .. External Functions ..
      LOGICAL            LSAME, LSAMEN
      EXTERNAL           lsame, lsamen
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          dble
*     ..
*     .. Executable Statements ..
*
*     Quick return if possible
*
      IF( m.LE.0 .OR. .NOT.( lsamen( 2, subnam, 'PS' ) .OR.
     $    lsamen( 2, subnam, 'PD' ) .OR. lsamen( 2, subnam, 'PC' )
     $   .OR. lsamen( 2, subnam, 'PZ' ) ) )
     $     THEN
         pdopbl3 = zero
         RETURN
      END IF
*
      c1 = subnam( 2: 2 )
      c2 = subnam( 3: 4 )
      c3 = subnam( 5: 7 )
      mults = zero
      adds  = zero
      em = dble( m )
      en = dble( n )
      ek = dble( k )
*
*     ----------------------
*     Matrix-matrix products
*        assume beta = 1
*     ----------------------
*
      IF( lsamen( 3, c3, 'MM ' ) ) THEN
*
         IF( lsamen( 2, c2, 'GE' ) ) THEN
*
            mults = em * ek * en
            adds  = em * ek * en
*
         ELSE IF( lsamen( 2, c2, 'SY' ) .OR.
     $            lsamen( 2, c2, 'HE' ) ) THEN
*
*           IF K <= 0, assume A multiplies B on the left.
*
            IF( k.LE.0 ) THEN
               mults = em * em * en
               adds  = em * em * en
            ELSE
               mults = em * en * en
               adds  = em * en * en
            END IF
*
         ELSE IF( lsamen( 2, c2, 'TR' ) ) THEN
*
*           IF K <= 0, assume A multiplies B on the left.
*
            IF( k.LE.0 ) THEN
               mults = en * em * ( em + one ) / two
               adds  = en * em * ( em - one ) / two
            ELSE
               mults = em * en * ( en + one ) / two
               adds  = em * en * ( en - one ) / two
            END IF
*
         END IF
*
*     ------------------------------------------------
*     Rank-K update of a symmetric or Hermitian matrix
*     ------------------------------------------------
*
      ELSE IF( lsamen( 3, c3, 'RK ' ) ) THEN
*
         IF( lsamen( 2, c2, 'SY' ) .OR.
     $       lsamen( 2, c2, 'HE' ) ) THEN
*
            mults = ek * em *( em + one ) / two
            adds  = ek * em *( em + one ) / two
         END IF
*
*     -------------------------------------------------
*     Rank-2K update of a symmetric or Hermitian matrix
*     -------------------------------------------------
*
      ELSE IF( lsamen( 3, c3, 'R2K' ) ) THEN
*
         IF( lsamen( 2, c2, 'SY' ) .OR.
     $       lsamen( 3, c2, 'HE' ) ) THEN
*
            mults = ek * em * em
            adds  = ek * em * em + em
         END IF
*
*     -----------------------------------------
*     Solving system with many right hand sides
*     -----------------------------------------
*
      ELSE IF( lsamen( 4, subnam( 3:6 ), 'TRSM' ) ) THEN
*
         IF( k.LE.0 ) THEN
            mults = en * em * ( em + one ) / two
            adds  = en * em * ( em - one ) / two
         ELSE
            mults = em * en * ( en + one ) / two
            adds  = em * en * ( en - one ) / two
         END IF
*
*     --------------------------
*     Matrix (tranpose) Addition
*     --------------------------
*
      ELSE IF( lsamen( 3, c3, 'ADD' ) ) THEN
*
         IF( lsamen( 2, c2, 'GE' ) ) THEN
*
            mults = 2 * em * en
            adds  = em * en
*
         ELSE IF( lsamen( 2, c2, 'TR' ) ) THEN
*
*           IF K <= 0, assume C is upper triangular.
*
            IF( k.LE.0 ) THEN
               IF( m.LE.n ) THEN
                  mults = em * ( two * en - em + one )
                  adds  = em * ( em + one ) / two + em * ( en - em )
               ELSE
                  mults = en * ( en + one )
                  adds  = en * ( en + one ) / two
               END IF
            ELSE
               IF( m.GE.n ) THEN
                  mults = en * ( two * em - en + one )
                  adds  = en * ( en + one ) / two + en * ( em - en )
               ELSE
                  mults = em * ( em + one )
                  adds  = em * ( em + one ) / two
               END IF
            END IF
*
         END IF
*
      END IF
*
*     ------------------------------------------------
*     Compute the total number of operations.
*     For real and double precision routines, count
*        1 for each multiply and 1 for each add.
*     For complex and complex*16 routines, count
*        6 for each multiply and 2 for each add.
*     ------------------------------------------------
*
      IF( lsame( c1, 'S' ) .OR. lsame( c1, 'D' ) ) THEN
*
         pdopbl3 = mults + adds
*
      ELSE
*
         pdopbl3 = six * mults + two * adds
*
      END IF
*
      RETURN
*
*     End of PDOPBL3
*

Here is the call graph for this function:

Here is the caller graph for this function: