Contents


NAME

     zgbtrf - compute an LU factorization  of  a  complex  m-by-n
     band matrix A using partial pivoting with row interchanges

SYNOPSIS

     SUBROUTINE ZGBTRF(M, N, KL, KU, AB, LDAB, IPIVOT, INFO)

     DOUBLE COMPLEX AB(LDAB,N)
     INTEGER M, N, KL, KU, LDAB, INFO
     INTEGER IPIVOT(MIN(M,N))

     SUBROUTINE ZGBTRF_64(M, N, KL, KU, AB, LDAB, IPIVOT, INFO)

     DOUBLE COMPLEX AB(LDAB,N)
     INTEGER*8 M, N, KL, KU, LDAB, INFO
     INTEGER*8 IPIVOT(MIN(M,N))

  F95 INTERFACE
     SUBROUTINE GBTRF(M, [N], KL, KU, AB, [LDAB], IPIVOT, [INFO])

     COMPLEX(8), DIMENSION(:,:) :: AB
     INTEGER :: M, N, KL, KU, LDAB, INFO
     INTEGER, DIMENSION(:) :: IPIVOT

     SUBROUTINE GBTRF_64(M, [N], KL, KU, AB, [LDAB], IPIVOT, [INFO])

     COMPLEX(8), DIMENSION(:,:) :: AB
     INTEGER(8) :: M, N, KL, KU, LDAB, INFO
     INTEGER(8), DIMENSION(:) :: IPIVOT

  C INTERFACE
     #include <sunperf.h>

     void zgbtrf(int m, int n, int kl, int ku, doublecomplex *ab,
               int ldab, int *ipivot, int *info);

     void zgbtrf_64(long m, long n, long kl, long ku,  doublecom-
               plex *ab, long ldab, long *ipivot, long *info);

PURPOSE

     zgbtrf computes an LU factorization of a complex m-by-n band
     matrix A using partial pivoting with row interchanges.

     This is the blocked version of the algorithm, calling  Level
     3 BLAS.

ARGUMENTS

     M (input) Integer
               The number of rows of the matrix A.  M >= 0.

     N (input) Integer
               The number of columns of the matrix A.  N >= 0.

     KL (input) Integer
               The number of subdiagonals within the band  of  A.
               KL >= 0.

     KU (input) Integer
               The number of superdiagonals within the band of A.
               KU >= 0.

     AB (input/output) Double complex array of dimension (LDAB,N).
               On  entry,  the  matrix A in band storage, in rows
               KL+1 to 2*KL+KU+1; rows 1 to KL of the array  need
               not be set.  The j-th column of A is stored in the
               j-th  column  of  the   array   AB   as   follows:
               AB(KL+KU+1+I-J,J)    =    A(I,J)    for   MAX(1,J-
               KU)<=I<=MIN(M,J+KL)

               On exit, details of the factorization: U is stored
               as  an  upper  triangular  band  matrix with KL+KU
               superdiagonals in rows 1 to KL+KU+1, and the  mul-
               tipliers  used during the factorization are stored
               in rows  KL+KU+2  to  2*KL+KU+1.   See  below  for
               further details.

     LDAB (input) Integer
               The leading dimension of  the  array  A.   LDA  >=
               2*KL+KU+1.

     IPIVOT (output) Integer array of dimension MIN(M,N)
               The pivot indices; for 1 <= I <= min(M,N),  row  I
               of the matrix was interchanged with row IPIVOT(I).

     INFO (output) Integer
               = 0: successful exit
               < 0: if INFO = -I, the I-th argument had an  ille-
               gal value
               > 0: if INFO = +I, U(I,I)  is  exactly  zero.  The
               factorization has been completed, but the factor U
               is exactly singular, and  division  by  zero  will
               occur  if  it  is  used to solve a system of equa-
               tions.

FURTHER DETAILS

     The band storage scheme  is  illustrated  by  the  following
     example, when M = N = 6, KL = 2, KU = 1:

     On entry:                       On exit:

         *    *    *    +    +    +       *    *    *   u14   u25
     u36
         *    *    +    +    +    +       *    *   u13  u24   u35
     u46
         *   a12  a23  a34  a45  a56      *   u12  u23  u34   u45
     u56
        a11  a22  a33  a44  a55  a66     u11  u22  u33  u44   u55
     u66
        a21  a32  a43  a54  a65   *      m21  m32  m43  m54   m65
     *
        a31  a42  a53  a64   *    *      m31  m42  m53   m64    *
     *

     Array elements marked * are not used by  the  routine;  ele-
     ments marked + need not be set on entry, but are required by
     the routine to  store  elements  of  U  because  of  fill-in
     resulting from the row interchanges.