MB02CD

Cholesky factorization of a positive definite block Toeplitz matrix

[Specification] [Arguments] [Method] [References] [Comments] [Example]

Purpose

  To compute the Cholesky factor and the generator and/or the
  Cholesky factor of the inverse of a symmetric positive definite
  (s.p.d.) block Toeplitz matrix T, defined by either its first
  block row, or its first block column, depending on the routine
  parameter TYPET. Transformation information is stored.

Specification
      SUBROUTINE MB02CD( JOB, TYPET, K, N, T, LDT, G, LDG, R, LDR, L,
     $                   LDL, CS, LCS, DWORK, LDWORK, INFO )
C     .. Scalar Arguments ..
      CHARACTER         JOB, TYPET
      INTEGER           INFO, K, LCS, LDG, LDL, LDR, LDT, LDWORK, N
C     .. Array Arguments ..
      DOUBLE PRECISION  CS(*), DWORK(*), G(LDG, *), L(LDL,*), R(LDR,*),
     $                  T(LDT,*)

Arguments

Mode Parameters

  JOB     CHARACTER*1
          Specifies the output of the routine, as follows:
          = 'G':  only computes the generator G of the inverse;
          = 'R':  computes the generator G of the inverse and the
                  Cholesky factor R of T, i.e., if TYPET = 'R',
                  then R'*R = T, and if TYPET = 'C', then R*R' = T;
          = 'L':  computes the generator G and the Cholesky factor L
                  of the inverse, i.e., if TYPET = 'R', then
                  L'*L = inv(T), and if TYPET = 'C', then
                  L*L' = inv(T);
          = 'A':  computes the generator G, the Cholesky factor L
                  of the inverse and the Cholesky factor R of T;
          = 'O':  only computes the Cholesky factor R of T.

  TYPET   CHARACTER*1
          Specifies the type of T, as follows:
          = 'R':  T contains the first block row of an s.p.d. block
                  Toeplitz matrix; if demanded, the Cholesky factors
                  R and L are upper and lower triangular,
                  respectively, and G contains the transposed
                  generator of the inverse;
          = 'C':  T contains the first block column of an s.p.d.
                  block Toeplitz matrix; if demanded, the Cholesky
                  factors R and L are lower and upper triangular,
                  respectively, and G contains the generator of the
                  inverse. This choice results in a column oriented
                  algorithm which is usually faster.
          Note:   in the sequel, the notation x / y means that
                  x corresponds to TYPET = 'R' and y corresponds to
                  TYPET = 'C'.

Input/Output Parameters
  K       (input)  INTEGER
          The number of rows / columns in T, which should be equal
          to the blocksize.  K >= 0.

  N       (input)  INTEGER
          The number of blocks in T.  N >= 0.

  T       (input/output)  DOUBLE PRECISION array, dimension
          (LDT,N*K) / (LDT,K)
          On entry, the leading K-by-N*K / N*K-by-K part of this
          array must contain the first block row / column of an
          s.p.d. block Toeplitz matrix.
          On exit, if INFO = 0, then the leading K-by-N*K / N*K-by-K
          part of this array contains, in the first K-by-K block,
          the upper / lower Cholesky factor of T(1:K,1:K), and in
          the remaining part, the Householder transformations
          applied during the process.

  LDT     INTEGER
          The leading dimension of the array T.
          LDT >= MAX(1,K),    if TYPET = 'R';
          LDT >= MAX(1,N*K),  if TYPET = 'C'.

  G       (output)  DOUBLE PRECISION array, dimension
          (LDG,N*K) / (LDG,2*K)
          If INFO = 0 and JOB = 'G', 'R', 'L', or 'A', the leading
          2*K-by-N*K / N*K-by-2*K part of this array contains, in
          the first K-by-K block of the second block row / column,
          the lower right block of L (necessary for updating
          factorizations in SLICOT Library routine MB02DD), and
          in the remaining part, the generator of the inverse of T.
          Actually, to obtain a generator one has to set
              G(K+1:2*K, 1:K) = 0,    if TYPET = 'R';
              G(1:K, K+1:2*K) = 0,    if TYPET = 'C'.

  LDG     INTEGER
          The leading dimension of the array G.
          LDG >= MAX(1,2*K),  if TYPET = 'R' and
                                 JOB = 'G', 'R', 'L', or 'A';
          LDG >= MAX(1,N*K),  if TYPET = 'C' and
                                 JOB = 'G', 'R', 'L', or 'A';
          LDG >= 1,           if JOB = 'O'.

  R       (output)  DOUBLE PRECISION array, dimension (LDR,N*K)
          If INFO = 0 and JOB = 'R', 'A', or 'O', then the leading
          N*K-by-N*K part of this array contains the upper / lower
          Cholesky factor of T.
          The elements in the strictly lower / upper triangular part
          are not referenced.

  LDR     INTEGER
          The leading dimension of the array R.
          LDR >= MAX(1,N*K),  if JOB = 'R', 'A', or 'O';
          LDR >= 1,           if JOB = 'G', or 'L'.

  L       (output)  DOUBLE PRECISION array, dimension (LDL,N*K)
          If INFO = 0 and JOB = 'L', or 'A', then the leading
          N*K-by-N*K part of this array contains the lower / upper
          Cholesky factor of the inverse of T.
          The elements in the strictly upper / lower triangular part
          are not referenced.

  LDL     INTEGER
          The leading dimension of the array L.
          LDL >= MAX(1,N*K),  if JOB = 'L', or 'A';
          LDL >= 1,           if JOB = 'G', 'R', or 'O'.

  CS      (output)  DOUBLE PRECISION array, dimension (LCS)
          If INFO = 0, then the leading 3*(N-1)*K part of this
          array contains information about the hyperbolic rotations
          and Householder transformations applied during the
          process. This information is needed for updating the
          factorizations in SLICOT Library routine MB02DD.

  LCS     INTEGER
          The length of the array CS.  LCS >= 3*(N-1)*K.

