pdopbl2()

double precision function pdopbl2	(	character*7	subnam,
		integer	m,
		integer	n,
		integer	kkl,
		integer	kku
	)

Definition at line 1083 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            KKL, KKU, M, N
*     ..
*
*  Purpose
*  =======
*
*  PDOPBL2  computes  an  approximation  of the number of floating point
*  operations performed by a subroutine SUBNAM with the  given values of
*  the parameters M, N, KL, and KU.
*
*  This version counts operations for the Level 2 PBLAS.
*
*  Arguments
*  =========
*
*  SUBNAM  (input) CHARACTER*7
*          On entry, SUBNAM specifies the name of the subroutine.
*
*  M       (input) INTEGER
*          On entry,  M  specifies the number of rows of the coefficient
*          matrix.  M must be at least zero.
*
*  N       (input) INTEGER
*          On entry,  N  specifies  the number of columns of the coeffi-
*          cient matrix. If the matrix  is  square (such  as  in a solve
*          routine) then N is the number of right hand sides. N  must be
*          at least zero.
*
*  KKL     (input) INTEGER
*          On entry,  KKL  specifies the lower band width of the coeffi-
*          cient matrix. KL is set to max( 0, min( M-1, KKL ) ).
*
*  KKU     (input) INTEGER
*          On entry,  KKU  specifies the upper band width of the coeffi-
*          cient matrix. KU is set to max( 0, min( N-1, KKU ) ).
*
*  -- 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, KL, KU, MULTS
*     ..
*     .. External Functions ..
      LOGICAL            LSAME, LSAMEN
      EXTERNAL           lsame, lsamen
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          dble, max, min
*     ..
*     .. 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
         pdopbl2 = zero
         RETURN
      END IF
*
      c1 = subnam( 2: 2 )
      c2 = subnam( 3: 4 )
      c3 = subnam( 5: 7 )
      mults = zero
      adds  = zero
      kl = max( 0, min( m-1, kkl ) )
      ku = max( 0, min( n-1, kku ) )
      em = dble( m )
      en = dble( n )
      ek = dble( kl )
*
*     -------------------------------
*     Matrix-vector multiply routines
*     -------------------------------
*
      IF( lsamen( 3, c3, 'MV ' ) ) THEN
*
         IF( lsamen( 2, c2, 'GE' ) ) THEN
*
            mults = em * ( en + one )
            adds  = em * en
*
*        Assume M <= N + KL and KL < M
*               N <= M + KU and KU < N
*        so that the zero sections are triangles.
*
         ELSE IF( lsamen( 2, c2, 'GB' ) ) THEN
*
            mults = em * ( en + one ) -
     $              ( em - one - kl ) * ( em - kl ) / two -
     $              ( en - one - ku ) * ( en - ku ) / two
            adds  = em * ( en + one ) -
     $              ( em - one - kl ) * ( em - kl ) / two -
     $              ( en - one - ku ) * ( en - ku ) / two
*
         ELSE IF( lsamen( 2, c2, 'SY' ) .OR. lsamen( 2, c2, 'SP' ) .OR.
     $            lsamen( 2, c2, 'HE' ) .OR. lsamen( 2, c2, 'HP' ) )
     $            THEN
*
            mults = em * ( em + one )
            adds  = em * em
*
         ELSE IF( lsamen( 2, c2, 'SB' ) .OR.
     $            lsamen( 2, c2, 'HB' ) ) THEN
*
            mults = em * ( em + one ) - ( em - one - ek ) * ( em - ek )
            adds  = em * em - ( em - one - ek ) * ( em - ek )
*
         ELSE IF( lsamen( 2, c2, 'TR' ) .OR. lsamen( 2, c2, 'TP' ) )
     $             THEN
*
            mults = em * ( em + one ) / two
            adds  = ( em - one ) * em / two
*
         ELSE IF( lsamen( 2, c2, 'TB' ) ) THEN
*
            mults = em * ( em + one ) / two -
     $              ( em - ek - one ) * ( em - ek ) / two
            adds = ( em - one ) * em / two -
     $             ( em - ek - one ) * ( em - ek ) / two
*
         END IF
*
*     ---------------------
*     Matrix solve routines
*     ---------------------
*
      ELSE IF( lsamen( 3, c3, 'SV ' ) ) THEN
*
         IF( lsamen( 2, c2, 'TR' ) .OR. lsamen( 2, c2, 'TP' ) ) THEN
*
            mults = em * ( em + one ) / two
            adds  = ( em - one ) * em / two
*
         ELSE IF( lsamen( 2, c2, 'TB' ) ) THEN
*
            mults = em * ( em + one ) / two -
     $              ( em - ek - one ) * ( em - ek ) / two
            adds  = ( em - one ) * em / two -
     $              ( em - ek - one ) * ( em - ek ) / two
*
         END IF
*
*     ----------------
*     Rank-one updates
*     ----------------
*
      ELSE IF( lsamen( 3, c3, 'R  ' ) ) THEN
*
         IF( lsamen( 2, c2, 'GE' ) ) THEN
*
            mults = em * en + min( em, en )
            adds  = em * en
*
         ELSE IF( lsamen( 2, c2, 'SY' ) .OR. lsamen( 2, c2, 'SP' ) .OR.
     $            lsamen( 2, c2, 'HE' ) .OR. lsamen( 2, c2, 'HP' ) )
     $            THEN
*
            mults = em * ( em + one ) / two + em
            adds  = em * ( em + one ) / two
*
         END IF
*
      ELSE IF( lsamen( 3, c3, 'RC ' ) .OR. lsamen( 3, c3, 'RU ' ) ) THEN
*
         IF( lsamen( 2, c2, 'GE' ) ) THEN
*
            mults = em * en + min( em, en )
            adds  = em * en
*
         END IF
*
*     ----------------
*     Rank-two updates
*     ----------------
*
      ELSE IF( lsamen( 3, c3, 'R2 ' ) ) THEN
         IF( lsamen( 2, c2, 'SY' ) .OR. lsamen( 2, c2, 'SP' ) .OR.
     $       lsamen( 2, c2, 'HE' ) .OR. lsamen( 2, c2, 'HP' ) ) THEN
*
            mults = em * ( em + one ) + two * em
            adds  = em * ( em + one )
*
         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
*
         pdopbl2 = mults + adds
*
      ELSE
*
         pdopbl2 = six * mults + two * adds
*
      END IF
*
      RETURN
*
*     End of PDOPBL2
*

Here is the call graph for this function:

Here is the caller graph for this function: