Routine DLAPST() Documented By Universal Report

Routine: DLAPST()

# lines:	251
# code:	251
# comment:	0
# blank:	0
# Variables:	11
# Callers:	2
# Callings:	0
# Words:	88
# Keywords:	47

..
     .. Local Scalars ..
     ..
     .. Local Arrays ..
     ..
     .. External Functions ..
     ..
     .. External Subroutines ..
     ..
     .. Executable Statements ..
     Test the input paramters.
     Quick return if possible
        Do Insertion sort on D( START:ENDD )
           Sort into decreasing order
           Sort into increasing order
        Partition D( START:ENDD ) and stack parts, largest one first
        Choose partition entry as median of 3
           Sort into decreasing order

Display dynamic version

FontSize: - +

001        SUBROUTINE DLAPST( ID , N , D , INDX , INFO )
002  
003  *     -- ScaLAPACK auxiliary routine(version 1.7) --
004  *     University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
005  *     and University of California , Berkeley.
006  *     December 31 , 1998
007  
008  *     .. Scalar Arguments ..
009        CHARACTER ID
010        INTEGER INFO , N
011  *     ..
012  *     .. Array Arguments ..
013        INTEGER INDX( * )
014        DOUBLE PRECISION D( * )
015  *     ..
016  
017  *     Purpose
018  *     === ====
019  *     DLAPST is a modified version of the LAPACK routine DLASRT.
020  
021  *     Define a permutation INDX that sorts the numbers in D
022  *     in increasing order(if ID = 'I') or
023  *     in decreasing order(if ID = 'D' ).
024  
025  *     Use Quick Sort , reverting to Insertion sort on arrays of
026  *     size <= 20. Dimension of STACK limits N to about 2**32.
027  
028  *     Arguments
029  *     === ======
030  
031  *     ID(input) CHARACTER*1
032  *     = 'I' : sort D in increasing order ;
033  *     = 'D' : sort D in decreasing order.
034  
035  *     N(input) INTEGER
036  *     The length of the array D.
037  
038  *     D(input) DOUBLE PRECISION array , dimension(N)
039  *     The array to be sorted.
040  
041  *     INDX(ouput) INTEGER array , dimension(N).
042  *     The permutation which sorts the array D.
043  
044  *     INFO(output) INTEGER
045  *     = 0 : successful exit
046  *     < 0 : if INFO = - i , the i - th argument had an illegal value
047  
048  *     === ==================================================================
049  
050  *     .. Parameters ..
051        INTEGER SELECT
052        PARAMETER( SELECT = 20 )
053        I = START - 1
054        J = ENDD + 1
055     70 CONTINUE
056     80 CONTINUE
057        J = J - 1
058        IF( D( INDX( J ) ).LT.DMNMX )
058               
059       $    GO TO 80
060     90 CONTINUE
061        I = I + 1
062        IF( D( INDX( I ) ).GT.DMNMX )
062               
063       $    GO TO 90
064            IF( I.LT.J ) THEN
064                   
065                ITMP = INDX( I )
066                INDX( I ) = INDX( J )
067                INDX( J ) = ITMP
068                GO TO 70
069            END IF
070            IF( J - START.GT.ENDD - J - 1 ) THEN
070                   
071                STKPNT = STKPNT + 1
072                STACK( 1 , STKPNT ) = START
073                STACK( 2 , STKPNT ) = J
074                STKPNT = STKPNT + 1
075                STACK( 1 , STKPNT ) = J + 1
076                STACK( 2 , STKPNT ) = ENDD
077            ELSE
077                   
078                STKPNT = STKPNT + 1
079                STACK( 1 , STKPNT ) = J + 1
080                STACK( 2 , STKPNT ) = ENDD
081                STKPNT = STKPNT + 1
082                STACK( 1 , STKPNT ) = START
083                STACK( 2 , STKPNT ) = J
084            END IF
085        ELSE
086  
087  *         Sort into increasing order
088  
088               
089            I = START - 1
090            J = ENDD + 1
091    100 CONTINUE
092    110 CONTINUE
093        J = J - 1
094        IF( D( INDX( J ) ).GT.DMNMX )
094               
095       $    GO TO 110
096    120 CONTINUE
097        I = I + 1
098        IF( D( INDX( I ) ).LT.DMNMX )
098               
099       $    GO TO 120
100            IF( I.LT.J ) THEN
100                   
101                ITMP = INDX( I )
102                INDX( I ) = INDX( J )
103                INDX( J ) = ITMP
104                GO TO 100
105            END IF
106            IF( J - START.GT.ENDD - J - 1 ) THEN
106                   
107                STKPNT = STKPNT + 1
108                STACK( 1 , STKPNT ) = START
109                STACK( 2 , STKPNT ) = J
110                STKPNT = STKPNT + 1
111                STACK( 1 , STKPNT ) = J + 1
112                STACK( 2 , STKPNT ) = ENDD
113            ELSE
113                   
114                STKPNT = STKPNT + 1
115                STACK( 1 , STKPNT ) = J + 1
116                STACK( 2 , STKPNT ) = ENDD
117                STKPNT = STKPNT + 1
118                STACK( 1 , STKPNT ) = START
119                STACK( 2 , STKPNT ) = J
120            END IF
121        END IF
122        END IF
123        IF( STKPNT.GT.0 )
123               
124       $    GO TO 20
125            RETURN
126  
127  *         End of DLAPST
128  
129        END3417

Variables in Routine DLAPST()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	1	1
DOUBLE PRECISION	1	4
INTEGER	7	28
REAL	2	8
TOTAL	11	41

List of Variables

CHARACTER

ID

DOUBLE PRECISION

D( * )

INTEGER

I INDX( * ) INFO ITMP J
N SELECT

REAL

STACK STKPNT

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
I <--- II = I + 1{2I = I + 1}

INDX <--- INDXINDX( I ) = INDX( J ){2INDX( I ) = INDX( J )}, ITMPINDX( J ) = ITMP{2INDX( J ) = ITMP}, JINDX( I ) = INDX( J ){2INDX( I ) = INDX( J )}

ITMP <--- IITMP = INDX( I ){2ITMP = INDX( I )}, INDXITMP = INDX( I ){2ITMP = INDX( I )}

J <--- JJ = J - 1{2J = J - 1}

STACK <--- JSTACK( 2, STKPNT ) = J{2STACK( 1, STKPNT ) = J + 1, 3STACK( 1, STKPNT ) = J + 1, 4STACK( 2, STKPNT ) = J, 5STACK( 2, STKPNT ) = J, 6STACK( 1, STKPNT ) = J + 1, 7STACK( 1, STKPNT ) = J + 1, 8STACK( 2, STKPNT ) = J}

STKPNT <--- STKPNTSTKPNT = STKPNT + 1{2STKPNT = STKPNT + 1, 3STKPNT = STKPNT + 1, 4STKPNT = STKPNT + 1, 5STKPNT = STKPNT + 1, 6STKPNT = STKPNT + 1, 7STKPNT = STKPNT + 1, 8STKPNT = STKPNT + 1}