Workspace
  DWORK   DOUBLE PRECISION array, dimension (LDWORK)
          On exit, if INFO = 0,  DWORK(1)  returns the optimal
          value of LDWORK.
          On exit, if  INFO = -16,  DWORK(1)  returns the minimum
          value of LDWORK.

  LDWORK  INTEGER
          The length of the array DWORK.
          LDWORK >= MAX(1,(N-1)*K).
          For optimum performance LDWORK should be larger.

Error Indicator
  INFO    INTEGER
          = 0:  successful exit;
          < 0:  if INFO = -i, the i-th argument had an illegal
                value;
          = 1:  the reduction algorithm failed. The Toeplitz matrix
                associated with T is not (numerically) positive
                definite.

Method
  Householder transformations and modified hyperbolic rotations
  are used in the Schur algorithm [1], [2].

References
  [1] Kailath, T. and Sayed, A.
      Fast Reliable Algorithms for Matrices with Structure.
      SIAM Publications, Philadelphia, 1999.

  [2] Kressner, D. and Van Dooren, P.
      Factorizations and linear system solvers for matrices with
      Toeplitz structure.
      SLICOT Working Note 2000-2, 2000.

Numerical Aspects
  The implemented method is numerically stable.
                            3 2
  The algorithm requires 0(K N ) floating point operations.

Further Comments
  None
Example

Program Text

*     MB02CD EXAMPLE PROGRAM TEXT
*     RELEASE 5.0, SLICOT COPYRIGHT 2000.
*
*     .. Parameters ..
      DOUBLE PRECISION ZERO
      PARAMETER        ( ZERO = 0.0D0 )
      INTEGER          NIN, NOUT
      PARAMETER        ( NIN = 5, NOUT = 6 )
      INTEGER          KMAX, NMAX
      PARAMETER        ( KMAX = 20, NMAX = 20 ) 
      INTEGER          LCS, LDG, LDL, LDR, LDT, LDWORK
      PARAMETER        ( LDG = 2*KMAX, LDL = NMAX*KMAX, LDR = NMAX*KMAX,
     $                   LDT = KMAX, LDWORK = ( NMAX - 1 )*KMAX )
      PARAMETER        ( LCS = 3*LDWORK ) 
*     .. Local Scalars .. 
      INTEGER          I, INFO, J, K, M, N
      CHARACTER        JOB, TYPET
*     .. Local Arrays .. (Dimensioned for TYPET = 'R'.)
      DOUBLE PRECISION CS(LCS), DWORK(LDWORK), G(LDG, NMAX*KMAX),
     $                 L(LDL, NMAX*KMAX), R(LDR, NMAX*KMAX),
     $                 T(LDT, NMAX*KMAX)
*     .. External Functions ..
      LOGICAL          LSAME 
      EXTERNAL         LSAME
*     .. External Subroutines ..
      EXTERNAL         DLASET, MB02CD
*    
*     .. Executable Statements ..
      WRITE ( NOUT, FMT = 99999 )
