Contents


NAME

     zhesv - compute the solution to a complex system  of  linear
     equations  A * X = B,

SYNOPSIS

     SUBROUTINE ZHESV(UPLO, N, NRHS, A, LDA, IPIVOT, B, LDB, WORK, LDWORK,
           INFO)

     CHARACTER * 1 UPLO
     DOUBLE COMPLEX A(LDA,*), B(LDB,*), WORK(*)
     INTEGER N, NRHS, LDA, LDB, LDWORK, INFO
     INTEGER IPIVOT(*)

     SUBROUTINE ZHESV_64(UPLO, N, NRHS, A, LDA, IPIVOT, B, LDB, WORK,
           LDWORK, INFO)

     CHARACTER * 1 UPLO
     DOUBLE COMPLEX A(LDA,*), B(LDB,*), WORK(*)
     INTEGER*8 N, NRHS, LDA, LDB, LDWORK, INFO
     INTEGER*8 IPIVOT(*)

  F95 INTERFACE
     SUBROUTINE HESV(UPLO, [N], [NRHS], A, [LDA], IPIVOT, B, [LDB], [WORK],
            [LDWORK], [INFO])

     CHARACTER(LEN=1) :: UPLO
     COMPLEX(8), DIMENSION(:) :: WORK
     COMPLEX(8), DIMENSION(:,:) :: A, B
     INTEGER :: N, NRHS, LDA, LDB, LDWORK, INFO
     INTEGER, DIMENSION(:) :: IPIVOT

     SUBROUTINE HESV_64(UPLO, [N], [NRHS], A, [LDA], IPIVOT, B, [LDB],
            [WORK], [LDWORK], [INFO])

     CHARACTER(LEN=1) :: UPLO
     COMPLEX(8), DIMENSION(:) :: WORK
     COMPLEX(8), DIMENSION(:,:) :: A, B
     INTEGER(8) :: N, NRHS, LDA, LDB, LDWORK, INFO
     INTEGER(8), DIMENSION(:) :: IPIVOT

  C INTERFACE
     #include <sunperf.h>

     void zhesv(char uplo, int n, int nrhs, doublecomplex *a, int
               lda,  int  *ipivot, doublecomplex *b, int ldb, int
               *info);
     void zhesv_64(char uplo, long n,  long  nrhs,  doublecomplex
               *a, long lda, long *ipivot, doublecomplex *b, long
               ldb, long *info);

PURPOSE

     zhesv computes the solution to a complex  system  of  linear
     equations
        A * X = B, where A is an N-by-N Hermitian  matrix  and  X
     and B are N-by-NRHS matrices.

     The diagonal pivoting method is used to factor A as
        A = U * D * U**H,  if UPLO = 'U', or
        A = L * D * L**H,  if UPLO = 'L',
     where U (or L) is a product of permutation  and  unit  upper
     (lower)  triangular  matrices,  and D is Hermitian and block
     diagonal with 1-by-1 and 2-by-2 diagonal blocks.   The  fac-
     tored  form  of  A is then used to solve the system of equa-
     tions A * X = B.

ARGUMENTS

     UPLO (input)
               = 'U':  Upper triangle of A is stored;
               = 'L':  Lower triangle of A is stored.

     N (input) The number of linear equations, i.e., the order of
               the matrix A.  N >= 0.

     NRHS (input)
               The number of right hand sides, i.e.,  the  number
               of columns of the matrix B.  NRHS >= 0.

     A (input/output)
               On entry, the Hermitian matrix A.  If UPLO =  'U',
               the leading N-by-N upper triangular part of A con-
               tains the upper triangular part of the  matrix  A,
               and the strictly lower triangular part of A is not
               referenced.  If UPLO =  'L',  the  leading  N-by-N
               lower triangular part of A contains the lower tri-
               angular part of the matrix  A,  and  the  strictly
               upper triangular part of A is not referenced.

               On exit, if INFO = 0, the block diagonal matrix  D
               and the multipliers used to obtain the factor U or
               L from the factorization  A  =  U*D*U**H  or  A  =
               L*D*L**H as computed by CHETRF.
     LDA (input)
               The leading dimension of  the  array  A.   LDA  >=
               max(1,N).

     IPIVOT (output)
               Details of the interchanges and the  block  struc-
               ture  of D, as determined by CHETRF.  If IPIVOT(k)
               > 0, then rows and columns k  and  IPIVOT(k)  were
               interchanged,  and  D(k,k)  is  a  1-by-1 diagonal
               block.  If UPLO = 'U' and IPIVOT(k) =  IPIVOT(k-1)
               < 0, then rows and columns k-1 and -IPIVOT(k) were
               interchanged and D(k-1:k,k-1:k) is a 2-by-2 diago-
               nal   block.   If  UPLO  =  'L'  and  IPIVOT(k)  =
               IPIVOT(k+1) < 0, then rows  and  columns  k+1  and
               -IPIVOT(k) were interchanged and D(k:k+1,k:k+1) is
               a 2-by-2 diagonal block.

     B (input/output)
               On entry, the N-by-NRHS right hand side matrix  B.
               On  exit,  if  INFO  =  0,  the N-by-NRHS solution
               matrix X.

     LDB (input)
               The leading dimension of  the  array  B.   LDB  >=
               max(1,N).

     WORK (workspace)
               On exit, if INFO = 0, WORK(1) returns the  optimal
               LDWORK.

     LDWORK (input)
               The length of WORK.  LDWORK >=  1,  and  for  best
               performance  LDWORK  >=  N*NB,  where  NB  is  the
               optimal blocksize for CHETRF.

               If LDWORK = -1, then a workspace query is assumed;
               the  routine  only  calculates the optimal size of
               the WORK array, returns this value  as  the  first
               entry  of  the  WORK  array,  and no error message
               related to LDWORK is issued by XERBLA.

     INFO (output)
               = 0: successful exit
               < 0: if INFO = -i, the i-th argument had an  ille-
               gal value
               > 0: if INFO = i, D(i,i)  is  exactly  zero.   The
               factorization  has  been  completed, but the block
               diagonal matrix D  is  exactly  singular,  so  the
               solution could not be computed.