hsein(3)

NAME
hsein - hsein: Hessenberg inverse iteration for eigvec

SYNOPSIS

  Functions
subroutine chsein (side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)
CHSEIN
subroutine dhsein (side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)
DHSEIN
subroutine shsein (side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)
SHSEIN
subroutine zhsein (side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)
ZHSEIN

Detailed Description

Function Documentation

  subroutine chsein (character side, character eigsrc, character initv, logical, dimension( * ) select, integer n, complex, dimension( ldh, * ) h, integer ldh, complex, dimension( * ) w, complex, dimension( ldvl, * ) vl, integer ldvl, complex, dimension( ldvr, * ) vr, integer ldvr, integer mm, integer m, complex, dimension( * ) work, real, dimension( * ) rwork, integer, dimension( * ) ifaill, integer, dimension( * ) ifailr, integer info)

CHSEIN

Purpose:

     CHSEIN uses inverse iteration to find specified right and/or left
     eigenvectors of a complex upper Hessenberg matrix H.
     The right eigenvector x and the left eigenvector y of the matrix H
     corresponding to an eigenvalue w are defined by:
                  H * x = w * x,     y**h * H = w * y**h
     where y**h denotes the conjugate transpose of the vector y.

Parameters
    SIDE

              SIDE is CHARACTER*1
              = 'R': compute right eigenvectors only;
              = 'L': compute left eigenvectors only;
              = 'B': compute both right and left eigenvectors.

    EIGSRC

              EIGSRC is CHARACTER*1
              Specifies the source of eigenvalues supplied in W:
              = 'Q': the eigenvalues were found using CHSEQR; thus, if
                     H has zero subdiagonal elements, and so is
                     block-triangular, then the j-th eigenvalue can be
                     assumed to be an eigenvalue of the block containing
                     the j-th row/column.  This property allows CHSEIN to
                     perform inverse iteration on just one diagonal block.
              = 'N': no assumptions are made on the correspondence
                     between eigenvalues and diagonal blocks.  In this
                     case, CHSEIN must always perform inverse iteration
                     using the whole matrix H.

    INITV

              INITV is CHARACTER*1
              = 'N': no initial vectors are supplied;
              = 'U': user-supplied initial vectors are stored in the arrays
                     VL and/or VR.

    SELECT

              SELECT is LOGICAL array, dimension (N)
              Specifies the eigenvectors to be computed. To select the
              eigenvector corresponding to the eigenvalue W(j),
              SELECT(j) must be set to .TRUE..

    N

              N is INTEGER
              The order of the matrix H.  N >= 0.

    H

              H is COMPLEX array, dimension (LDH,N)
              The upper Hessenberg matrix H.
              If a NaN is detected in H, the routine will return with INFO=-6.

    LDH

              LDH is INTEGER
              The leading dimension of the array H.  LDH >= max(1,N).

    W

              W is COMPLEX array, dimension (N)
              On entry, the eigenvalues of H.
              On exit, the real parts of W may have been altered since
              close eigenvalues are perturbed slightly in searching for
              independent eigenvectors.

    VL

              VL is COMPLEX array, dimension (LDVL,MM)
              On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must
              contain starting vectors for the inverse iteration for the
              left eigenvectors; the starting vector for each eigenvector
              must be in the same column in which the eigenvector will be
              stored.
              On exit, if SIDE = 'L' or 'B', the left eigenvectors
              specified by SELECT will be stored consecutively in the
              columns of VL, in the same order as their eigenvalues.
              If SIDE = 'R', VL is not referenced.

    LDVL

              LDVL is INTEGER
              The leading dimension of the array VL.
              LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise.

    VR

              VR is COMPLEX array, dimension (LDVR,MM)
              On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must
              contain starting vectors for the inverse iteration for the
              right eigenvectors; the starting vector for each eigenvector
              must be in the same column in which the eigenvector will be
              stored.
              On exit, if SIDE = 'R' or 'B', the right eigenvectors
              specified by SELECT will be stored consecutively in the
              columns of VR, in the same order as their eigenvalues.
              If SIDE = 'L', VR is not referenced.

    LDVR

              LDVR is INTEGER
              The leading dimension of the array VR.
              LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise.

    MM

              MM is INTEGER
              The number of columns in the arrays VL and/or VR. MM >= M.

    M

              M is INTEGER
              The number of columns in the arrays VL and/or VR required to
              store the eigenvectors (= the number of .TRUE. elements in
              SELECT).

    WORK

              WORK is COMPLEX array, dimension (N*N)

    RWORK

              RWORK is REAL array, dimension (N)

    IFAILL

              IFAILL is INTEGER array, dimension (MM)
              If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left
              eigenvector in the i-th column of VL (corresponding to the
              eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the
              eigenvector converged satisfactorily.
              If SIDE = 'R', IFAILL is not referenced.

    IFAILR

              IFAILR is INTEGER array, dimension (MM)
              If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right
              eigenvector in the i-th column of VR (corresponding to the
              eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the
              eigenvector converged satisfactorily.
              If SIDE = 'L', IFAILR is not referenced.

    INFO

              INFO is INTEGER
              = 0:  successful exit
              < 0:  if INFO = -i, the i-th argument had an illegal value
              > 0:  if INFO = i, i is the number of eigenvectors which
                    failed to converge; see IFAILL and IFAILR for further
                    details.

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

      Each eigenvector is normalized so that the element of largest
      magnitude has magnitude 1; here the magnitude of a complex number
      (x,y) is taken to be |x|+|y|.

Definition at line 242 of file chsein.f.

  subroutine dhsein (character side, character eigsrc, character initv, logical, dimension( * ) select, integer n, double precision, dimension( ldh, * ) h, integer ldh, double precision, dimension( * ) wr, double precision, dimension( * ) wi, double precision, dimension( ldvl, * ) vl, integer ldvl, double precision, dimension( ldvr, * ) vr, integer ldvr, integer mm, integer m, double precision, dimension( * ) work, integer, dimension( * ) ifaill, integer, dimension( * ) ifailr, integer info)

DHSEIN

Purpose:

     DHSEIN uses inverse iteration to find specified right and/or left
     eigenvectors of a real upper Hessenberg matrix H.
     The right eigenvector x and the left eigenvector y of the matrix H
     corresponding to an eigenvalue w are defined by:
                  H * x = w * x,     y**h * H = w * y**h
     where y**h denotes the conjugate transpose of the vector y.

Parameters
    SIDE

              SIDE is CHARACTER*1
              = 'R': compute right eigenvectors only;
              = 'L': compute left eigenvectors only;
              = 'B': compute both right and left eigenvectors.

    EIGSRC

              EIGSRC is CHARACTER*1
              Specifies the source of eigenvalues supplied in (WR,WI):
              = 'Q': the eigenvalues were found using DHSEQR; thus, if
                     H has zero subdiagonal elements, and so is
                     block-triangular, then the j-th eigenvalue can be
                     assumed to be an eigenvalue of the block containing
                     the j-th row/column.  This property allows DHSEIN to
                     perform inverse iteration on just one diagonal block.
              = 'N': no assumptions are made on the correspondence
                     between eigenvalues and diagonal blocks.  In this
                     case, DHSEIN must always perform inverse iteration
                     using the whole matrix H.

    INITV

              INITV is CHARACTER*1
              = 'N': no initial vectors are supplied;
              = 'U': user-supplied initial vectors are stored in the arrays
                     VL and/or VR.

    SELECT

              SELECT is LOGICAL array, dimension (N)
              Specifies the eigenvectors to be computed. To select the
              real eigenvector corresponding to a real eigenvalue WR(j),
              SELECT(j) must be set to .TRUE.. To select the complex
              eigenvector corresponding to a complex eigenvalue
              (WR(j),WI(j)), with complex conjugate (WR(j+1),WI(j+1)),
              either SELECT(j) or SELECT(j+1) or both must be set to
              .TRUE.; then on exit SELECT(j) is .TRUE. and SELECT(j+1) is
              .FALSE..

    N

              N is INTEGER
              The order of the matrix H.  N >= 0.

    H

              H is DOUBLE PRECISION array, dimension (LDH,N)
              The upper Hessenberg matrix H.
              If a NaN is detected in H, the routine will return with INFO=-6.

    LDH

              LDH is INTEGER
              The leading dimension of the array H.  LDH >= max(1,N).

    WR

              WR is DOUBLE PRECISION array, dimension (N)

    WI

              WI is DOUBLE PRECISION array, dimension (N)
              On entry, the real and imaginary parts of the eigenvalues of
              H; a complex conjugate pair of eigenvalues must be stored in
              consecutive elements of WR and WI.
              On exit, WR may have been altered since close eigenvalues
              are perturbed slightly in searching for independent
              eigenvectors.

    VL

              VL is DOUBLE PRECISION array, dimension (LDVL,MM)
              On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must
              contain starting vectors for the inverse iteration for the
              left eigenvectors; the starting vector for each eigenvector
              must be in the same column(s) in which the eigenvector will
              be stored.
              On exit, if SIDE = 'L' or 'B', the left eigenvectors
              specified by SELECT will be stored consecutively in the
              columns of VL, in the same order as their eigenvalues. A
              complex eigenvector corresponding to a complex eigenvalue is
              stored in two consecutive columns, the first holding the real
              part and the second the imaginary part.
              If SIDE = 'R', VL is not referenced.

    LDVL

              LDVL is INTEGER
              The leading dimension of the array VL.
              LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise.

    VR

              VR is DOUBLE PRECISION array, dimension (LDVR,MM)
              On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must
              contain starting vectors for the inverse iteration for the
              right eigenvectors; the starting vector for each eigenvector
              must be in the same column(s) in which the eigenvector will
              be stored.
              On exit, if SIDE = 'R' or 'B', the right eigenvectors
              specified by SELECT will be stored consecutively in the
              columns of VR, in the same order as their eigenvalues. A
              complex eigenvector corresponding to a complex eigenvalue is
              stored in two consecutive columns, the first holding the real
              part and the second the imaginary part.
              If SIDE = 'L', VR is not referenced.

    LDVR

              LDVR is INTEGER
              The leading dimension of the array VR.
              LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise.

    MM

              MM is INTEGER
              The number of columns in the arrays VL and/or VR. MM >= M.

    M

              M is INTEGER
              The number of columns in the arrays VL and/or VR required to
              store the eigenvectors; each selected real eigenvector
              occupies one column and each selected complex eigenvector
              occupies two columns.

    WORK

              WORK is DOUBLE PRECISION array, dimension ((N+2)*N)

    IFAILL

              IFAILL is INTEGER array, dimension (MM)
              If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left
              eigenvector in the i-th column of VL (corresponding to the
              eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the
              eigenvector converged satisfactorily. If the i-th and (i+1)th
              columns of VL hold a complex eigenvector, then IFAILL(i) and
              IFAILL(i+1) are set to the same value.
              If SIDE = 'R', IFAILL is not referenced.

    IFAILR

              IFAILR is INTEGER array, dimension (MM)
              If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right
              eigenvector in the i-th column of VR (corresponding to the
              eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the
              eigenvector converged satisfactorily. If the i-th and (i+1)th
              columns of VR hold a complex eigenvector, then IFAILR(i) and
              IFAILR(i+1) are set to the same value.
              If SIDE = 'L', IFAILR is not referenced.

    INFO

              INFO is INTEGER
              = 0:  successful exit
              < 0:  if INFO = -i, the i-th argument had an illegal value
              > 0:  if INFO = i, i is the number of eigenvectors which
                    failed to converge; see IFAILL and IFAILR for further
                    details.

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

      Each eigenvector is normalized so that the element of largest
      magnitude has magnitude 1; here the magnitude of a complex number
      (x,y) is taken to be |x|+|y|.

Definition at line 260 of file dhsein.f.

  subroutine shsein (character side, character eigsrc, character initv, logical, dimension( * ) select, integer n, real, dimension( ldh, * ) h, integer ldh, real, dimension( * ) wr, real, dimension( * ) wi, real, dimension( ldvl, * ) vl, integer ldvl, real, dimension( ldvr, * ) vr, integer ldvr, integer mm, integer m, real, dimension( * ) work, integer, dimension( * ) ifaill, integer, dimension( * ) ifailr, integer info)

SHSEIN

Purpose:

     SHSEIN uses inverse iteration to find specified right and/or left
     eigenvectors of a real upper Hessenberg matrix H.
     The right eigenvector x and the left eigenvector y of the matrix H
     corresponding to an eigenvalue w are defined by:
                  H * x = w * x,     y**h * H = w * y**h
     where y**h denotes the conjugate transpose of the vector y.

Parameters
    SIDE

              SIDE is CHARACTER*1
              = 'R': compute right eigenvectors only;
              = 'L': compute left eigenvectors only;
              = 'B': compute both right and left eigenvectors.

    EIGSRC

              EIGSRC is CHARACTER*1
              Specifies the source of eigenvalues supplied in (WR,WI):
              = 'Q': the eigenvalues were found using SHSEQR; thus, if
                     H has zero subdiagonal elements, and so is
                     block-triangular, then the j-th eigenvalue can be
                     assumed to be an eigenvalue of the block containing
                     the j-th row/column.  This property allows SHSEIN to
                     perform inverse iteration on just one diagonal block.
              = 'N': no assumptions are made on the correspondence
                     between eigenvalues and diagonal blocks.  In this
                     case, SHSEIN must always perform inverse iteration
                     using the whole matrix H.

    INITV

              INITV is CHARACTER*1
              = 'N': no initial vectors are supplied;
              = 'U': user-supplied initial vectors are stored in the arrays
                     VL and/or VR.

    SELECT

              SELECT is LOGICAL array, dimension (N)
              Specifies the eigenvectors to be computed. To select the
              real eigenvector corresponding to a real eigenvalue WR(j),
              SELECT(j) must be set to .TRUE.. To select the complex
              eigenvector corresponding to a complex eigenvalue
              (WR(j),WI(j)), with complex conjugate (WR(j+1),WI(j+1)),
              either SELECT(j) or SELECT(j+1) or both must be set to
              .TRUE.; then on exit SELECT(j) is .TRUE. and SELECT(j+1) is
              .FALSE..

    N

              N is INTEGER
              The order of the matrix H.  N >= 0.

    H

              H is REAL array, dimension (LDH,N)
              The upper Hessenberg matrix H.
              If a NaN is detected in H, the routine will return with INFO=-6.

    LDH

              LDH is INTEGER
              The leading dimension of the array H.  LDH >= max(1,N).

    WR

              WR is REAL array, dimension (N)

    WI

              WI is REAL array, dimension (N)
              On entry, the real and imaginary parts of the eigenvalues of
              H; a complex conjugate pair of eigenvalues must be stored in
              consecutive elements of WR and WI.
              On exit, WR may have been altered since close eigenvalues
              are perturbed slightly in searching for independent
              eigenvectors.

    VL

              VL is REAL array, dimension (LDVL,MM)
              On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must
              contain starting vectors for the inverse iteration for the
              left eigenvectors; the starting vector for each eigenvector
              must be in the same column(s) in which the eigenvector will
              be stored.
              On exit, if SIDE = 'L' or 'B', the left eigenvectors
              specified by SELECT will be stored consecutively in the
              columns of VL, in the same order as their eigenvalues. A
              complex eigenvector corresponding to a complex eigenvalue is
              stored in two consecutive columns, the first holding the real
              part and the second the imaginary part.
              If SIDE = 'R', VL is not referenced.

    LDVL

              LDVL is INTEGER
              The leading dimension of the array VL.
              LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise.

    VR

              VR is REAL array, dimension (LDVR,MM)
              On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must
              contain starting vectors for the inverse iteration for the
              right eigenvectors; the starting vector for each eigenvector
              must be in the same column(s) in which the eigenvector will
              be stored.
              On exit, if SIDE = 'R' or 'B', the right eigenvectors
              specified by SELECT will be stored consecutively in the
              columns of VR, in the same order as their eigenvalues. A
              complex eigenvector corresponding to a complex eigenvalue is
              stored in two consecutive columns, the first holding the real
              part and the second the imaginary part.
              If SIDE = 'L', VR is not referenced.

    LDVR

              LDVR is INTEGER
              The leading dimension of the array VR.
              LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise.

    MM

              MM is INTEGER
              The number of columns in the arrays VL and/or VR. MM >= M.

    M

              M is INTEGER
              The number of columns in the arrays VL and/or VR required to
              store the eigenvectors; each selected real eigenvector
              occupies one column and each selected complex eigenvector
              occupies two columns.

    WORK

              WORK is REAL array, dimension ((N+2)*N)

    IFAILL

              IFAILL is INTEGER array, dimension (MM)
              If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left
              eigenvector in the i-th column of VL (corresponding to the
              eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the
              eigenvector converged satisfactorily. If the i-th and (i+1)th
              columns of VL hold a complex eigenvector, then IFAILL(i) and
              IFAILL(i+1) are set to the same value.
              If SIDE = 'R', IFAILL is not referenced.

    IFAILR

              IFAILR is INTEGER array, dimension (MM)
              If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right
              eigenvector in the i-th column of VR (corresponding to the
              eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the
              eigenvector converged satisfactorily. If the i-th and (i+1)th
              columns of VR hold a complex eigenvector, then IFAILR(i) and
              IFAILR(i+1) are set to the same value.
              If SIDE = 'L', IFAILR is not referenced.

    INFO

              INFO is INTEGER
              = 0:  successful exit
              < 0:  if INFO = -i, the i-th argument had an illegal value
              > 0:  if INFO = i, i is the number of eigenvectors which
                    failed to converge; see IFAILL and IFAILR for further
                    details.

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

      Each eigenvector is normalized so that the element of largest
      magnitude has magnitude 1; here the magnitude of a complex number
      (x,y) is taken to be |x|+|y|.

Definition at line 260 of file shsein.f.

  subroutine zhsein (character side, character eigsrc, character initv, logical, dimension( * ) select, integer n, complex*16, dimension( ldh, * ) h, integer ldh, complex*16, dimension( * ) w, complex*16, dimension( ldvl, * ) vl, integer ldvl, complex*16, dimension( ldvr, * ) vr, integer ldvr, integer mm, integer m, complex*16, dimension( * ) work, double precision, dimension( * ) rwork, integer, dimension( * ) ifaill, integer, dimension( * ) ifailr, integer info)

ZHSEIN

Purpose:

     ZHSEIN uses inverse iteration to find specified right and/or left
     eigenvectors of a complex upper Hessenberg matrix H.
     The right eigenvector x and the left eigenvector y of the matrix H
     corresponding to an eigenvalue w are defined by:
                  H * x = w * x,     y**h * H = w * y**h
     where y**h denotes the conjugate transpose of the vector y.

Parameters
    SIDE

              SIDE is CHARACTER*1
              = 'R': compute right eigenvectors only;
              = 'L': compute left eigenvectors only;
              = 'B': compute both right and left eigenvectors.

    EIGSRC

              EIGSRC is CHARACTER*1
              Specifies the source of eigenvalues supplied in W:
              = 'Q': the eigenvalues were found using ZHSEQR; thus, if
                     H has zero subdiagonal elements, and so is
                     block-triangular, then the j-th eigenvalue can be
                     assumed to be an eigenvalue of the block containing
                     the j-th row/column.  This property allows ZHSEIN to
                     perform inverse iteration on just one diagonal block.
              = 'N': no assumptions are made on the correspondence
                     between eigenvalues and diagonal blocks.  In this
                     case, ZHSEIN must always perform inverse iteration
                     using the whole matrix H.

    INITV

              INITV is CHARACTER*1
              = 'N': no initial vectors are supplied;
              = 'U': user-supplied initial vectors are stored in the arrays
                     VL and/or VR.

    SELECT

              SELECT is LOGICAL array, dimension (N)
              Specifies the eigenvectors to be computed. To select the
              eigenvector corresponding to the eigenvalue W(j),
              SELECT(j) must be set to .TRUE..

    N

              N is INTEGER
              The order of the matrix H.  N >= 0.

    H

              H is COMPLEX*16 array, dimension (LDH,N)
              The upper Hessenberg matrix H.
              If a NaN is detected in H, the routine will return with INFO=-6.

    LDH

              LDH is INTEGER
              The leading dimension of the array H.  LDH >= max(1,N).

    W

              W is COMPLEX*16 array, dimension (N)
              On entry, the eigenvalues of H.
              On exit, the real parts of W may have been altered since
              close eigenvalues are perturbed slightly in searching for
              independent eigenvectors.

    VL

              VL is COMPLEX*16 array, dimension (LDVL,MM)
              On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must
              contain starting vectors for the inverse iteration for the
              left eigenvectors; the starting vector for each eigenvector
              must be in the same column in which the eigenvector will be
              stored.
              On exit, if SIDE = 'L' or 'B', the left eigenvectors
              specified by SELECT will be stored consecutively in the
              columns of VL, in the same order as their eigenvalues.
              If SIDE = 'R', VL is not referenced.

    LDVL

              LDVL is INTEGER
              The leading dimension of the array VL.
              LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise.

    VR

              VR is COMPLEX*16 array, dimension (LDVR,MM)
              On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must
              contain starting vectors for the inverse iteration for the
              right eigenvectors; the starting vector for each eigenvector
              must be in the same column in which the eigenvector will be
              stored.
              On exit, if SIDE = 'R' or 'B', the right eigenvectors
              specified by SELECT will be stored consecutively in the
              columns of VR, in the same order as their eigenvalues.
              If SIDE = 'L', VR is not referenced.

    LDVR

              LDVR is INTEGER
              The leading dimension of the array VR.
              LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise.

    MM

              MM is INTEGER
              The number of columns in the arrays VL and/or VR. MM >= M.

    M

              M is INTEGER
              The number of columns in the arrays VL and/or VR required to
              store the eigenvectors (= the number of .TRUE. elements in
              SELECT).

    WORK

              WORK is COMPLEX*16 array, dimension (N*N)

    RWORK

              RWORK is DOUBLE PRECISION array, dimension (N)

    IFAILL

              IFAILL is INTEGER array, dimension (MM)
              If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left
              eigenvector in the i-th column of VL (corresponding to the
              eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the
              eigenvector converged satisfactorily.
              If SIDE = 'R', IFAILL is not referenced.

    IFAILR

              IFAILR is INTEGER array, dimension (MM)
              If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right
              eigenvector in the i-th column of VR (corresponding to the
              eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the
              eigenvector converged satisfactorily.
              If SIDE = 'L', IFAILR is not referenced.

    INFO

              INFO is INTEGER
              = 0:  successful exit
              < 0:  if INFO = -i, the i-th argument had an illegal value
              > 0:  if INFO = i, i is the number of eigenvectors which
                    failed to converge; see IFAILL and IFAILR for further
                    details.

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

      Each eigenvector is normalized so that the element of largest
      magnitude has magnitude 1; here the magnitude of a complex number
      (x,y) is taken to be |x|+|y|.

Definition at line 242 of file zhsein.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.