*     Skip the heading in the data file and read the data.
      READ ( NIN, FMT = '()' )
      READ ( NIN, FMT = * ) N, K, JOB
      TYPET = 'R'
      M = N*K
      IF( N.LE.0 .OR. N.GT.NMAX ) THEN
         WRITE ( NOUT, FMT = 99993 ) N
      ELSE
         IF( K.LE.0 .OR. K.GT.KMAX ) THEN
            WRITE ( NOUT, FMT = 99992 ) K
         ELSE
            READ ( NIN, FMT = * ) ( ( T(I,J), J = 1,M ), I = 1,K )
*           Compute the Cholesky factor(s) and/or the generator.
            CALL MB02CD( JOB, TYPET, K, N, T, LDT, G, LDG, R, LDR, L,
     $                   LDL, CS, LCS, DWORK, LDWORK, INFO )
            IF ( INFO.NE.0 ) THEN
               WRITE ( NOUT, FMT = 99998 ) INFO
            ELSE
               IF ( LSAME( JOB, 'G' ) .OR. LSAME( JOB, 'A' ) .OR.
     $              LSAME( JOB, 'L' ) .OR. LSAME( JOB, 'R' ) ) THEN
                  WRITE ( NOUT, FMT = 99997 )
                  CALL DLASET( 'Full', K, K, ZERO, ZERO, G(K+1,1), LDG )
                  DO 10  I = 1, 2*K
                     WRITE ( NOUT, FMT = 99994 ) ( G(I,J), J = 1, M )
   10             CONTINUE
               END IF
               IF ( LSAME( JOB, 'L' ) .OR. LSAME( JOB, 'A' ) ) THEN
                  WRITE ( NOUT, FMT = 99996 )
                  DO 20  I = 1, M
                     WRITE ( NOUT, FMT = 99994 ) ( L(I,J), J = 1, M )
   20             CONTINUE
               END IF
               IF ( LSAME( JOB, 'R' ) .OR. LSAME( JOB, 'A' )
     $                                .OR. LSAME( JOB, 'O' ) ) THEN
                  WRITE ( NOUT, FMT = 99995 )
                  DO 30  I = 1, M
                     WRITE ( NOUT, FMT = 99994 ) ( R(I,J), J = 1, M )
   30             CONTINUE      
               END IF
            END IF
         END IF
      END IF
      STOP
*
99999 FORMAT (' MB02CD EXAMPLE PROGRAM RESULTS',/1X)
99998 FORMAT (' INFO on exit from MB02CD = ',I2)
99997 FORMAT (' The generator of the inverse of block Toeplitz matrix',
     $        ' is ')        
99996 FORMAT (/' The lower Cholesky factor of the inverse is ')
99995 FORMAT (/' The upper Cholesky factor of block Toeplitz matrix is '
     $       )
99994 FORMAT (20(1X,F8.4))
99993 FORMAT (/' N is out of range.',/' N = ',I5)
99992 FORMAT (/' K is out of range.',/' K = ',I5)
      END
Program Data
MB02CD EXAMPLE PROGRAM DATA
  3    2     A
  3.0000    1.0000    0.1000    0.1000    0.2000    0.0500
  1.0000    4.0000    0.4000    0.1000    0.0400    0.2000
Program Results
 MB02CD EXAMPLE PROGRAM RESULTS

 The generator of the inverse of block Toeplitz matrix is 
  -0.2355   0.5231  -0.0642   0.0077   0.0187  -0.0265
  -0.5568  -0.0568   0.0229   0.0060   0.0363   0.0000
   0.0000   0.0000  -0.0387   0.0052   0.0003  -0.0575
   0.0000   0.0000   0.0119  -0.0265  -0.0110   0.0076

 The lower Cholesky factor of the inverse is 
   0.5774   0.0000   0.0000   0.0000   0.0000   0.0000
  -0.1741   0.5222   0.0000   0.0000   0.0000   0.0000
   0.0000  -0.0581   0.5812   0.0000   0.0000   0.0000
  -0.0142   0.0080  -0.1747   0.5224   0.0000   0.0000
  -0.0387   0.0052   0.0003  -0.0575   0.5825   0.0000
   0.0119  -0.0265  -0.0110   0.0076  -0.1754   0.5231

 The upper Cholesky factor of block Toeplitz matrix is 
   1.7321   0.5774   0.0577   0.0577   0.1155   0.0289
   0.0000   1.9149   0.1915   0.0348  -0.0139   0.0957
   0.0000   0.0000   1.7205   0.5754   0.0558   0.0465
   0.0000   0.0000   0.0000   1.9142   0.1890   0.0357
   0.0000   0.0000   0.0000   0.0000   1.7169   0.5759
   0.0000   0.0000   0.0000   0.0000   0.0000   1.9118

Return to index