Next: Sorting Eigenvalues and Eigenvectors, Previous: Complex Generalized Hermitian-Definite Eigensystems, Up: Eigensystems [Index]

Given two square matrices (*A*, *B*), the generalized
nonsymmetric eigenvalue problem is to find eigenvalues *\lambda* and
eigenvectors *x* such that

A x = \lambda B x

We may also define the problem as finding eigenvalues *\mu* and
eigenvectors *y* such that

\mu A y = B y

Note that these two problems are equivalent (with *\lambda = 1/\mu*)
if neither *\lambda* nor *\mu* is zero. If say, *\lambda*
is zero, then it is still a well defined eigenproblem, but its alternate
problem involving *\mu* is not. Therefore, to allow for zero
(and infinite) eigenvalues, the problem which is actually solved is

\beta A x = \alpha B x

The eigensolver routines below will return two values *\alpha*
and *\beta* and leave it to the user to perform the divisions
*\lambda = \alpha / \beta* and *\mu = \beta / \alpha*.

If the determinant of the matrix pencil *A - \lambda B* is zero
for all *\lambda*, the problem is said to be singular; otherwise
it is called regular. Singularity normally leads to some
*\alpha = \beta = 0* which means the eigenproblem is ill-conditioned
and generally does not have well defined eigenvalue solutions. The
routines below are intended for regular matrix pencils and could yield
unpredictable results when applied to singular pencils.

The solution of the real generalized nonsymmetric eigensystem problem for a
matrix pair *(A, B)* involves computing the generalized Schur
decomposition

A = Q S Z^T B = Q T Z^T

where *Q* and *Z* are orthogonal matrices of left and right
Schur vectors respectively, and *(S, T)* is the generalized Schur
form whose diagonal elements give the *\alpha* and *\beta*
values. The algorithm used is the QZ method due to Moler and Stewart
(see references).

- Function:
*gsl_eigen_gen_workspace ****gsl_eigen_gen_alloc***(const size_t*`n`) -
This function allocates a workspace for computing eigenvalues of

`n`-by-`n`real generalized nonsymmetric eigensystems. The size of the workspace is*O(n)*.

- Function:
*void***gsl_eigen_gen_free***(gsl_eigen_gen_workspace **`w`) This function frees the memory associated with the workspace

`w`.

- Function:
*void***gsl_eigen_gen_params***(const int*`compute_s`, const int`compute_t`, const int`balance`, gsl_eigen_gen_workspace *`w`) This function sets some parameters which determine how the eigenvalue problem is solved in subsequent calls to

`gsl_eigen_gen`

.If

`compute_s`is set to 1, the full Schur form*S*will be computed by`gsl_eigen_gen`

. If it is set to 0,*S*will not be computed (this is the default setting).*S*is a quasi upper triangular matrix with 1-by-1 and 2-by-2 blocks on its diagonal. 1-by-1 blocks correspond to real eigenvalues, and 2-by-2 blocks correspond to complex eigenvalues.If

`compute_t`is set to 1, the full Schur form*T*will be computed by`gsl_eigen_gen`

. If it is set to 0,*T*will not be computed (this is the default setting).*T*is an upper triangular matrix with non-negative elements on its diagonal. Any 2-by-2 blocks in*S*will correspond to a 2-by-2 diagonal block in*T*.The

`balance`parameter is currently ignored, since generalized balancing is not yet implemented.

- Function:
*int***gsl_eigen_gen***(gsl_matrix **`A`, gsl_matrix *`B`, gsl_vector_complex *`alpha`, gsl_vector *`beta`, gsl_eigen_gen_workspace *`w`) This function computes the eigenvalues of the real generalized nonsymmetric matrix pair (

`A`,`B`), and stores them as pairs in (`alpha`,`beta`), where`alpha`is complex and`beta`is real. If*\beta_i*is non-zero, then*\lambda = \alpha_i / \beta_i*is an eigenvalue. Likewise, if*\alpha_i*is non-zero, then*\mu = \beta_i / \alpha_i*is an eigenvalue of the alternate problem*\mu A y = B y*. The elements of`beta`are normalized to be non-negative.If

*S*is desired, it is stored in`A`on output. If*T*is desired, it is stored in`B`on output. The ordering of eigenvalues in (`alpha`,`beta`) follows the ordering of the diagonal blocks in the Schur forms*S*and*T*. In rare cases, this function may fail to find all eigenvalues. If this occurs, an error code is returned.

- Function:
*int***gsl_eigen_gen_QZ***(gsl_matrix **`A`, gsl_matrix *`B`, gsl_vector_complex *`alpha`, gsl_vector *`beta`, gsl_matrix *`Q`, gsl_matrix *`Z`, gsl_eigen_gen_workspace *`w`) This function is identical to

`gsl_eigen_gen`

except that it also computes the left and right Schur vectors and stores them into`Q`and`Z`respectively.

- Function:
*gsl_eigen_genv_workspace ****gsl_eigen_genv_alloc***(const size_t*`n`) -
This function allocates a workspace for computing eigenvalues and eigenvectors of

`n`-by-`n`real generalized nonsymmetric eigensystems. The size of the workspace is*O(7n)*.

- Function:
*void***gsl_eigen_genv_free***(gsl_eigen_genv_workspace **`w`) This function frees the memory associated with the workspace

`w`.

- Function:
*int***gsl_eigen_genv***(gsl_matrix **`A`, gsl_matrix *`B`, gsl_vector_complex *`alpha`, gsl_vector *`beta`, gsl_matrix_complex *`evec`, gsl_eigen_genv_workspace *`w`) This function computes eigenvalues and right eigenvectors of the

`n`-by-`n`real generalized nonsymmetric matrix pair (`A`,`B`). The eigenvalues are stored in (`alpha`,`beta`) and the eigenvectors are stored in`evec`. It first calls`gsl_eigen_gen`

to compute the eigenvalues, Schur forms, and Schur vectors. Then it finds eigenvectors of the Schur forms and backtransforms them using the Schur vectors. The Schur vectors are destroyed in the process, but can be saved by using`gsl_eigen_genv_QZ`

. The computed eigenvectors are normalized to have unit magnitude. On output, (`A`,`B`) contains the generalized Schur form (*S*,*T*). If`gsl_eigen_gen`

fails, no eigenvectors are computed, and an error code is returned.

- Function:
*int***gsl_eigen_genv_QZ***(gsl_matrix **`A`, gsl_matrix *`B`, gsl_vector_complex *`alpha`, gsl_vector *`beta`, gsl_matrix_complex *`evec`, gsl_matrix *`Q`, gsl_matrix *`Z`, gsl_eigen_genv_workspace *`w`) This function is identical to

`gsl_eigen_genv`

except that it also computes the left and right Schur vectors and stores them into`Q`and`Z`respectively.