Return to zgegs.f CVS log

Up to [local] / rpl / lapack / lapack

Mise à jour de lapack.

    1: *> \brief <b> ZGEEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices</b>
    2: *
    3: *  =========== DOCUMENTATION ===========
    4: *
    5: * Online html documentation available at 
    6: *            http://www.netlib.org/lapack/explore-html/ 
    7: *
    8: *> \htmlonly
    9: *> Download ZGEGS + dependencies 
   10: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zgegs.f"> 
   11: *> [TGZ]</a> 
   12: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zgegs.f"> 
   13: *> [ZIP]</a> 
   14: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgegs.f"> 
   15: *> [TXT]</a>
   16: *> \endhtmlonly 
   17: *
   18: *  Definition:
   19: *  ===========
   20: *
   21: *       SUBROUTINE ZGEGS( JOBVSL, JOBVSR, N, A, LDA, B, LDB, ALPHA, BETA,
   22: *                         VSL, LDVSL, VSR, LDVSR, WORK, LWORK, RWORK,
   23: *                         INFO )
   24: * 
   25: *       .. Scalar Arguments ..
   26: *       CHARACTER          JOBVSL, JOBVSR
   27: *       INTEGER            INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N
   28: *       ..
   29: *       .. Array Arguments ..
   30: *       DOUBLE PRECISION   RWORK( * )
   31: *       COMPLEX*16         A( LDA, * ), ALPHA( * ), B( LDB, * ),
   32: *      $                   BETA( * ), VSL( LDVSL, * ), VSR( LDVSR, * ),
   33: *      $                   WORK( * )
   34: *       ..
   35: *  
   36: *
   37: *> \par Purpose:
   38: *  =============
   39: *>
   40: *> \verbatim
   41: *>
   42: *> This routine is deprecated and has been replaced by routine ZGGES.
   43: *>
   44: *> ZGEGS computes the eigenvalues, Schur form, and, optionally, the
   45: *> left and or/right Schur vectors of a complex matrix pair (A,B).
   46: *> Given two square matrices A and B, the generalized Schur
   47: *> factorization has the form
   48: *> 
   49: *>    A = Q*S*Z**H,  B = Q*T*Z**H
   50: *> 
   51: *> where Q and Z are unitary matrices and S and T are upper triangular.
   52: *> The columns of Q are the left Schur vectors
   53: *> and the columns of Z are the right Schur vectors.
   54: *> 
   55: *> If only the eigenvalues of (A,B) are needed, the driver routine
   56: *> ZGEGV should be used instead.  See ZGEGV for a description of the
   57: *> eigenvalues of the generalized nonsymmetric eigenvalue problem
   58: *> (GNEP).
   59: *> \endverbatim
   60: *
   61: *  Arguments:
   62: *  ==========
   63: *
   64: *> \param[in] JOBVSL
   65: *> \verbatim
   66: *>          JOBVSL is CHARACTER*1
   67: *>          = 'N':  do not compute the left Schur vectors;
   68: *>          = 'V':  compute the left Schur vectors (returned in VSL).
   69: *> \endverbatim
   70: *>
   71: *> \param[in] JOBVSR
   72: *> \verbatim
   73: *>          JOBVSR is CHARACTER*1
   74: *>          = 'N':  do not compute the right Schur vectors;
   75: *>          = 'V':  compute the right Schur vectors (returned in VSR).
   76: *> \endverbatim
   77: *>
   78: *> \param[in] N
   79: *> \verbatim
   80: *>          N is INTEGER
   81: *>          The order of the matrices A, B, VSL, and VSR.  N >= 0.
   82: *> \endverbatim
   83: *>
   84: *> \param[in,out] A
   85: *> \verbatim
   86: *>          A is COMPLEX*16 array, dimension (LDA, N)
   87: *>          On entry, the matrix A.
   88: *>          On exit, the upper triangular matrix S from the generalized
   89: *>          Schur factorization.
   90: *> \endverbatim
   91: *>
   92: *> \param[in] LDA
   93: *> \verbatim
   94: *>          LDA is INTEGER
   95: *>          The leading dimension of A.  LDA >= max(1,N).
   96: *> \endverbatim
   97: *>
   98: *> \param[in,out] B
   99: *> \verbatim
  100: *>          B is COMPLEX*16 array, dimension (LDB, N)
  101: *>          On entry, the matrix B.
  102: *>          On exit, the upper triangular matrix T from the generalized
  103: *>          Schur factorization.
  104: *> \endverbatim
  105: *>
  106: *> \param[in] LDB
  107: *> \verbatim
  108: *>          LDB is INTEGER
  109: *>          The leading dimension of B.  LDB >= max(1,N).
  110: *> \endverbatim
  111: *>
  112: *> \param[out] ALPHA
  113: *> \verbatim
  114: *>          ALPHA is COMPLEX*16 array, dimension (N)
  115: *>          The complex scalars alpha that define the eigenvalues of
  116: *>          GNEP.  ALPHA(j) = S(j,j), the diagonal element of the Schur
  117: *>          form of A.
  118: *> \endverbatim
  119: *>
  120: *> \param[out] BETA
  121: *> \verbatim
  122: *>          BETA is COMPLEX*16 array, dimension (N)
  123: *>          The non-negative real scalars beta that define the
  124: *>          eigenvalues of GNEP.  BETA(j) = T(j,j), the diagonal element
  125: *>          of the triangular factor T.
  126: *>
  127: *>          Together, the quantities alpha = ALPHA(j) and beta = BETA(j)
  128: *>          represent the j-th eigenvalue of the matrix pair (A,B), in
  129: *>          one of the forms lambda = alpha/beta or mu = beta/alpha.
  130: *>          Since either lambda or mu may overflow, they should not,
  131: *>          in general, be computed.
  132: *> \endverbatim
  133: *>
  134: *> \param[out] VSL
  135: *> \verbatim
  136: *>          VSL is COMPLEX*16 array, dimension (LDVSL,N)
  137: *>          If JOBVSL = 'V', the matrix of left Schur vectors Q.
  138: *>          Not referenced if JOBVSL = 'N'.
  139: *> \endverbatim
  140: *>
  141: *> \param[in] LDVSL
  142: *> \verbatim
  143: *>          LDVSL is INTEGER
  144: *>          The leading dimension of the matrix VSL. LDVSL >= 1, and
  145: *>          if JOBVSL = 'V', LDVSL >= N.
  146: *> \endverbatim
  147: *>
  148: *> \param[out] VSR
  149: *> \verbatim
  150: *>          VSR is COMPLEX*16 array, dimension (LDVSR,N)
  151: *>          If JOBVSR = 'V', the matrix of right Schur vectors Z.
  152: *>          Not referenced if JOBVSR = 'N'.
  153: *> \endverbatim
  154: *>
  155: *> \param[in] LDVSR
  156: *> \verbatim
  157: *>          LDVSR is INTEGER
  158: *>          The leading dimension of the matrix VSR. LDVSR >= 1, and
  159: *>          if JOBVSR = 'V', LDVSR >= N.
  160: *> \endverbatim
  161: *>
  162: *> \param[out] WORK
  163: *> \verbatim
  164: *>          WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
  165: *>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
  166: *> \endverbatim
  167: *>
  168: *> \param[in] LWORK
  169: *> \verbatim
  170: *>          LWORK is INTEGER
  171: *>          The dimension of the array WORK.  LWORK >= max(1,2*N).
  172: *>          For good performance, LWORK must generally be larger.
  173: *>          To compute the optimal value of LWORK, call ILAENV to get
  174: *>          blocksizes (for ZGEQRF, ZUNMQR, and CUNGQR.)  Then compute:
  175: *>          NB  -- MAX of the blocksizes for ZGEQRF, ZUNMQR, and CUNGQR;
  176: *>          the optimal LWORK is N*(NB+1).
  177: *>
  178: *>          If LWORK = -1, then a workspace query is assumed; the routine
  179: *>          only calculates the optimal size of the WORK array, returns
  180: *>          this value as the first entry of the WORK array, and no error
  181: *>          message related to LWORK is issued by XERBLA.
  182: *> \endverbatim
  183: *>
  184: *> \param[out] RWORK
  185: *> \verbatim
  186: *>          RWORK is DOUBLE PRECISION array, dimension (3*N)
  187: *> \endverbatim
  188: *>
  189: *> \param[out] INFO
  190: *> \verbatim
  191: *>          INFO is INTEGER
  192: *>          = 0:  successful exit
  193: *>          < 0:  if INFO = -i, the i-th argument had an illegal value.
  194: *>          =1,...,N:
  195: *>                The QZ iteration failed.  (A,B) are not in Schur
  196: *>                form, but ALPHA(j) and BETA(j) should be correct for
  197: *>                j=INFO+1,...,N.
  198: *>          > N:  errors that usually indicate LAPACK problems:
  199: *>                =N+1: error return from ZGGBAL
  200: *>                =N+2: error return from ZGEQRF
  201: *>                =N+3: error return from ZUNMQR
  202: *>                =N+4: error return from ZUNGQR
  203: *>                =N+5: error return from ZGGHRD
  204: *>                =N+6: error return from ZHGEQZ (other than failed
  205: *>                                               iteration)
  206: *>                =N+7: error return from ZGGBAK (computing VSL)
  207: *>                =N+8: error return from ZGGBAK (computing VSR)
  208: *>                =N+9: error return from ZLASCL (various places)
  209: *> \endverbatim
  210: *
  211: *  Authors:
  212: *  ========
  213: *
  214: *> \author Univ. of Tennessee 
  215: *> \author Univ. of California Berkeley 
  216: *> \author Univ. of Colorado Denver 
  217: *> \author NAG Ltd. 
  218: *
  219: *> \date November 2011
  220: *
  221: *> \ingroup complex16GEeigen
  222: *
  223: *  =====================================================================
  224:       SUBROUTINE ZGEGS( JOBVSL, JOBVSR, N, A, LDA, B, LDB, ALPHA, BETA,
  225:      $                  VSL, LDVSL, VSR, LDVSR, WORK, LWORK, RWORK,
  226:      $                  INFO )
  227: *
  228: *  -- LAPACK driver routine (version 3.4.0) --
  229: *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
  230: *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
  231: *     November 2011
  232: *
  233: *     .. Scalar Arguments ..
  234:       CHARACTER          JOBVSL, JOBVSR
  235:       INTEGER            INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N
  236: *     ..
  237: *     .. Array Arguments ..
  238:       DOUBLE PRECISION   RWORK( * )
  239:       COMPLEX*16         A( LDA, * ), ALPHA( * ), B( LDB, * ),
  240:      $                   BETA( * ), VSL( LDVSL, * ), VSR( LDVSR, * ),
  241:      $                   WORK( * )
  242: *     ..
  243: *
  244: *  =====================================================================
  245: *
  246: *     .. Parameters ..
  247:       DOUBLE PRECISION   ZERO, ONE
  248:       PARAMETER          ( ZERO = 0.0D0, ONE = 1.0D0 )
  249:       COMPLEX*16         CZERO, CONE
  250:       PARAMETER          ( CZERO = ( 0.0D0, 0.0D0 ),
  251:      $                   CONE = ( 1.0D0, 0.0D0 ) )
  252: *     ..
  253: *     .. Local Scalars ..
  254:       LOGICAL            ILASCL, ILBSCL, ILVSL, ILVSR, LQUERY
  255:       INTEGER            ICOLS, IHI, IINFO, IJOBVL, IJOBVR, ILEFT, ILO,
  256:      $                   IRIGHT, IROWS, IRWORK, ITAU, IWORK, LOPT,
  257:      $                   LWKMIN, LWKOPT, NB, NB1, NB2, NB3
  258:       DOUBLE PRECISION   ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS,
  259:      $                   SAFMIN, SMLNUM
  260: *     ..
  261: *     .. External Subroutines ..
  262:       EXTERNAL           XERBLA, ZGEQRF, ZGGBAK, ZGGBAL, ZGGHRD, ZHGEQZ,
  263:      $                   ZLACPY, ZLASCL, ZLASET, ZUNGQR, ZUNMQR
  264: *     ..
  265: *     .. External Functions ..
  266:       LOGICAL            LSAME
  267:       INTEGER            ILAENV
  268:       DOUBLE PRECISION   DLAMCH, ZLANGE
  269:       EXTERNAL           LSAME, ILAENV, DLAMCH, ZLANGE
  270: *     ..
  271: *     .. Intrinsic Functions ..
  272:       INTRINSIC          INT, MAX
  273: *     ..
  274: *     .. Executable Statements ..
  275: *
  276: *     Decode the input arguments
  277: *
  278:       IF( LSAME( JOBVSL, 'N' ) ) THEN
  279:          IJOBVL = 1
  280:          ILVSL = .FALSE.
  281:       ELSE IF( LSAME( JOBVSL, 'V' ) ) THEN
  282:          IJOBVL = 2
  283:          ILVSL = .TRUE.
  284:       ELSE
  285:          IJOBVL = -1
  286:          ILVSL = .FALSE.
  287:       END IF
  288: *
  289:       IF( LSAME( JOBVSR, 'N' ) ) THEN
  290:          IJOBVR = 1
  291:          ILVSR = .FALSE.
  292:       ELSE IF( LSAME( JOBVSR, 'V' ) ) THEN
  293:          IJOBVR = 2
  294:          ILVSR = .TRUE.
  295:       ELSE
  296:          IJOBVR = -1
  297:          ILVSR = .FALSE.
  298:       END IF
  299: *
  300: *     Test the input arguments
  301: *
  302:       LWKMIN = MAX( 2*N, 1 )
  303:       LWKOPT = LWKMIN
  304:       WORK( 1 ) = LWKOPT
  305:       LQUERY = ( LWORK.EQ.-1 )
  306:       INFO = 0
  307:       IF( IJOBVL.LE.0 ) THEN
  308:          INFO = -1
  309:       ELSE IF( IJOBVR.LE.0 ) THEN
  310:          INFO = -2
  311:       ELSE IF( N.LT.0 ) THEN
  312:          INFO = -3
  313:       ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
  314:          INFO = -5
  315:       ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
  316:          INFO = -7
  317:       ELSE IF( LDVSL.LT.1 .OR. ( ILVSL .AND. LDVSL.LT.N ) ) THEN
  318:          INFO = -11
  319:       ELSE IF( LDVSR.LT.1 .OR. ( ILVSR .AND. LDVSR.LT.N ) ) THEN
  320:          INFO = -13
  321:       ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
  322:          INFO = -15
  323:       END IF
  324: *
  325:       IF( INFO.EQ.0 ) THEN
  326:          NB1 = ILAENV( 1, 'ZGEQRF', ' ', N, N, -1, -1 )
  327:          NB2 = ILAENV( 1, 'ZUNMQR', ' ', N, N, N, -1 )
  328:          NB3 = ILAENV( 1, 'ZUNGQR', ' ', N, N, N, -1 )
  329:          NB = MAX( NB1, NB2, NB3 )
  330:          LOPT = N*( NB+1 )
  331:          WORK( 1 ) = LOPT
  332:       END IF
  333: *
  334:       IF( INFO.NE.0 ) THEN
  335:          CALL XERBLA( 'ZGEGS ', -INFO )
  336:          RETURN
  337:       ELSE IF( LQUERY ) THEN
  338:          RETURN
  339:       END IF
  340: *
  341: *     Quick return if possible
  342: *
  343:       IF( N.EQ.0 )
  344:      $   RETURN
  345: *
  346: *     Get machine constants
  347: *
  348:       EPS = DLAMCH( 'E' )*DLAMCH( 'B' )
  349:       SAFMIN = DLAMCH( 'S' )
  350:       SMLNUM = N*SAFMIN / EPS
  351:       BIGNUM = ONE / SMLNUM
  352: *
  353: *     Scale A if max element outside range [SMLNUM,BIGNUM]
  354: *
  355:       ANRM = ZLANGE( 'M', N, N, A, LDA, RWORK )
  356:       ILASCL = .FALSE.
  357:       IF( ANRM.GT.ZERO .AND. ANRM.LT.SMLNUM ) THEN
  358:          ANRMTO = SMLNUM
  359:          ILASCL = .TRUE.
  360:       ELSE IF( ANRM.GT.BIGNUM ) THEN
  361:          ANRMTO = BIGNUM
  362:          ILASCL = .TRUE.
  363:       END IF
  364: *
  365:       IF( ILASCL ) THEN
  366:          CALL ZLASCL( 'G', -1, -1, ANRM, ANRMTO, N, N, A, LDA, IINFO )
  367:          IF( IINFO.NE.0 ) THEN
  368:             INFO = N + 9
  369:             RETURN
  370:          END IF
  371:       END IF
  372: *
  373: *     Scale B if max element outside range [SMLNUM,BIGNUM]
  374: *
  375:       BNRM = ZLANGE( 'M', N, N, B, LDB, RWORK )
  376:       ILBSCL = .FALSE.
  377:       IF( BNRM.GT.ZERO .AND. BNRM.LT.SMLNUM ) THEN
  378:          BNRMTO = SMLNUM
  379:          ILBSCL = .TRUE.
  380:       ELSE IF( BNRM.GT.BIGNUM ) THEN
  381:          BNRMTO = BIGNUM
  382:          ILBSCL = .TRUE.
  383:       END IF
  384: *
  385:       IF( ILBSCL ) THEN
  386:          CALL ZLASCL( 'G', -1, -1, BNRM, BNRMTO, N, N, B, LDB, IINFO )
  387:          IF( IINFO.NE.0 ) THEN
  388:             INFO = N + 9
  389:             RETURN
  390:          END IF
  391:       END IF
  392: *
  393: *     Permute the matrix to make it more nearly triangular
  394: *
  395:       ILEFT = 1
  396:       IRIGHT = N + 1
  397:       IRWORK = IRIGHT + N
  398:       IWORK = 1
  399:       CALL ZGGBAL( 'P', N, A, LDA, B, LDB, ILO, IHI, RWORK( ILEFT ),
  400:      $             RWORK( IRIGHT ), RWORK( IRWORK ), IINFO )
  401:       IF( IINFO.NE.0 ) THEN
  402:          INFO = N + 1
  403:          GO TO 10
  404:       END IF
  405: *
  406: *     Reduce B to triangular form, and initialize VSL and/or VSR
  407: *
  408:       IROWS = IHI + 1 - ILO
  409:       ICOLS = N + 1 - ILO
  410:       ITAU = IWORK
  411:       IWORK = ITAU + IROWS
  412:       CALL ZGEQRF( IROWS, ICOLS, B( ILO, ILO ), LDB, WORK( ITAU ),
  413:      $             WORK( IWORK ), LWORK+1-IWORK, IINFO )
  414:       IF( IINFO.GE.0 )
  415:      $   LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 )
  416:       IF( IINFO.NE.0 ) THEN
  417:          INFO = N + 2
  418:          GO TO 10
  419:       END IF
  420: *
  421:       CALL ZUNMQR( 'L', 'C', IROWS, ICOLS, IROWS, B( ILO, ILO ), LDB,
  422:      $             WORK( ITAU ), A( ILO, ILO ), LDA, WORK( IWORK ),
  423:      $             LWORK+1-IWORK, IINFO )
  424:       IF( IINFO.GE.0 )
  425:      $   LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 )
  426:       IF( IINFO.NE.0 ) THEN
  427:          INFO = N + 3
  428:          GO TO 10
  429:       END IF
  430: *
  431:       IF( ILVSL ) THEN
  432:          CALL ZLASET( 'Full', N, N, CZERO, CONE, VSL, LDVSL )
  433:          CALL ZLACPY( 'L', IROWS-1, IROWS-1, B( ILO+1, ILO ), LDB,
  434:      $                VSL( ILO+1, ILO ), LDVSL )
  435:          CALL ZUNGQR( IROWS, IROWS, IROWS, VSL( ILO, ILO ), LDVSL,
  436:      $                WORK( ITAU ), WORK( IWORK ), LWORK+1-IWORK,
  437:      $                IINFO )
  438:          IF( IINFO.GE.0 )
  439:      $      LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 )
  440:          IF( IINFO.NE.0 ) THEN
  441:             INFO = N + 4
  442:             GO TO 10
  443:          END IF
  444:       END IF
  445: *
  446:       IF( ILVSR )
  447:      $   CALL ZLASET( 'Full', N, N, CZERO, CONE, VSR, LDVSR )
  448: *
  449: *     Reduce to generalized Hessenberg form
  450: *
  451:       CALL ZGGHRD( JOBVSL, JOBVSR, N, ILO, IHI, A, LDA, B, LDB, VSL,
  452:      $             LDVSL, VSR, LDVSR, IINFO )
  453:       IF( IINFO.NE.0 ) THEN
  454:          INFO = N + 5
  455:          GO TO 10
  456:       END IF
  457: *
  458: *     Perform QZ algorithm, computing Schur vectors if desired
  459: *
  460:       IWORK = ITAU
  461:       CALL ZHGEQZ( 'S', JOBVSL, JOBVSR, N, ILO, IHI, A, LDA, B, LDB,
  462:      $             ALPHA, BETA, VSL, LDVSL, VSR, LDVSR, WORK( IWORK ),
  463:      $             LWORK+1-IWORK, RWORK( IRWORK ), IINFO )
  464:       IF( IINFO.GE.0 )
  465:      $   LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 )
  466:       IF( IINFO.NE.0 ) THEN
  467:          IF( IINFO.GT.0 .AND. IINFO.LE.N ) THEN
  468:             INFO = IINFO
  469:          ELSE IF( IINFO.GT.N .AND. IINFO.LE.2*N ) THEN
  470:             INFO = IINFO - N
  471:          ELSE
  472:             INFO = N + 6
  473:          END IF
  474:          GO TO 10
  475:       END IF
  476: *
  477: *     Apply permutation to VSL and VSR
  478: *
  479:       IF( ILVSL ) THEN
  480:          CALL ZGGBAK( 'P', 'L', N, ILO, IHI, RWORK( ILEFT ),
  481:      $                RWORK( IRIGHT ), N, VSL, LDVSL, IINFO )
  482:          IF( IINFO.NE.0 ) THEN
  483:             INFO = N + 7
  484:             GO TO 10
  485:          END IF
  486:       END IF
  487:       IF( ILVSR ) THEN
  488:          CALL ZGGBAK( 'P', 'R', N, ILO, IHI, RWORK( ILEFT ),
  489:      $                RWORK( IRIGHT ), N, VSR, LDVSR, IINFO )
  490:          IF( IINFO.NE.0 ) THEN
  491:             INFO = N + 8
  492:             GO TO 10
  493:          END IF
  494:       END IF
  495: *
  496: *     Undo scaling
  497: *
  498:       IF( ILASCL ) THEN
  499:          CALL ZLASCL( 'U', -1, -1, ANRMTO, ANRM, N, N, A, LDA, IINFO )
  500:          IF( IINFO.NE.0 ) THEN
  501:             INFO = N + 9
  502:             RETURN
  503:          END IF
  504:          CALL ZLASCL( 'G', -1, -1, ANRMTO, ANRM, N, 1, ALPHA, N, IINFO )
  505:          IF( IINFO.NE.0 ) THEN
  506:             INFO = N + 9
  507:             RETURN
  508:          END IF
  509:       END IF
  510: *
  511:       IF( ILBSCL ) THEN
  512:          CALL ZLASCL( 'U', -1, -1, BNRMTO, BNRM, N, N, B, LDB, IINFO )
  513:          IF( IINFO.NE.0 ) THEN
  514:             INFO = N + 9
  515:             RETURN
  516:          END IF
  517:          CALL ZLASCL( 'G', -1, -1, BNRMTO, BNRM, N, 1, BETA, N, IINFO )
  518:          IF( IINFO.NE.0 ) THEN
  519:             INFO = N + 9
  520:             RETURN
  521:          END IF
  522:       END IF
  523: *
  524:    10 CONTINUE
  525:       WORK( 1 ) = LWKOPT
  526: *
  527:       RETURN
  528: *
  529: *     End of ZGEGS
  530: *
  531:       END