SGEEV(l)	     LAPACK driver routine (version 1.1)	     SGEEV(l)

NAME
  SGEEV	- compute for an N-by-N	real nonsymmetric matrix A, the	eigenvalues
  and, optionally, the left and/or right eigenvectors

SYNOPSIS

  SUBROUTINE SGEEV( JOBVL, JOBVR, N, A,	LDA, WR, WI, VL, LDVL, VR, LDVR,
		    WORK, LWORK, INFO )

      CHARACTER	    JOBVL, JOBVR

      INTEGER	    INFO, LDA, LDVL, LDVR, LWORK, N

      REAL	    A( LDA, * ), VL( LDVL, * ),	VR( LDVR, * ), WI( * ),	WORK(
		    * ), WR( * )

PURPOSE
  SGEEV	computes for an	N-by-N real nonsymmetric matrix	A, the eigenvalues
  and, optionally, the left and/or right eigenvectors.

  The left eigenvectors	of A are the same as the right eigenvectors of A**T.
  If u(j) and v(j) are the left	and right eigenvectors,	respectively,
  corresponding	to the eigenvalue lambda(j), then (u(j)**T)*A =
  lambda(j)*(u(j)**T) and A*v(j) = lambda(j) * v(j).

  The computed eigenvectors are	normalized to have Euclidean norm equal	to 1
  and largest component	real.

ARGUMENTS

  JOBVL	  (input) CHARACTER*1
	  = 'N': left eigenvectors of A	are not	computed;
	  = 'V': left eigenvectors of A	are computed.

  JOBVR	  (input) CHARACTER*1
	  = 'N': right eigenvectors of A are not computed;
	  = 'V': right eigenvectors of A are computed.

  N	  (input) INTEGER
	  The order of the matrix A. N >= 0.

  A	  (input/output) REAL array, dimension (LDA,N)
	  On entry, the	N-by-N matrix A.  On exit, A has been overwritten.

  LDA	  (input) INTEGER
	  The leading dimension	of the array A.	 LDA >=	max(1,N).

  WR	  (output) REAL	array, dimension (N)
	  WI	  (output) REAL	array, dimension (N) WR	and WI contain the
	  real and imaginary parts, respectively, of the computed eigen-
	  values.  Complex conjugate pairs of eigenvalues appear consecu-
	  tively with the eigenvalue having the	positive imaginary part
	  first.

  VL	  (output) REAL	array, dimension (LDVL,N)
	  If JOBVL = 'V', the left eigenvectors	u(j) are stored	one after
	  another in the columns of VL,	in the same order as their eigen-
	  values.  If JOBVL = 'N', VL is not referenced.  If the j-th
	  eigenvalue is	real, then u(j)	= VL(:,j), the j-th column of VL.  If
	  the j-th and (j+1)-st	eigenvalues form a complex conjugate pair,
	  then u(j) = VL(:,j) +	i*VL(:,j+1) and
	  u(j+1) = VL(:,j) = i*VL(:,j+1).

  LDVL	  (input) INTEGER
	  The leading dimension	of the array VL.  LDVL >= 1; if	JOBVL =	'V',
	  LDVL >= N.

  VR	  (output) REAL	array, dimension (LDVR,N)
	  If JOBVR = 'V', the right eigenvectors v(j) are stored one after
	  another in the columns of VR,	in the same order as their eigen-
	  values.  If JOBVR = 'N', VR is not referenced.  If the j-th eigen-
	  value	is real, then v(j) = VR(:,j), the j-th column of VR.  If the
	  j-th and (j+1)-st eigenvalues	form a complex conjugate pair, then
	  v(j) = VR(:,j) + i*VR(:,j+1) and
	  v(j+1) = VR(:,j) = i*VR(:,j+1).

  LDVR	  (input) INTEGER
	  The leading dimension	of the array VR.  LDVR >= 1; if	JOBVR =	'V',
	  LDVR >= N.

  WORK	  (workspace/output) REAL array, dimension (LWORK)
	  On exit, if INFO = 0,	WORK(1)	returns	the optimal LWORK.

  LWORK	  (input) INTEGER
	  The dimension	of the array WORK.  LWORK >= max(1,3*N), and if	JOBVL
	  = 'V'	or JOBVR = 'V',	LWORK >= 4*N.  For good	performance, LWORK
	  must generally be larger.

  INFO	  (output) INTEGER
	  = 0:	successful exit
	  < 0:	if INFO	= -i, the i-th argument	had an illegal value.
	  > 0:	if INFO	= i, the QR algorithm failed to	compute	all the
	  eigenvalues, and no eigenvectors have	been computed; elements	i+1:N
	  of WR	and WI contain eigenvalues which have converged.