clapmt()

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

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

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

Purpose:

!>
!> CLAPMT 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 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 101 of file clapmt.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            X( LDX, * )
*     ..
*
*  =====================================================================
*
*     .. Local Scalars ..
      INTEGER            I, II, J, IN
      COMPLEX            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 60 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
*
   60    CONTINUE
*
      ELSE
*
*        Backward permutation
*
         DO 110 i = 1, n
*
            IF( k( i ).GT.0 )
     $         GO TO 100
*
            k( i ) = -k( i )
            j = k( i )
   80       CONTINUE
            IF( j.EQ.i )
     $         GO TO 100
*
            DO 90 ii = 1, m
               temp = x( ii, i )
               x( ii, i ) = x( ii, j )
               x( ii, j ) = temp
   90       CONTINUE
*
            k( j ) = -k( j )
            j = k( j )
            GO TO 80
*
  100       CONTINUE
 
  110    CONTINUE
*
      END IF
*
      RETURN
*
*     End of CLAPMT
*

Here is the caller graph for this function: