TESTING/MATGEN/dlatm5.f(3)

NAME
TESTING/MATGEN/dlatm5.f

SYNOPSIS

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

Function/Subroutine Documentation

  subroutine dlatm5 (integer prtype, integer m, integer n, double precision, dimension( lda, * ) a, integer lda, double precision, dimension( ldb, * ) b, integer ldb, double precision, dimension( ldc, * ) c, integer ldc, double precision, dimension( ldd, * ) d, integer ldd, double precision, dimension( lde, * ) e, integer lde, double precision, dimension( ldf, * ) f, integer ldf, double precision, dimension( ldr, * ) r, integer ldr, double precision, dimension( ldl, * ) l, integer ldl, double precision alpha, integer qblcka, integer qblckb)

DLATM5

Purpose:

    !>
    !> DLATM5 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 dlatm5.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.