zggbak (3p)

Name

zggbak - form the right or left eigenvectors of a complex generalized eigenvalue problem A*x = lambda*B*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by ZGGBAL

Synopsis

SUBROUTINE ZGGBAK(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V, LDV,
INFO)

CHARACTER*1 JOB, SIDE
DOUBLE COMPLEX V(LDV,*)
INTEGER N, ILO, IHI, M, LDV, INFO
DOUBLE PRECISION LSCALE(*), RSCALE(*)

SUBROUTINE ZGGBAK_64(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V,
LDV, INFO)

CHARACTER*1 JOB, SIDE
DOUBLE COMPLEX V(LDV,*)
INTEGER*8 N, ILO, IHI, M, LDV, INFO
DOUBLE PRECISION LSCALE(*), RSCALE(*)




F95 INTERFACE
SUBROUTINE GGBAK(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V,
LDV, INFO)

CHARACTER(LEN=1) :: JOB, SIDE
COMPLEX(8), DIMENSION(:,:) :: V
INTEGER :: N, ILO, IHI, M, LDV, INFO
REAL(8), DIMENSION(:) :: LSCALE, RSCALE

SUBROUTINE GGBAK_64(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V,
LDV, INFO)

CHARACTER(LEN=1) :: JOB, SIDE
COMPLEX(8), DIMENSION(:,:) :: V
INTEGER(8) :: N, ILO, IHI, M, LDV, INFO
REAL(8), DIMENSION(:) :: LSCALE, RSCALE




C INTERFACE
#include <sunperf.h>

void zggbak(char job, char side,  int  n,  int  ilo,  int  ihi,  double
*lscale,  double  *rscale,  int m, doublecomplex *v, int ldv,
int *info);

void zggbak_64(char job, char side, long n, long ilo, long ihi,  double
*lscale,  double *rscale, long m, doublecomplex *v, long ldv,
long *info);

Description

Oracle Solaris Studio Performance Library                           zggbak(3P)



NAME
       zggbak  -  form the right or left eigenvectors of a complex generalized
       eigenvalue problem A*x = lambda*B*x, by backward transformation on  the
       computed eigenvectors of the balanced pair of matrices output by ZGGBAL


SYNOPSIS
       SUBROUTINE ZGGBAK(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V, LDV,
             INFO)

       CHARACTER*1 JOB, SIDE
       DOUBLE COMPLEX V(LDV,*)
       INTEGER N, ILO, IHI, M, LDV, INFO
       DOUBLE PRECISION LSCALE(*), RSCALE(*)

       SUBROUTINE ZGGBAK_64(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V,
             LDV, INFO)

       CHARACTER*1 JOB, SIDE
       DOUBLE COMPLEX V(LDV,*)
       INTEGER*8 N, ILO, IHI, M, LDV, INFO
       DOUBLE PRECISION LSCALE(*), RSCALE(*)




   F95 INTERFACE
       SUBROUTINE GGBAK(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V,
              LDV, INFO)

       CHARACTER(LEN=1) :: JOB, SIDE
       COMPLEX(8), DIMENSION(:,:) :: V
       INTEGER :: N, ILO, IHI, M, LDV, INFO
       REAL(8), DIMENSION(:) :: LSCALE, RSCALE

       SUBROUTINE GGBAK_64(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V,
              LDV, INFO)

       CHARACTER(LEN=1) :: JOB, SIDE
       COMPLEX(8), DIMENSION(:,:) :: V
       INTEGER(8) :: N, ILO, IHI, M, LDV, INFO
       REAL(8), DIMENSION(:) :: LSCALE, RSCALE




   C INTERFACE
       #include <sunperf.h>

       void zggbak(char job, char side,  int  n,  int  ilo,  int  ihi,  double
                 *lscale,  double  *rscale,  int m, doublecomplex *v, int ldv,
                 int *info);

       void zggbak_64(char job, char side, long n, long ilo, long ihi,  double
                 *lscale,  double *rscale, long m, doublecomplex *v, long ldv,
                 long *info);



PURPOSE
       zggbak forms the right or left eigenvectors of  a  complex  generalized
       eigenvalue  problem A*x = lambda*B*x, by backward transformation on the
       computed eigenvectors of the balanced pair of matrices output  by  ZGG-
       BAL.


ARGUMENTS
       JOB (input)
                 Specifies the type of backward transformation required:
                 = 'N':  do nothing, return immediately;
                 = 'P':  do backward transformation for permutation only;
                 = 'S':  do backward transformation for scaling only;
                 =  'B':  do backward transformations for both permutation and
                 scaling.  JOB must be the same as the argument  JOB  supplied
                 to ZGGBAL.


       SIDE (input)
                 = 'R':  V contains right eigenvectors;
                 = 'L':  V contains left eigenvectors.


       N (input) The number of rows of the matrix V.  N >= 0.


       ILO (input)
                 The  integers  ILO and IHI determined by ZGGBAL.  1 <= ILO <=
                 IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.


       IHI (input)
                 The integers ILO and IHI determined by ZGGBAL.  1 <=  ILO  <=
                 IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.


       LSCALE (input)
                 Details of the permutations and/or scaling factors applied to
                 the left side of A and B, as returned by ZGGBAL.


       RSCALE (input)
                 Details of the permutations and/or scaling factors applied to
                 the right side of A and B, as returned by ZGGBAL.


       M (input) The number of columns of the matrix V.  M >= 0.


       V (input/output)
                 On  entry,  the  matrix  of  right or left eigenvectors to be
                 transformed, as returned by ZTGEVC.  On exit, V is  overwrit-
                 ten by the transformed eigenvectors.


       LDV (input)
                 The leading dimension of the matrix V. LDV >= max(1,N).


       INFO (output)
                 = 0:  successful exit.
                 < 0:  if INFO = -i, the i-th argument had an illegal value.

FURTHER DETAILS
       See R.C. Ward, Balancing the generalized eigenvalue problem,
                      SIAM J. Sci. Stat. Comp. 2 (1981), 141-152.




                                  7 Nov 2015                        zggbak(3P)