LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
sgegs.f
Go to the documentation of this file.
00001 *> \brief <b> SGEEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices</b>
00002 *
00003 *  =========== DOCUMENTATION ===========
00004 *
00005 * Online html documentation available at 
00006 *            http://www.netlib.org/lapack/explore-html/ 
00007 *
00008 *> \htmlonly
00009 *> Download SGEGS + dependencies 
00010 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/sgegs.f"> 
00011 *> [TGZ]</a> 
00012 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/sgegs.f"> 
00013 *> [ZIP]</a> 
00014 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/sgegs.f"> 
00015 *> [TXT]</a>
00016 *> \endhtmlonly 
00017 *
00018 *  Definition:
00019 *  ===========
00020 *
00021 *       SUBROUTINE SGEGS( JOBVSL, JOBVSR, N, A, LDA, B, LDB, ALPHAR,
00022 *                         ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, WORK,
00023 *                         LWORK, INFO )
00024 * 
00025 *       .. Scalar Arguments ..
00026 *       CHARACTER          JOBVSL, JOBVSR
00027 *       INTEGER            INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N
00028 *       ..
00029 *       .. Array Arguments ..
00030 *       REAL               A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
00031 *      $                   B( LDB, * ), BETA( * ), VSL( LDVSL, * ),
00032 *      $                   VSR( LDVSR, * ), WORK( * )
00033 *       ..
00034 *  
00035 *
00036 *> \par Purpose:
00037 *  =============
00038 *>
00039 *> \verbatim
00040 *>
00041 *> This routine is deprecated and has been replaced by routine SGGES.
00042 *>
00043 *> SGEGS computes the eigenvalues, real Schur form, and, optionally,
00044 *> left and or/right Schur vectors of a real matrix pair (A,B).
00045 *> Given two square matrices A and B, the generalized real Schur
00046 *> factorization has the form
00047 *> 
00048 *>   A = Q*S*Z**T,  B = Q*T*Z**T
00049 *>
00050 *> where Q and Z are orthogonal matrices, T is upper triangular, and S
00051 *> is an upper quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal
00052 *> blocks, the 2-by-2 blocks corresponding to complex conjugate pairs
00053 *> of eigenvalues of (A,B).  The columns of Q are the left Schur vectors
00054 *> and the columns of Z are the right Schur vectors.
00055 *> 
00056 *> If only the eigenvalues of (A,B) are needed, the driver routine
00057 *> SGEGV should be used instead.  See SGEGV for a description of the
00058 *> eigenvalues of the generalized nonsymmetric eigenvalue problem
00059 *> (GNEP).
00060 *> \endverbatim
00061 *
00062 *  Arguments:
00063 *  ==========
00064 *
00065 *> \param[in] JOBVSL
00066 *> \verbatim
00067 *>          JOBVSL is CHARACTER*1
00068 *>          = 'N':  do not compute the left Schur vectors;
00069 *>          = 'V':  compute the left Schur vectors (returned in VSL).
00070 *> \endverbatim
00071 *>
00072 *> \param[in] JOBVSR
00073 *> \verbatim
00074 *>          JOBVSR is CHARACTER*1
00075 *>          = 'N':  do not compute the right Schur vectors;
00076 *>          = 'V':  compute the right Schur vectors (returned in VSR).
00077 *> \endverbatim
00078 *>
00079 *> \param[in] N
00080 *> \verbatim
00081 *>          N is INTEGER
00082 *>          The order of the matrices A, B, VSL, and VSR.  N >= 0.
00083 *> \endverbatim
00084 *>
00085 *> \param[in,out] A
00086 *> \verbatim
00087 *>          A is REAL array, dimension (LDA, N)
00088 *>          On entry, the matrix A.
00089 *>          On exit, the upper quasi-triangular matrix S from the
00090 *>          generalized real Schur factorization.
00091 *> \endverbatim
00092 *>
00093 *> \param[in] LDA
00094 *> \verbatim
00095 *>          LDA is INTEGER
00096 *>          The leading dimension of A.  LDA >= max(1,N).
00097 *> \endverbatim
00098 *>
00099 *> \param[in,out] B
00100 *> \verbatim
00101 *>          B is REAL array, dimension (LDB, N)
00102 *>          On entry, the matrix B.
00103 *>          On exit, the upper triangular matrix T from the generalized
00104 *>          real Schur factorization.
00105 *> \endverbatim
00106 *>
00107 *> \param[in] LDB
00108 *> \verbatim
00109 *>          LDB is INTEGER
00110 *>          The leading dimension of B.  LDB >= max(1,N).
00111 *> \endverbatim
00112 *>
00113 *> \param[out] ALPHAR
00114 *> \verbatim
00115 *>          ALPHAR is REAL array, dimension (N)
00116 *>          The real parts of each scalar alpha defining an eigenvalue
00117 *>          of GNEP.
00118 *> \endverbatim
00119 *>
00120 *> \param[out] ALPHAI
00121 *> \verbatim
00122 *>          ALPHAI is REAL array, dimension (N)
00123 *>          The imaginary parts of each scalar alpha defining an
00124 *>          eigenvalue of GNEP.  If ALPHAI(j) is zero, then the j-th
00125 *>          eigenvalue is real; if positive, then the j-th and (j+1)-st
00126 *>          eigenvalues are a complex conjugate pair, with
00127 *>          ALPHAI(j+1) = -ALPHAI(j).
00128 *> \endverbatim
00129 *>
00130 *> \param[out] BETA
00131 *> \verbatim
00132 *>          BETA is REAL array, dimension (N)
00133 *>          The scalars beta that define the eigenvalues of GNEP.
00134 *>          Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and
00135 *>          beta = BETA(j) represent the j-th eigenvalue of the matrix
00136 *>          pair (A,B), in one of the forms lambda = alpha/beta or
00137 *>          mu = beta/alpha.  Since either lambda or mu may overflow,
00138 *>          they should not, in general, be computed.
00139 *> \endverbatim
00140 *>
00141 *> \param[out] VSL
00142 *> \verbatim
00143 *>          VSL is REAL array, dimension (LDVSL,N)
00144 *>          If JOBVSL = 'V', the matrix of left Schur vectors Q.
00145 *>          Not referenced if JOBVSL = 'N'.
00146 *> \endverbatim
00147 *>
00148 *> \param[in] LDVSL
00149 *> \verbatim
00150 *>          LDVSL is INTEGER
00151 *>          The leading dimension of the matrix VSL. LDVSL >=1, and
00152 *>          if JOBVSL = 'V', LDVSL >= N.
00153 *> \endverbatim
00154 *>
00155 *> \param[out] VSR
00156 *> \verbatim
00157 *>          VSR is REAL array, dimension (LDVSR,N)
00158 *>          If JOBVSR = 'V', the matrix of right Schur vectors Z.
00159 *>          Not referenced if JOBVSR = 'N'.
00160 *> \endverbatim
00161 *>
00162 *> \param[in] LDVSR
00163 *> \verbatim
00164 *>          LDVSR is INTEGER
00165 *>          The leading dimension of the matrix VSR. LDVSR >= 1, and
00166 *>          if JOBVSR = 'V', LDVSR >= N.
00167 *> \endverbatim
00168 *>
00169 *> \param[out] WORK
00170 *> \verbatim
00171 *>          WORK is REAL array, dimension (MAX(1,LWORK))
00172 *>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
00173 *> \endverbatim
00174 *>
00175 *> \param[in] LWORK
00176 *> \verbatim
00177 *>          LWORK is INTEGER
00178 *>          The dimension of the array WORK.  LWORK >= max(1,4*N).
00179 *>          For good performance, LWORK must generally be larger.
00180 *>          To compute the optimal value of LWORK, call ILAENV to get
00181 *>          blocksizes (for SGEQRF, SORMQR, and SORGQR.)  Then compute:
00182 *>          NB  -- MAX of the blocksizes for SGEQRF, SORMQR, and SORGQR
00183 *>          The optimal LWORK is  2*N + N*(NB+1).
00184 *>
00185 *>          If LWORK = -1, then a workspace query is assumed; the routine
00186 *>          only calculates the optimal size of the WORK array, returns
00187 *>          this value as the first entry of the WORK array, and no error
00188 *>          message related to LWORK is issued by XERBLA.
00189 *> \endverbatim
00190 *>
00191 *> \param[out] INFO
00192 *> \verbatim
00193 *>          INFO is INTEGER
00194 *>          = 0:  successful exit
00195 *>          < 0:  if INFO = -i, the i-th argument had an illegal value.
00196 *>          = 1,...,N:
00197 *>                The QZ iteration failed.  (A,B) are not in Schur
00198 *>                form, but ALPHAR(j), ALPHAI(j), and BETA(j) should
00199 *>                be correct for j=INFO+1,...,N.
00200 *>          > N:  errors that usually indicate LAPACK problems:
00201 *>                =N+1: error return from SGGBAL
00202 *>                =N+2: error return from SGEQRF
00203 *>                =N+3: error return from SORMQR
00204 *>                =N+4: error return from SORGQR
00205 *>                =N+5: error return from SGGHRD
00206 *>                =N+6: error return from SHGEQZ (other than failed
00207 *>                                                iteration)
00208 *>                =N+7: error return from SGGBAK (computing VSL)
00209 *>                =N+8: error return from SGGBAK (computing VSR)
00210 *>                =N+9: error return from SLASCL (various places)
00211 *> \endverbatim
00212 *
00213 *  Authors:
00214 *  ========
00215 *
00216 *> \author Univ. of Tennessee 
00217 *> \author Univ. of California Berkeley 
00218 *> \author Univ. of Colorado Denver 
00219 *> \author NAG Ltd. 
00220 *
00221 *> \date November 2011
00222 *
00223 *> \ingroup realGEeigen
00224 *
00225 *  =====================================================================
00226       SUBROUTINE SGEGS( JOBVSL, JOBVSR, N, A, LDA, B, LDB, ALPHAR,
00227      $                  ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, WORK,
00228      $                  LWORK, INFO )
00229 *
00230 *  -- LAPACK driver routine (version 3.4.0) --
00231 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00232 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00233 *     November 2011
00234 *
00235 *     .. Scalar Arguments ..
00236       CHARACTER          JOBVSL, JOBVSR
00237       INTEGER            INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N
00238 *     ..
00239 *     .. Array Arguments ..
00240       REAL               A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
00241      $                   B( LDB, * ), BETA( * ), VSL( LDVSL, * ),
00242      $                   VSR( LDVSR, * ), WORK( * )
00243 *     ..
00244 *
00245 *  =====================================================================
00246 *
00247 *     .. Parameters ..
00248       REAL               ZERO, ONE
00249       PARAMETER          ( ZERO = 0.0E0, ONE = 1.0E0 )
00250 *     ..
00251 *     .. Local Scalars ..
00252       LOGICAL            ILASCL, ILBSCL, ILVSL, ILVSR, LQUERY
00253       INTEGER            ICOLS, IHI, IINFO, IJOBVL, IJOBVR, ILEFT,
00254      $                   ILO, IRIGHT, IROWS, ITAU, IWORK, LOPT, LWKMIN,
00255      $                   LWKOPT, NB, NB1, NB2, NB3
00256       REAL               ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS,
00257      $                   SAFMIN, SMLNUM
00258 *     ..
00259 *     .. External Subroutines ..
00260       EXTERNAL           SGEQRF, SGGBAK, SGGBAL, SGGHRD, SHGEQZ, SLACPY,
00261      $                   SLASCL, SLASET, SORGQR, SORMQR, XERBLA
00262 *     ..
00263 *     .. External Functions ..
00264       LOGICAL            LSAME
00265       INTEGER            ILAENV
00266       REAL               SLAMCH, SLANGE
00267       EXTERNAL           ILAENV, LSAME, SLAMCH, SLANGE
00268 *     ..
00269 *     .. Intrinsic Functions ..
00270       INTRINSIC          INT, MAX
00271 *     ..
00272 *     .. Executable Statements ..
00273 *
00274 *     Decode the input arguments
00275 *
00276       IF( LSAME( JOBVSL, 'N' ) ) THEN
00277          IJOBVL = 1
00278          ILVSL = .FALSE.
00279       ELSE IF( LSAME( JOBVSL, 'V' ) ) THEN
00280          IJOBVL = 2
00281          ILVSL = .TRUE.
00282       ELSE
00283          IJOBVL = -1
00284          ILVSL = .FALSE.
00285       END IF
00286 *
00287       IF( LSAME( JOBVSR, 'N' ) ) THEN
00288          IJOBVR = 1
00289          ILVSR = .FALSE.
00290       ELSE IF( LSAME( JOBVSR, 'V' ) ) THEN
00291          IJOBVR = 2
00292          ILVSR = .TRUE.
00293       ELSE
00294          IJOBVR = -1
00295          ILVSR = .FALSE.
00296       END IF
00297 *
00298 *     Test the input arguments
00299 *
00300       LWKMIN = MAX( 4*N, 1 )
00301       LWKOPT = LWKMIN
00302       WORK( 1 ) = LWKOPT
00303       LQUERY = ( LWORK.EQ.-1 )
00304       INFO = 0
00305       IF( IJOBVL.LE.0 ) THEN
00306          INFO = -1
00307       ELSE IF( IJOBVR.LE.0 ) THEN
00308          INFO = -2
00309       ELSE IF( N.LT.0 ) THEN
00310          INFO = -3
00311       ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
00312          INFO = -5
00313       ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
00314          INFO = -7
00315       ELSE IF( LDVSL.LT.1 .OR. ( ILVSL .AND. LDVSL.LT.N ) ) THEN
00316          INFO = -12
00317       ELSE IF( LDVSR.LT.1 .OR. ( ILVSR .AND. LDVSR.LT.N ) ) THEN
00318          INFO = -14
00319       ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN
00320          INFO = -16
00321       END IF
00322 *
00323       IF( INFO.EQ.0 ) THEN
00324          NB1 = ILAENV( 1, 'SGEQRF', ' ', N, N, -1, -1 )
00325          NB2 = ILAENV( 1, 'SORMQR', ' ', N, N, N, -1 )
00326          NB3 = ILAENV( 1, 'SORGQR', ' ', N, N, N, -1 )
00327          NB = MAX( NB1, NB2, NB3 )
00328          LOPT = 2*N+N*(NB+1)
00329          WORK( 1 ) = LOPT
00330       END IF
00331 *
00332       IF( INFO.NE.0 ) THEN
00333          CALL XERBLA( 'SGEGS ', -INFO )
00334          RETURN
00335       ELSE IF( LQUERY ) THEN
00336          RETURN
00337       END IF
00338 *
00339 *     Quick return if possible
00340 *
00341       IF( N.EQ.0 )
00342      $   RETURN
00343 *
00344 *     Get machine constants
00345 *
00346       EPS = SLAMCH( 'E' )*SLAMCH( 'B' )
00347       SAFMIN = SLAMCH( 'S' )
00348       SMLNUM = N*SAFMIN / EPS
00349       BIGNUM = ONE / SMLNUM
00350 *
00351 *     Scale A if max element outside range [SMLNUM,BIGNUM]
00352 *
00353       ANRM = SLANGE( 'M', N, N, A, LDA, WORK )
00354       ILASCL = .FALSE.
00355       IF( ANRM.GT.ZERO .AND. ANRM.LT.SMLNUM ) THEN
00356          ANRMTO = SMLNUM
00357          ILASCL = .TRUE.
00358       ELSE IF( ANRM.GT.BIGNUM ) THEN
00359          ANRMTO = BIGNUM
00360          ILASCL = .TRUE.
00361       END IF
00362 *
00363       IF( ILASCL ) THEN
00364          CALL SLASCL( 'G', -1, -1, ANRM, ANRMTO, N, N, A, LDA, IINFO )
00365          IF( IINFO.NE.0 ) THEN
00366             INFO = N + 9
00367             RETURN
00368          END IF
00369       END IF
00370 *
00371 *     Scale B if max element outside range [SMLNUM,BIGNUM]
00372 *
00373       BNRM = SLANGE( 'M', N, N, B, LDB, WORK )
00374       ILBSCL = .FALSE.
00375       IF( BNRM.GT.ZERO .AND. BNRM.LT.SMLNUM ) THEN
00376          BNRMTO = SMLNUM
00377          ILBSCL = .TRUE.
00378       ELSE IF( BNRM.GT.BIGNUM ) THEN
00379          BNRMTO = BIGNUM
00380          ILBSCL = .TRUE.
00381       END IF
00382 *
00383       IF( ILBSCL ) THEN
00384          CALL SLASCL( 'G', -1, -1, BNRM, BNRMTO, N, N, B, LDB, IINFO )
00385          IF( IINFO.NE.0 ) THEN
00386             INFO = N + 9
00387             RETURN
00388          END IF
00389       END IF
00390 *
00391 *     Permute the matrix to make it more nearly triangular
00392 *     Workspace layout:  (2*N words -- "work..." not actually used)
00393 *        left_permutation, right_permutation, work...
00394 *
00395       ILEFT = 1
00396       IRIGHT = N + 1
00397       IWORK = IRIGHT + N
00398       CALL SGGBAL( 'P', N, A, LDA, B, LDB, ILO, IHI, WORK( ILEFT ),
00399      $             WORK( IRIGHT ), WORK( IWORK ), IINFO )
00400       IF( IINFO.NE.0 ) THEN
00401          INFO = N + 1
00402          GO TO 10
00403       END IF
00404 *
00405 *     Reduce B to triangular form, and initialize VSL and/or VSR
00406 *     Workspace layout:  ("work..." must have at least N words)
00407 *        left_permutation, right_permutation, tau, work...
00408 *
00409       IROWS = IHI + 1 - ILO
00410       ICOLS = N + 1 - ILO
00411       ITAU = IWORK
00412       IWORK = ITAU + IROWS
00413       CALL SGEQRF( IROWS, ICOLS, B( ILO, ILO ), LDB, WORK( ITAU ),
00414      $             WORK( IWORK ), LWORK+1-IWORK, IINFO )
00415       IF( IINFO.GE.0 )
00416      $   LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 )
00417       IF( IINFO.NE.0 ) THEN
00418          INFO = N + 2
00419          GO TO 10
00420       END IF
00421 *
00422       CALL SORMQR( 'L', 'T', IROWS, ICOLS, IROWS, B( ILO, ILO ), LDB,
00423      $             WORK( ITAU ), A( ILO, ILO ), LDA, WORK( IWORK ),
00424      $             LWORK+1-IWORK, IINFO )
00425       IF( IINFO.GE.0 )
00426      $   LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 )
00427       IF( IINFO.NE.0 ) THEN
00428          INFO = N + 3
00429          GO TO 10
00430       END IF
00431 *
00432       IF( ILVSL ) THEN
00433          CALL SLASET( 'Full', N, N, ZERO, ONE, VSL, LDVSL )
00434          CALL SLACPY( 'L', IROWS-1, IROWS-1, B( ILO+1, ILO ), LDB,
00435      $                VSL( ILO+1, ILO ), LDVSL )
00436          CALL SORGQR( IROWS, IROWS, IROWS, VSL( ILO, ILO ), LDVSL,
00437      $                WORK( ITAU ), WORK( IWORK ), LWORK+1-IWORK,
00438      $                IINFO )
00439          IF( IINFO.GE.0 )
00440      $      LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 )
00441          IF( IINFO.NE.0 ) THEN
00442             INFO = N + 4
00443             GO TO 10
00444          END IF
00445       END IF
00446 *
00447       IF( ILVSR )
00448      $   CALL SLASET( 'Full', N, N, ZERO, ONE, VSR, LDVSR )
00449 *
00450 *     Reduce to generalized Hessenberg form
00451 *
00452       CALL SGGHRD( JOBVSL, JOBVSR, N, ILO, IHI, A, LDA, B, LDB, VSL,
00453      $             LDVSL, VSR, LDVSR, IINFO )
00454       IF( IINFO.NE.0 ) THEN
00455          INFO = N + 5
00456          GO TO 10
00457       END IF
00458 *
00459 *     Perform QZ algorithm, computing Schur vectors if desired
00460 *     Workspace layout:  ("work..." must have at least 1 word)
00461 *        left_permutation, right_permutation, work...
00462 *
00463       IWORK = ITAU
00464       CALL SHGEQZ( 'S', JOBVSL, JOBVSR, N, ILO, IHI, A, LDA, B, LDB,
00465      $             ALPHAR, ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR,
00466      $             WORK( IWORK ), LWORK+1-IWORK, IINFO )
00467       IF( IINFO.GE.0 )
00468      $   LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 )
00469       IF( IINFO.NE.0 ) THEN
00470          IF( IINFO.GT.0 .AND. IINFO.LE.N ) THEN
00471             INFO = IINFO
00472          ELSE IF( IINFO.GT.N .AND. IINFO.LE.2*N ) THEN
00473             INFO = IINFO - N
00474          ELSE
00475             INFO = N + 6
00476          END IF
00477          GO TO 10
00478       END IF
00479 *
00480 *     Apply permutation to VSL and VSR
00481 *
00482       IF( ILVSL ) THEN
00483          CALL SGGBAK( 'P', 'L', N, ILO, IHI, WORK( ILEFT ),
00484      $                WORK( IRIGHT ), N, VSL, LDVSL, IINFO )
00485          IF( IINFO.NE.0 ) THEN
00486             INFO = N + 7
00487             GO TO 10
00488          END IF
00489       END IF
00490       IF( ILVSR ) THEN
00491          CALL SGGBAK( 'P', 'R', N, ILO, IHI, WORK( ILEFT ),
00492      $                WORK( IRIGHT ), N, VSR, LDVSR, IINFO )
00493          IF( IINFO.NE.0 ) THEN
00494             INFO = N + 8
00495             GO TO 10
00496          END IF
00497       END IF
00498 *
00499 *     Undo scaling
00500 *
00501       IF( ILASCL ) THEN
00502          CALL SLASCL( 'H', -1, -1, ANRMTO, ANRM, N, N, A, LDA, IINFO )
00503          IF( IINFO.NE.0 ) THEN
00504             INFO = N + 9
00505             RETURN
00506          END IF
00507          CALL SLASCL( 'G', -1, -1, ANRMTO, ANRM, N, 1, ALPHAR, N,
00508      $                IINFO )
00509          IF( IINFO.NE.0 ) THEN
00510             INFO = N + 9
00511             RETURN
00512          END IF
00513          CALL SLASCL( 'G', -1, -1, ANRMTO, ANRM, N, 1, ALPHAI, N,
00514      $                IINFO )
00515          IF( IINFO.NE.0 ) THEN
00516             INFO = N + 9
00517             RETURN
00518          END IF
00519       END IF
00520 *
00521       IF( ILBSCL ) THEN
00522          CALL SLASCL( 'U', -1, -1, BNRMTO, BNRM, N, N, B, LDB, IINFO )
00523          IF( IINFO.NE.0 ) THEN
00524             INFO = N + 9
00525             RETURN
00526          END IF
00527          CALL SLASCL( 'G', -1, -1, BNRMTO, BNRM, N, 1, BETA, N, IINFO )
00528          IF( IINFO.NE.0 ) THEN
00529             INFO = N + 9
00530             RETURN
00531          END IF
00532       END IF
00533 *
00534    10 CONTINUE
00535       WORK( 1 ) = LWKOPT
00536 *
00537       RETURN
00538 *
00539 *     End of SGEGS
00540 *
00541       END
 All Files Functions