```      SUBROUTINE DLAPMT( FORWRD, M, N, X, LDX, K )
*
*  -- LAPACK auxiliary routine (version 3.1) --
*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
*     November 2006
*
*     .. Scalar Arguments ..
LOGICAL            FORWRD
INTEGER            LDX, M, N
*     ..
*     .. Array Arguments ..
INTEGER            K( * )
DOUBLE PRECISION   X( LDX, * )
*     ..
*
*  Purpose
*  =======
*
*  DLAPMT 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.
*
*  Arguments
*  =========
*
*  FORWRD  (input) LOGICAL
*          = .TRUE., forward permutation
*          = .FALSE., backward permutation
*
*  M       (input) INTEGER
*          The number of rows of the matrix X. M >= 0.
*
*  N       (input) INTEGER
*          The number of columns of the matrix X. N >= 0.
*
*  X       (input/output) DOUBLE PRECISION array, dimension (LDX,N)
*          On entry, the M by N matrix X.
*          On exit, X contains the permuted matrix X.
*
*  LDX     (input) INTEGER
*          The leading dimension of the array X, LDX >= MAX(1,M).
*
*  K       (input/output) 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.
*
*  =====================================================================
*
*     .. Local Scalars ..
INTEGER            I, II, IN, J
DOUBLE PRECISION   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 DLAPMT
*
END

```