CTRSNA  - estimate reciprocal condition numbers for speci­
       fied eigenvalues and/or right eigenvectors  of  a  complex
       upper  triangular matrix T (or of any matrix Q*T*Q**H with
       Q unitary)


SYNOPSIS

       SUBROUTINE CTRSNA( JOB, HOWMNY, SELECT,  N,  T,  LDT,  VL,
                          LDVL,  VR,  LDVR,  S, SEP, MM, M, WORK,
                          LDWORK, RWORK, INFO )

           CHARACTER      HOWMNY, JOB

           INTEGER        INFO, LDT, LDVL, LDVR, LDWORK, M, MM, N

           LOGICAL        SELECT( * )

           REAL           RWORK( * ), S( * ), SEP( * )

           COMPLEX        T( LDT, * ), VL( LDVL, * ), VR( LDVR, *
                          ), WORK( LDWORK, * )


PURPOSE

       CTRSNA estimates reciprocal condition numbers  for  speci­
       fied  eigenvalues  and/or  right eigenvectors of a complex
       upper triangular matrix T (or of any matrix Q*T*Q**H  with
       Q unitary).


ARGUMENTS

       JOB     (input) CHARACTER*1
               Specifies  whether  condition numbers are required
               for eigenvalues (S) or eigenvectors (SEP):
               = 'E': for eigenvalues only (S);
               = 'V': for eigenvectors only (SEP);
               = 'B': for both eigenvalues  and  eigenvectors  (S
               and SEP).

       HOWMNY  (input) CHARACTER*1
               =  'A':  compute  condition numbers for all eigen­
               pairs;
               = 'S':  compute  condition  numbers  for  selected
               eigenpairs specified by the array SELECT.

       SELECT  (input) LOGICAL array, dimension (N)
               If  HOWMNY  = 'S', SELECT specifies the eigenpairs
               for  which  condition  numbers  are  required.  To
               select  condition  numbers for the j-th eigenpair,
               SELECT(j) must be set to .TRUE..  If HOWMNY = 'A',
               SELECT is not referenced.

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

               The upper triangular matrix T.

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

       VL      (input) COMPLEX array, dimension (LDVL,M)
               If JOB = 'E' or 'B', VL must contain  left  eigen­
               vectors  of T (or of any Q*T*Q**H with Q unitary),
               corresponding  to  the  eigenpairs  specified   by
               HOWMNY and SELECT. The eigenvectors must be stored
               in consecutive  columns  of  VL,  as  returned  by
               CHSEIN  or CTREVC.  If JOB = 'V', VL is not refer­
               enced.

       LDVL    (input) INTEGER
               The leading dimension of the array VL.  LDVL >= 1;
               and if JOB = 'E' or 'B', LDVL >= N.

       VR      (input) COMPLEX array, dimension (LDVR,M)
               If  JOB = 'E' or 'B', VR must contain right eigen­
               vectors of T (or of any Q*T*Q**H with Q  unitary),
               corresponding   to  the  eigenpairs  specified  by
               HOWMNY and SELECT. The eigenvectors must be stored
               in  consecutive  columns  of  VR,  as  returned by
               CHSEIN or CTREVC.  If JOB = 'V', VR is not  refer­
               enced.

       LDVR    (input) INTEGER
               The leading dimension of the array VR.  LDVR >= 1;
               and if JOB = 'E' or 'B', LDVR >= N.

       S       (output) REAL array, dimension (MM)
               If JOB = 'E' or 'B', the reciprocal condition num­
               bers  of  the selected eigenvalues, stored in con­
               secutive elements of the array. Thus S(j), SEP(j),
               and  the  j-th columns of VL and VR all correspond
               to the same eigenpair (but not in general the j-th
               eigenpair,  unless  all  eigenpairs are selected).
               If JOB = 'V', S is not referenced.

       SEP     (output) REAL array, dimension (MM)
               If JOB = 'V' or 'B', the estimated reciprocal con­
               dition   numbers  of  the  selected  eigenvectors,
               stored in consecutive elements of the  array.   If
               JOB = 'E', SEP is not referenced.

       MM      (input) INTEGER
               The  number  of elements in the arrays S (if JOB =
               'E' or 'B') and/or SEP (if JOB = 'V' or  'B').  MM
               >= M.

               The  number of elements of the arrays S and/or SEP
               actually used to  store  the  estimated  condition
               numbers.  If HOWMNY = 'A', M is set to N.

       WORK    (workspace) COMPLEX array, dimension (LDWORK,N+1)
               If JOB = 'E', WORK is not referenced.

       LDWORK  (input) INTEGER
               The  leading  dimension of the array WORK.  LDWORK
               >= 1; and if JOB = 'V' or 'B', LDWORK >= N.

       RWORK   (workspace) REAL array, dimension (N)
               If JOB = 'E', RWORK is not referenced.

       INFO    (output) INTEGER
               = 0: successful exit
               < 0: if INFO = -i, the i-th argument had an  ille­
               gal value


FURTHER DETAILS

       The  reciprocal  of  the condition number of an eigenvalue
       lambda is defined as

               S(lambda) = |v'*u| / (norm(u)*norm(v))

       where u and v are the right and  left  eigenvectors  of  T
       corresponding  to  lambda; v' denotes the conjugate trans­
       pose of v, and norm(u) denotes the Euclidean  norm.  These
       reciprocal condition numbers always lie between zero (very
       badly conditioned) and one (very well conditioned). If n =
       1, S(lambda) is defined to be 1.

       An  approximate error bound for a computed eigenvalue W(i)
       is given by

                           EPS * norm(T) / S(i)

       where EPS is the machine precision.

       The reciprocal of the condition number of the right eigen­
       vector  u  corresponding  to lambda is defined as follows.
       Suppose

                   T = ( lambda  c  )
                       (   0    T22 )

       Then the reciprocal condition number is

               SEP( lambda, T22 ) = sigma-min( T22 - lambda*I )

       where sigma-min denotes the smallest  singular  value.  We
       approximate  the smallest singular value by the reciprocal
       of an estimate of the one-norm of the  inverse  of  T22  -


       An  approximate error bound for a computed right eigenvec­
       tor VR(i) is given by

                           EPS * norm(T) / SEP(i)


Man(1) output converted with man2html