zlapmt()

subroutine zlapmt	(	logical	forwrd,
		integer	m,
		integer	n,
		complex*16, dimension( ldx, * )	x,
		integer	ldx,
		integer, dimension( * )	k
	)

ZLAPMT performs a forward or backward permutation of the columns of a matrix.

Download ZLAPMT + dependencies [TGZ] [ZIP] [TXT]

Purpose:

 ZLAPMT rearranges the columns of the M by N matrix X as specified
 by the permutation K(1),K(2),...,K(N) of the integers 1,...,N.
 If FORWRD = .TRUE.,  forward permutation:

      X(*,K(J)) is moved X(*,J) for J = 1,2,...,N.

 If FORWRD = .FALSE., backward permutation:

      X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.

Parameters

[in]	FORWRD	FORWRD is LOGICAL = .TRUE., forward permutation = .FALSE., backward permutation
[in]	M	M is INTEGER The number of rows of the matrix X. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix X. N >= 0.
[in,out]	X	X is COMPLEX*16 array, dimension (LDX,N) On entry, the M by N matrix X. On exit, X contains the permuted matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X, LDX >= MAX(1,M).
[in,out]	K	K is INTEGER array, dimension (N) On entry, K contains the permutation vector. K is used as internal workspace, but reset to its original value on output.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 103 of file zlapmt.f.

*
*  -- LAPACK auxiliary routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      LOGICAL            FORWRD
      INTEGER            LDX, M, N
*     ..
*     .. Array Arguments ..
      INTEGER            K( * )
      COMPLEX*16         X( LDX, * )
*     ..
*
*  =====================================================================
*
*     .. Local Scalars ..
      INTEGER            I, II, IN, J
      COMPLEX*16         TEMP
*     ..
*     .. Executable Statements ..
*
      IF( n.LE.1 )
     $   RETURN
*
      DO 10 i = 1, n
         k( i ) = -k( i )
   10 CONTINUE
*
      IF( forwrd ) THEN
*
*        Forward permutation
*
         DO 50 i = 1, n
*
            IF( k( i ).GT.0 )
     $         GO TO 40
*
            j = i
            k( j ) = -k( j )
            in = k( j )
*
   20       CONTINUE
            IF( k( in ).GT.0 )
     $         GO TO 40
*
            DO 30 ii = 1, m
               temp = x( ii, j )
               x( ii, j ) = x( ii, in )
               x( ii, in ) = temp
   30       CONTINUE
*
            k( in ) = -k( in )
            j = in
            in = k( in )
            GO TO 20
*
   40       CONTINUE
*
   50    CONTINUE
*
      ELSE
*
*        Backward permutation
*
         DO 90 i = 1, n
*
            IF( k( i ).GT.0 )
     $         GO TO 80
*
            k( i ) = -k( i )
            j = k( i )
   60       CONTINUE
            IF( j.EQ.i )
     $         GO TO 80
*
            DO 70 ii = 1, m
               temp = x( ii, i )
               x( ii, i ) = x( ii, j )
               x( ii, j ) = temp
   70       CONTINUE
*
            k( j ) = -k( j )
            j = k( j )
            GO TO 60
*
   80       CONTINUE
*
   90    CONTINUE
*
      END IF
*
      RETURN
*
*     End of ZLAPMT
*

Here is the caller graph for this function: