zggbak_8f_source.html

*> \brief \b ZGGBAK

*

*  =========== DOCUMENTATION ===========

*

* Online html documentation available at

*            http://www.netlib.org/lapack/explore-html/

*

*> \htmlonly

*> Download ZGGBAK + dependencies

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zggbak.f">

*> [TGZ]</a>

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zggbak.f">

*> [ZIP]</a>

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggbak.f">

*> [TXT]</a>

*> \endhtmlonly

*

*  Definition:

*  ===========

*

*       SUBROUTINE ZGGBAK( JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V,

*                          LDV, INFO )

*

*       .. Scalar Arguments ..

*       CHARACTER          JOB, SIDE

*       INTEGER            IHI, ILO, INFO, LDV, M, N

*       ..

*       .. Array Arguments ..

*       DOUBLE PRECISION   LSCALE( * ), RSCALE( * )

*       COMPLEX*16         V( LDV, * )

*       ..

*

*

*> \par Purpose:

*  =============

*>

*> \verbatim

*>

*> ZGGBAK forms the right or left eigenvectors of a complex generalized

*> eigenvalue problem A*x = lambda*B*x, by backward transformation on

*> the computed eigenvectors of the balanced pair of matrices output by

*> ZGGBAL.

*> \endverbatim

*

*  Arguments:

*  ==========

*

*> \param[in] JOB

*> \verbatim

*>          JOB is CHARACTER*1

*>          Specifies the type of backward transformation required:

*>          = 'N':  do nothing, return immediately;

*>          = 'P':  do backward transformation for permutation only;

*>          = 'S':  do backward transformation for scaling only;

*>          = 'B':  do backward transformations for both permutation and

*>                  scaling.

*>          JOB must be the same as the argument JOB supplied to ZGGBAL.

*> \endverbatim

*>

*> \param[in] SIDE

*> \verbatim

*>          SIDE is CHARACTER*1

*>          = 'R':  V contains right eigenvectors;

*>          = 'L':  V contains left eigenvectors.

*> \endverbatim

*>

*> \param[in] N

*> \verbatim

*>          N is INTEGER

*>          The number of rows of the matrix V.  N >= 0.

*> \endverbatim

*>

*> \param[in] ILO

*> \verbatim

*>          ILO is INTEGER

*> \endverbatim

*>

*> \param[in] IHI

*> \verbatim

*>          IHI is INTEGER

*>          The integers ILO and IHI determined by ZGGBAL.

*>          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

*> \endverbatim

*>

*> \param[in] LSCALE

*> \verbatim

*>          LSCALE is DOUBLE PRECISION array, dimension (N)

*>          Details of the permutations and/or scaling factors applied

*>          to the left side of A and B, as returned by ZGGBAL.

*> \endverbatim

*>

*> \param[in] RSCALE

*> \verbatim

*>          RSCALE is DOUBLE PRECISION array, dimension (N)

*>          Details of the permutations and/or scaling factors applied

*>          to the right side of A and B, as returned by ZGGBAL.

*> \endverbatim

*>

*> \param[in] M

*> \verbatim

*>          M is INTEGER

*>          The number of columns of the matrix V.  M >= 0.

*> \endverbatim

*>

*> \param[in,out] V

*> \verbatim

*>          V is COMPLEX*16 array, dimension (LDV,M)

*>          On entry, the matrix of right or left eigenvectors to be

*>          transformed, as returned by ZTGEVC.

*>          On exit, V is overwritten by the transformed eigenvectors.

*> \endverbatim

*>

*> \param[in] LDV

*> \verbatim

*>          LDV is INTEGER

*>          The leading dimension of the matrix V. LDV >= max(1,N).

*> \endverbatim

*>

*> \param[out] INFO

*> \verbatim

*>          INFO is INTEGER

*>          = 0:  successful exit.

*>          < 0:  if INFO = -i, the i-th argument had an illegal value.

*> \endverbatim

*

*  Authors:

*  ========

*

*> \author Univ. of Tennessee

*> \author Univ. of California Berkeley

*> \author Univ. of Colorado Denver

*> \author NAG Ltd.

*

*> \ingroup complex16GBcomputational

*

*> \par Further Details:

*  =====================

*>

*> \verbatim

*>

*>  See R.C. Ward, Balancing the generalized eigenvalue problem,

*>                 SIAM J. Sci. Stat. Comp. 2 (1981), 141-152.

*> \endverbatim

*>

*  =====================================================================


      SUBROUTINE zggbak( JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V,

     $                   LDV, INFO )

*

*  -- LAPACK computational routine --

*  -- LAPACK is a software package provided by Univ. of Tennessee,    --

*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--

*

*     .. Scalar Arguments ..

      CHARACTER          JOB, SIDE

      INTEGER            IHI, ILO, INFO, LDV, M, N

*     ..

*     .. Array Arguments ..

      DOUBLE PRECISION   LSCALE( * ), RSCALE( * )

      COMPLEX*16         V( LDV, * )

*     ..

*

*  =====================================================================

*

*     .. Local Scalars ..

      LOGICAL            LEFTV, RIGHTV

      INTEGER            I, K

*     ..

*     .. External Functions ..

      LOGICAL            LSAME

      EXTERNAL           lsame

*     ..

*     .. External Subroutines ..

      EXTERNAL           xerbla, zdscal, zswap

*     ..

*     .. Intrinsic Functions ..

      INTRINSIC          max, int

*     ..

*     .. Executable Statements ..

*

*     Test the input parameters

*

      rightv = lsame( side, 'r' )

      LEFTV = LSAME( SIDE, 'l' )

*

      INFO = 0

.NOT.      IF( LSAME( JOB, 'n.AND..NOT.' )  LSAME( JOB, 'p.AND.' )

.NOT.     $    LSAME( JOB, 's.AND..NOT.' )  LSAME( JOB, 'b' ) ) THEN

         INFO = -1

.NOT..AND..NOT.      ELSE IF( RIGHTV  LEFTV ) THEN

         INFO = -2

.LT.      ELSE IF( N0 ) THEN

         INFO = -3

.LT.      ELSE IF( ILO1 ) THEN

         INFO = -4

.EQ..AND..EQ..AND..NE.      ELSE IF( N0  IHI0  ILO1 ) THEN

         INFO = -4

.GT..AND..LT..OR..GT.      ELSE IF( N0  ( IHIILO  IHIMAX( 1, N ) ) )

     $   THEN

         INFO = -5

.EQ..AND..EQ..AND..NE.      ELSE IF( N0  ILO1  IHI0 ) THEN

         INFO = -5

.LT.      ELSE IF( M0 ) THEN

         INFO = -8

.LT.      ELSE IF( LDVMAX( 1, N ) ) THEN

         INFO = -10

      END IF

.NE.      IF( INFO0 ) THEN

         CALL XERBLA( 'zggbak', -INFO )

         RETURN

      END IF

*

*     Quick return if possible

*

.EQ.      IF( N0 )

     $   RETURN

.EQ.      IF( M0 )

     $   RETURN

      IF( LSAME( JOB, 'n' ) )

     $   RETURN

*

.EQ.      IF( ILOIHI )

     $   GO TO 30

*

*     Backward balance

*

      IF( LSAME( JOB, 's.OR.' )  LSAME( JOB, 'b' ) ) THEN

*

*        Backward transformation on right eigenvectors

*

         IF( RIGHTV ) THEN

            DO 10 I = ILO, IHI

               CALL ZDSCAL( M, RSCALE( I ), V( I, 1 ), LDV )

   10       CONTINUE

         END IF

*

*        Backward transformation on left eigenvectors

*

         IF( LEFTV ) THEN

            DO 20 I = ILO, IHI

               CALL ZDSCAL( M, LSCALE( I ), V( I, 1 ), LDV )

   20       CONTINUE

         END IF

      END IF

*

*     Backward permutation

*

   30 CONTINUE

      IF( LSAME( JOB, 'p.OR.' )  LSAME( JOB, 'b' ) ) THEN

*

*        Backward permutation on right eigenvectors

*

         IF( RIGHTV ) THEN

.EQ.            IF( ILO1 )

     $         GO TO 50

            DO 40 I = ILO - 1, 1, -1

               K = INT(RSCALE( I ))

.EQ.               IF( KI )

     $            GO TO 40

               CALL ZSWAP( M, V( I, 1 ), LDV, V( K, 1 ), LDV )

   40       CONTINUE

*

   50       CONTINUE

.EQ.            IF( IHIN )

     $         GO TO 70

            DO 60 I = IHI + 1, N

               K = INT(RSCALE( I ))

.EQ.               IF( KI )

     $            GO TO 60

               CALL ZSWAP( M, V( I, 1 ), LDV, V( K, 1 ), LDV )

   60       CONTINUE

         END IF

*

*        Backward permutation on left eigenvectors

*

   70    CONTINUE

         IF( LEFTV ) THEN

.EQ.            IF( ILO1 )

     $         GO TO 90

            DO 80 I = ILO - 1, 1, -1

               K = INT(LSCALE( I ))

.EQ.               IF( KI )

     $            GO TO 80

               CALL ZSWAP( M, V( I, 1 ), LDV, V( K, 1 ), LDV )

   80       CONTINUE

*

   90       CONTINUE

.EQ.            IF( IHIN )

     $         GO TO 110

            DO 100 I = IHI + 1, N

               K = INT(LSCALE( I ))

.EQ.               IF( KI )

     $            GO TO 100

               CALL ZSWAP( M, V( I, 1 ), LDV, V( K, 1 ), LDV )

  100       CONTINUE

         END IF

      END IF

*

  110 CONTINUE

*

      RETURN

*

*     End of ZGGBAK

*


      END

xerbla
subroutine xerbla(srname, info)
XERBLA
Definition xerbla.f:60

zggbak
subroutine zggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
ZGGBAK
Definition zggbak.f:148

zdscal
subroutine zdscal(n, da, zx, incx)
ZDSCAL
Definition zdscal.f:78

zswap
subroutine zswap(n, zx, incx, zy, incy)
ZSWAP
Definition zswap.f:81

max
#define max(a, b)
Definition macros.h:21