TESTING/MATGEN/zlatm5.f(3)                            Library Functions Manual

NAME
       TESTING/MATGEN/zlatm5.f

SYNOPSIS
   Functions/Subroutines
       subroutine zlatm5 (prtype, m, n, a, lda, b, ldb, c, ldc, d, ldd, e,
           lde, f, ldf, r, ldr, l, ldl, alpha, qblcka, qblckb)
           ZLATM5

Function/Subroutine Documentation
   subroutine zlatm5 (integer prtype, integer m, integer n, complex*16,
       dimension( lda, * ) a, integer lda, complex*16, dimension( ldb, * ) b,
       integer ldb, complex*16, dimension( ldc, * ) c, integer ldc,
       complex*16, dimension( ldd, * ) d, integer ldd, complex*16, dimension(
       lde, * ) e, integer lde, complex*16, dimension( ldf, * ) f, integer
       ldf, complex*16, dimension( ldr, * ) r, integer ldr, complex*16,
       dimension( ldl, * ) l, integer ldl, double precision alpha, integer
       qblcka, integer qblckb)
       ZLATM5

       Purpose:


           !>
           !> ZLATM5 generates matrices involved in the Generalized Sylvester
           !> equation:
           !>
           !>     A * R - L * B = C
           !>     D * R - L * E = F
           !>
           !> They also satisfy (the diagonalization condition)
           !>
           !>  [ I -L ] ( [ A  -C ], [ D -F ] ) [ I  R ] = ( [ A    ], [ D    ] )
           !>  [    I ] ( [     B ]  [    E ] ) [    I ]   ( [    B ]  [    E ] )
           !>
           !>

       Parameters
           PRTYPE

           !>          PRTYPE is INTEGER
           !>           to a certain type of the matrices to generate
           !>          (see further details).
           !>

           M

           !>          M is INTEGER
           !>          Specifies the order of A and D and the number of rows in
           !>          C, F,  R and L.
           !>

           N

           !>          N is INTEGER
           !>          Specifies the order of B and E and the number of columns in
           !>          C, F, R and L.
           !>

           A

           !>          A is COMPLEX*16 array, dimension (LDA, M).
           !>          On exit A M-by-M is initialized according to PRTYPE.
           !>

           LDA

           !>          LDA is INTEGER
           !>          The leading dimension of A.
           !>

           B

           !>          B is COMPLEX*16 array, dimension (LDB, N).
           !>          On exit B N-by-N is initialized according to PRTYPE.
           !>

           LDB

           !>          LDB is INTEGER
           !>          The leading dimension of B.
           !>

           C

           !>          C is COMPLEX*16 array, dimension (LDC, N).
           !>          On exit C M-by-N is initialized according to PRTYPE.
           !>

           LDC

           !>          LDC is INTEGER
           !>          The leading dimension of C.
           !>

           D

           !>          D is COMPLEX*16 array, dimension (LDD, M).
           !>          On exit D M-by-M is initialized according to PRTYPE.
           !>

           LDD

           !>          LDD is INTEGER
           !>          The leading dimension of D.
           !>

           E

           !>          E is COMPLEX*16 array, dimension (LDE, N).
           !>          On exit E N-by-N is initialized according to PRTYPE.
           !>

           LDE

           !>          LDE is INTEGER
           !>          The leading dimension of E.
           !>

           F

           !>          F is COMPLEX*16 array, dimension (LDF, N).
           !>          On exit F M-by-N is initialized according to PRTYPE.
           !>

           LDF

           !>          LDF is INTEGER
           !>          The leading dimension of F.
           !>

           R

           !>          R is COMPLEX*16 array, dimension (LDR, N).
           !>          On exit R M-by-N is initialized according to PRTYPE.
           !>

           LDR

           !>          LDR is INTEGER
           !>          The leading dimension of R.
           !>

           L

           !>          L is COMPLEX*16 array, dimension (LDL, N).
           !>          On exit L M-by-N is initialized according to PRTYPE.
           !>

           LDL

           !>          LDL is INTEGER
           !>          The leading dimension of L.
           !>

           ALPHA

           !>          ALPHA is DOUBLE PRECISION
           !>          Parameter used in generating PRTYPE = 1 and 5 matrices.
           !>

           QBLCKA

           !>          QBLCKA is INTEGER
           !>          When PRTYPE = 3, specifies the distance between 2-by-2
           !>          blocks on the diagonal in A. Otherwise, QBLCKA is not
           !>          referenced. QBLCKA > 1.
           !>

           QBLCKB

           !>          QBLCKB is INTEGER
           !>          When PRTYPE = 3, specifies the distance between 2-by-2
           !>          blocks on the diagonal in B. Otherwise, QBLCKB is not
           !>          referenced. QBLCKB > 1.
           !>

       Author
           Univ. of Tennessee


           Univ. of California Berkeley


           Univ. of Colorado Denver


           NAG Ltd.

       Further Details:


           !>
           !>  PRTYPE = 1: A and B are Jordan blocks, D and E are identity matrices
           !>
           !>             A : if (i == j) then A(i, j) = 1.0
           !>                 if (j == i + 1) then A(i, j) = -1.0
           !>                 else A(i, j) = 0.0,            i, j = 1...M
           !>
           !>             B : if (i == j) then B(i, j) = 1.0 - ALPHA
           !>                 if (j == i + 1) then B(i, j) = 1.0
           !>                 else B(i, j) = 0.0,            i, j = 1...N
           !>
           !>             D : if (i == j) then D(i, j) = 1.0
           !>                 else D(i, j) = 0.0,            i, j = 1...M
           !>
           !>             E : if (i == j) then E(i, j) = 1.0
           !>                 else E(i, j) = 0.0,            i, j = 1...N
           !>
           !>             L =  R are chosen from [-10...10],
           !>                  which specifies the right hand sides (C, F).
           !>
           !>  PRTYPE = 2 or 3: Triangular and/or quasi- triangular.
           !>
           !>             A : if (i <= j) then A(i, j) = [-1...1]
           !>                 else A(i, j) = 0.0,             i, j = 1...M
           !>
           !>                 if (PRTYPE = 3) then
           !>                    A(k + 1, k + 1) = A(k, k)
           !>                    A(k + 1, k) = [-1...1]
           !>                    sign(A(k, k + 1) = -(sin(A(k + 1, k))
           !>                        k = 1, M - 1, QBLCKA
           !>
           !>             B : if (i <= j) then B(i, j) = [-1...1]
           !>                 else B(i, j) = 0.0,            i, j = 1...N
           !>
           !>                 if (PRTYPE = 3) then
           !>                    B(k + 1, k + 1) = B(k, k)
           !>                    B(k + 1, k) = [-1...1]
           !>                    sign(B(k, k + 1) = -(sign(B(k + 1, k))
           !>                        k = 1, N - 1, QBLCKB
           !>
           !>             D : if (i <= j) then D(i, j) = [-1...1].
           !>                 else D(i, j) = 0.0,            i, j = 1...M
           !>
           !>
           !>             E : if (i <= j) then D(i, j) = [-1...1]
           !>                 else E(i, j) = 0.0,            i, j = 1...N
           !>
           !>                 L, R are chosen from [-10...10],
           !>                 which specifies the right hand sides (C, F).
           !>
           !>  PRTYPE = 4 Full
           !>             A(i, j) = [-10...10]
           !>             D(i, j) = [-1...1]    i,j = 1...M
           !>             B(i, j) = [-10...10]
           !>             E(i, j) = [-1...1]    i,j = 1...N
           !>             R(i, j) = [-10...10]
           !>             L(i, j) = [-1...1]    i = 1..M ,j = 1...N
           !>
           !>             L, R specifies the right hand sides (C, F).
           !>
           !>  PRTYPE = 5 special case common and/or close eigs.
           !>

       Definition at line 265 of file zlatm5.f.

Author
       Generated automatically by Doxygen for LAPACK from the source code.

LAPACK                          Version 3.12.0      TESTING/MATGEN/zlatm5.f(3)