Annotation of rpl/lapack/lapack/zlahef_aa.f, revision 1.6

1.1       bertrand    1: *> \brief \b ZLAHEF_AA
                      2: *
                      3: *  =========== DOCUMENTATION ===========
                      4: *
                      5: * Online html documentation available at
                      6: *            http://www.netlib.org/lapack/explore-html/
                      7: *
                      8: *> \htmlonly
                      9: *> Download ZLAHEF_AA + dependencies
                     10: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zlahef_aa.f">
                     11: *> [TGZ]</a>
                     12: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zlahef_aa.f">
                     13: *> [ZIP]</a>
                     14: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlahef_aa.f">
                     15: *> [TXT]</a>
                     16: *> \endhtmlonly
                     17: *
                     18: *  Definition:
                     19: *  ===========
                     20: *
                     21: *       SUBROUTINE ZLAHEF_AA( UPLO, J1, M, NB, A, LDA, IPIV,
1.3       bertrand   22: *                             H, LDH, WORK )
1.1       bertrand   23: *
                     24: *       .. Scalar Arguments ..
                     25: *       CHARACTER    UPLO
1.3       bertrand   26: *       INTEGER      J1, M, NB, LDA, LDH
1.1       bertrand   27: *       ..
                     28: *       .. Array Arguments ..
                     29: *       INTEGER      IPIV( * )
                     30: *       COMPLEX*16   A( LDA, * ), H( LDH, * ), WORK( * )
                     31: *       ..
                     32: *
                     33: *
                     34: *> \par Purpose:
                     35: *  =============
                     36: *>
                     37: *> \verbatim
                     38: *>
                     39: *> DLAHEF_AA factorizes a panel of a complex hermitian matrix A using
                     40: *> the Aasen's algorithm. The panel consists of a set of NB rows of A
                     41: *> when UPLO is U, or a set of NB columns when UPLO is L.
                     42: *>
                     43: *> In order to factorize the panel, the Aasen's algorithm requires the
                     44: *> last row, or column, of the previous panel. The first row, or column,
                     45: *> of A is set to be the first row, or column, of an identity matrix,
                     46: *> which is used to factorize the first panel.
                     47: *>
                     48: *> The resulting J-th row of U, or J-th column of L, is stored in the
                     49: *> (J-1)-th row, or column, of A (without the unit diagonals), while
                     50: *> the diagonal and subdiagonal of A are overwritten by those of T.
                     51: *>
                     52: *> \endverbatim
                     53: *
                     54: *  Arguments:
                     55: *  ==========
                     56: *
                     57: *> \param[in] UPLO
                     58: *> \verbatim
                     59: *>          UPLO is CHARACTER*1
                     60: *>          = 'U':  Upper triangle of A is stored;
                     61: *>          = 'L':  Lower triangle of A is stored.
                     62: *> \endverbatim
                     63: *>
                     64: *> \param[in] J1
                     65: *> \verbatim
                     66: *>          J1 is INTEGER
                     67: *>          The location of the first row, or column, of the panel
                     68: *>          within the submatrix of A, passed to this routine, e.g.,
                     69: *>          when called by ZHETRF_AA, for the first panel, J1 is 1,
                     70: *>          while for the remaining panels, J1 is 2.
                     71: *> \endverbatim
                     72: *>
                     73: *> \param[in] M
                     74: *> \verbatim
                     75: *>          M is INTEGER
                     76: *>          The dimension of the submatrix. M >= 0.
                     77: *> \endverbatim
                     78: *>
                     79: *> \param[in] NB
                     80: *> \verbatim
                     81: *>          NB is INTEGER
                     82: *>          The dimension of the panel to be facotorized.
                     83: *> \endverbatim
                     84: *>
                     85: *> \param[in,out] A
                     86: *> \verbatim
                     87: *>          A is COMPLEX*16 array, dimension (LDA,M) for
                     88: *>          the first panel, while dimension (LDA,M+1) for the
                     89: *>          remaining panels.
                     90: *>
                     91: *>          On entry, A contains the last row, or column, of
                     92: *>          the previous panel, and the trailing submatrix of A
                     93: *>          to be factorized, except for the first panel, only
                     94: *>          the panel is passed.
                     95: *>
                     96: *>          On exit, the leading panel is factorized.
                     97: *> \endverbatim
                     98: *>
                     99: *> \param[in] LDA
                    100: *> \verbatim
                    101: *>          LDA is INTEGER
                    102: *>          The leading dimension of the array A.  LDA >= max(1,N).
                    103: *> \endverbatim
                    104: *>
                    105: *> \param[out] IPIV
                    106: *> \verbatim
                    107: *>          IPIV is INTEGER array, dimension (N)
                    108: *>          Details of the row and column interchanges,
                    109: *>          the row and column k were interchanged with the row and
                    110: *>          column IPIV(k).
                    111: *> \endverbatim
                    112: *>
                    113: *> \param[in,out] H
                    114: *> \verbatim
                    115: *>          H is COMPLEX*16 workspace, dimension (LDH,NB).
                    116: *>
                    117: *> \endverbatim
                    118: *>
                    119: *> \param[in] LDH
                    120: *> \verbatim
                    121: *>          LDH is INTEGER
                    122: *>          The leading dimension of the workspace H. LDH >= max(1,M).
                    123: *> \endverbatim
                    124: *>
                    125: *> \param[out] WORK
                    126: *> \verbatim
                    127: *>          WORK is COMPLEX*16 workspace, dimension (M).
                    128: *> \endverbatim
                    129: *>
                    130: *
                    131: *  Authors:
                    132: *  ========
                    133: *
                    134: *> \author Univ. of Tennessee
                    135: *> \author Univ. of California Berkeley
                    136: *> \author Univ. of Colorado Denver
                    137: *> \author NAG Ltd.
                    138: *
                    139: *> \ingroup complex16HEcomputational
                    140: *
                    141: *  =====================================================================
                    142:       SUBROUTINE ZLAHEF_AA( UPLO, J1, M, NB, A, LDA, IPIV,
1.3       bertrand  143:      $                      H, LDH, WORK )
1.1       bertrand  144: *
1.6     ! bertrand  145: *  -- LAPACK computational routine --
1.1       bertrand  146: *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
                    147: *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
                    148: *
                    149:       IMPLICIT NONE
                    150: *
                    151: *     .. Scalar Arguments ..
                    152:       CHARACTER    UPLO
1.3       bertrand  153:       INTEGER      M, NB, J1, LDA, LDH
1.1       bertrand  154: *     ..
                    155: *     .. Array Arguments ..
                    156:       INTEGER      IPIV( * )
                    157:       COMPLEX*16   A( LDA, * ), H( LDH, * ), WORK( * )
                    158: *     ..
                    159: *
                    160: *  =====================================================================
                    161: *     .. Parameters ..
                    162:       COMPLEX*16   ZERO, ONE
                    163:       PARAMETER    ( ZERO = (0.0D+0, 0.0D+0), ONE = (1.0D+0, 0.0D+0) )
                    164: *
                    165: *     .. Local Scalars ..
1.3       bertrand  166:       INTEGER      J, K, K1, I1, I2, MJ
1.1       bertrand  167:       COMPLEX*16   PIV, ALPHA
                    168: *     ..
                    169: *     .. External Functions ..
                    170:       LOGICAL      LSAME
                    171:       INTEGER      IZAMAX, ILAENV
                    172:       EXTERNAL     LSAME, ILAENV, IZAMAX
                    173: *     ..
                    174: *     .. External Subroutines ..
1.3       bertrand  175:       EXTERNAL     ZGEMM, ZGEMV, ZAXPY, ZLACGV, ZCOPY, ZSCAL, ZSWAP,
                    176:      $             ZLASET, XERBLA
1.1       bertrand  177: *     ..
                    178: *     .. Intrinsic Functions ..
                    179:       INTRINSIC    DBLE, DCONJG, MAX
                    180: *     ..
                    181: *     .. Executable Statements ..
                    182: *
                    183:       J = 1
                    184: *
                    185: *     K1 is the first column of the panel to be factorized
                    186: *     i.e.,  K1 is 2 for the first block column, and 1 for the rest of the blocks
                    187: *
                    188:       K1 = (2-J1)+1
                    189: *
                    190:       IF( LSAME( UPLO, 'U' ) ) THEN
                    191: *
                    192: *        .....................................................
                    193: *        Factorize A as U**T*D*U using the upper triangle of A
                    194: *        .....................................................
                    195: *
                    196:  10      CONTINUE
                    197:          IF ( J.GT.MIN(M, NB) )
                    198:      $      GO TO 20
                    199: *
                    200: *        K is the column to be factorized
                    201: *         when being called from ZHETRF_AA,
                    202: *         > for the first block column, J1 is 1, hence J1+J-1 is J,
                    203: *         > for the rest of the columns, J1 is 2, and J1+J-1 is J+1,
                    204: *
                    205:          K = J1+J-1
1.3       bertrand  206:          IF( J.EQ.M ) THEN
                    207: *
                    208: *            Only need to compute T(J, J)
                    209: *
                    210:              MJ = 1
                    211:          ELSE
                    212:              MJ = M-J+1
                    213:          END IF
1.1       bertrand  214: *
                    215: *        H(J:N, J) := A(J, J:N) - H(J:N, 1:(J-1)) * L(J1:(J-1), J),
                    216: *         where H(J:N, J) has been initialized to be A(J, J:N)
                    217: *
                    218:          IF( K.GT.2 ) THEN
                    219: *
                    220: *        K is the column to be factorized
                    221: *         > for the first block column, K is J, skipping the first two
                    222: *           columns
                    223: *         > for the rest of the columns, K is J+1, skipping only the
                    224: *           first column
                    225: *
                    226:             CALL ZLACGV( J-K1, A( 1, J ), 1 )
1.3       bertrand  227:             CALL ZGEMV( 'No transpose', MJ, J-K1,
1.1       bertrand  228:      $                 -ONE, H( J, K1 ), LDH,
                    229:      $                       A( 1, J ), 1,
                    230:      $                  ONE, H( J, J ), 1 )
                    231:             CALL ZLACGV( J-K1, A( 1, J ), 1 )
                    232:          END IF
                    233: *
                    234: *        Copy H(i:n, i) into WORK
                    235: *
1.3       bertrand  236:          CALL ZCOPY( MJ, H( J, J ), 1, WORK( 1 ), 1 )
1.1       bertrand  237: *
                    238:          IF( J.GT.K1 ) THEN
                    239: *
                    240: *           Compute WORK := WORK - L(J-1, J:N) * T(J-1,J),
                    241: *            where A(J-1, J) stores T(J-1, J) and A(J-2, J:N) stores U(J-1, J:N)
                    242: *
                    243:             ALPHA = -DCONJG( A( K-1, J ) )
1.3       bertrand  244:             CALL ZAXPY( MJ, ALPHA, A( K-2, J ), LDA, WORK( 1 ), 1 )
1.1       bertrand  245:          END IF
                    246: *
                    247: *        Set A(J, J) = T(J, J)
                    248: *
                    249:          A( K, J ) = DBLE( WORK( 1 ) )
                    250: *
                    251:          IF( J.LT.M ) THEN
                    252: *
                    253: *           Compute WORK(2:N) = T(J, J) L(J, (J+1):N)
                    254: *            where A(J, J) stores T(J, J) and A(J-1, (J+1):N) stores U(J, (J+1):N)
                    255: *
                    256:             IF( K.GT.1 ) THEN
                    257:                ALPHA = -A( K, J )
                    258:                CALL ZAXPY( M-J, ALPHA, A( K-1, J+1 ), LDA,
                    259:      $                                 WORK( 2 ), 1 )
                    260:             ENDIF
                    261: *
                    262: *           Find max(|WORK(2:n)|)
                    263: *
                    264:             I2 = IZAMAX( M-J, WORK( 2 ), 1 ) + 1
                    265:             PIV = WORK( I2 )
                    266: *
                    267: *           Apply hermitian pivot
                    268: *
                    269:             IF( (I2.NE.2) .AND. (PIV.NE.0) ) THEN
                    270: *
                    271: *              Swap WORK(I1) and WORK(I2)
                    272: *
                    273:                I1 = 2
                    274:                WORK( I2 ) = WORK( I1 )
                    275:                WORK( I1 ) = PIV
                    276: *
                    277: *              Swap A(I1, I1+1:N) with A(I1+1:N, I2)
                    278: *
                    279:                I1 = I1+J-1
                    280:                I2 = I2+J-1
                    281:                CALL ZSWAP( I2-I1-1, A( J1+I1-1, I1+1 ), LDA,
                    282:      $                              A( J1+I1, I2 ), 1 )
                    283:                CALL ZLACGV( I2-I1, A( J1+I1-1, I1+1 ), LDA )
                    284:                CALL ZLACGV( I2-I1-1, A( J1+I1, I2 ), 1 )
                    285: *
                    286: *              Swap A(I1, I2+1:N) with A(I2, I2+1:N)
                    287: *
1.5       bertrand  288:                IF( I2.LT.M )
                    289:      $            CALL ZSWAP( M-I2, A( J1+I1-1, I2+1 ), LDA,
                    290:      $                              A( J1+I2-1, I2+1 ), LDA )
1.1       bertrand  291: *
                    292: *              Swap A(I1, I1) with A(I2,I2)
                    293: *
                    294:                PIV = A( I1+J1-1, I1 )
                    295:                A( J1+I1-1, I1 ) = A( J1+I2-1, I2 )
                    296:                A( J1+I2-1, I2 ) = PIV
                    297: *
                    298: *              Swap H(I1, 1:J1) with H(I2, 1:J1)
                    299: *
                    300:                CALL ZSWAP( I1-1, H( I1, 1 ), LDH, H( I2, 1 ), LDH )
                    301:                IPIV( I1 ) = I2
                    302: *
                    303:                IF( I1.GT.(K1-1) ) THEN
                    304: *
                    305: *                 Swap L(1:I1-1, I1) with L(1:I1-1, I2),
                    306: *                  skipping the first column
                    307: *
                    308:                   CALL ZSWAP( I1-K1+1, A( 1, I1 ), 1,
                    309:      $                                 A( 1, I2 ), 1 )
                    310:                END IF
                    311:             ELSE
                    312:                IPIV( J+1 ) = J+1
                    313:             ENDIF
                    314: *
                    315: *           Set A(J, J+1) = T(J, J+1)
                    316: *
                    317:             A( K, J+1 ) = WORK( 2 )
                    318: *
                    319:             IF( J.LT.NB ) THEN
                    320: *
                    321: *              Copy A(J+1:N, J+1) into H(J:N, J),
                    322: *
                    323:                CALL ZCOPY( M-J, A( K+1, J+1 ), LDA,
                    324:      $                          H( J+1, J+1 ), 1 )
                    325:             END IF
                    326: *
                    327: *           Compute L(J+2, J+1) = WORK( 3:N ) / T(J, J+1),
                    328: *            where A(J, J+1) = T(J, J+1) and A(J+2:N, J) = L(J+2:N, J+1)
                    329: *
1.5       bertrand  330:             IF( J.LT.(M-1) ) THEN
                    331:                IF( A( K, J+1 ).NE.ZERO ) THEN
                    332:                   ALPHA = ONE / A( K, J+1 )
                    333:                   CALL ZCOPY( M-J-1, WORK( 3 ), 1, A( K, J+2 ), LDA )
                    334:                   CALL ZSCAL( M-J-1, ALPHA, A( K, J+2 ), LDA )
                    335:                ELSE
                    336:                   CALL ZLASET( 'Full', 1, M-J-1, ZERO, ZERO,
                    337:      $                         A( K, J+2 ), LDA)
                    338:                END IF
1.1       bertrand  339:             END IF
                    340:          END IF
                    341:          J = J + 1
                    342:          GO TO 10
                    343:  20      CONTINUE
                    344: *
                    345:       ELSE
                    346: *
                    347: *        .....................................................
                    348: *        Factorize A as L*D*L**T using the lower triangle of A
                    349: *        .....................................................
                    350: *
                    351:  30      CONTINUE
                    352:          IF( J.GT.MIN( M, NB ) )
                    353:      $      GO TO 40
                    354: *
                    355: *        K is the column to be factorized
                    356: *         when being called from ZHETRF_AA,
                    357: *         > for the first block column, J1 is 1, hence J1+J-1 is J,
                    358: *         > for the rest of the columns, J1 is 2, and J1+J-1 is J+1,
                    359: *
                    360:          K = J1+J-1
1.3       bertrand  361:          IF( J.EQ.M ) THEN
                    362: *
                    363: *            Only need to compute T(J, J)
                    364: *
                    365:              MJ = 1
                    366:          ELSE
                    367:              MJ = M-J+1
                    368:          END IF
1.1       bertrand  369: *
                    370: *        H(J:N, J) := A(J:N, J) - H(J:N, 1:(J-1)) * L(J, J1:(J-1))^T,
                    371: *         where H(J:N, J) has been initialized to be A(J:N, J)
                    372: *
                    373:          IF( K.GT.2 ) THEN
                    374: *
                    375: *        K is the column to be factorized
                    376: *         > for the first block column, K is J, skipping the first two
                    377: *           columns
                    378: *         > for the rest of the columns, K is J+1, skipping only the
                    379: *           first column
                    380: *
                    381:             CALL ZLACGV( J-K1, A( J, 1 ), LDA )
1.3       bertrand  382:             CALL ZGEMV( 'No transpose', MJ, J-K1,
1.1       bertrand  383:      $                 -ONE, H( J, K1 ), LDH,
                    384:      $                       A( J, 1 ), LDA,
                    385:      $                  ONE, H( J, J ), 1 )
                    386:             CALL ZLACGV( J-K1, A( J, 1 ), LDA )
                    387:          END IF
                    388: *
                    389: *        Copy H(J:N, J) into WORK
                    390: *
1.3       bertrand  391:          CALL ZCOPY( MJ, H( J, J ), 1, WORK( 1 ), 1 )
1.1       bertrand  392: *
                    393:          IF( J.GT.K1 ) THEN
                    394: *
                    395: *           Compute WORK := WORK - L(J:N, J-1) * T(J-1,J),
                    396: *            where A(J-1, J) = T(J-1, J) and A(J, J-2) = L(J, J-1)
                    397: *
                    398:             ALPHA = -DCONJG( A( J, K-1 ) )
1.3       bertrand  399:             CALL ZAXPY( MJ, ALPHA, A( J, K-2 ), 1, WORK( 1 ), 1 )
1.1       bertrand  400:          END IF
                    401: *
                    402: *        Set A(J, J) = T(J, J)
                    403: *
                    404:          A( J, K ) = DBLE( WORK( 1 ) )
                    405: *
                    406:          IF( J.LT.M ) THEN
                    407: *
                    408: *           Compute WORK(2:N) = T(J, J) L((J+1):N, J)
                    409: *            where A(J, J) = T(J, J) and A((J+1):N, J-1) = L((J+1):N, J)
                    410: *
                    411:             IF( K.GT.1 ) THEN
                    412:                ALPHA = -A( J, K )
                    413:                CALL ZAXPY( M-J, ALPHA, A( J+1, K-1 ), 1,
                    414:      $                                 WORK( 2 ), 1 )
                    415:             ENDIF
                    416: *
                    417: *           Find max(|WORK(2:n)|)
                    418: *
                    419:             I2 = IZAMAX( M-J, WORK( 2 ), 1 ) + 1
                    420:             PIV = WORK( I2 )
                    421: *
                    422: *           Apply hermitian pivot
                    423: *
                    424:             IF( (I2.NE.2) .AND. (PIV.NE.0) ) THEN
                    425: *
                    426: *              Swap WORK(I1) and WORK(I2)
                    427: *
                    428:                I1 = 2
                    429:                WORK( I2 ) = WORK( I1 )
                    430:                WORK( I1 ) = PIV
                    431: *
                    432: *              Swap A(I1+1:N, I1) with A(I2, I1+1:N)
                    433: *
                    434:                I1 = I1+J-1
                    435:                I2 = I2+J-1
                    436:                CALL ZSWAP( I2-I1-1, A( I1+1, J1+I1-1 ), 1,
                    437:      $                              A( I2, J1+I1 ), LDA )
                    438:                CALL ZLACGV( I2-I1, A( I1+1, J1+I1-1 ), 1 )
                    439:                CALL ZLACGV( I2-I1-1, A( I2, J1+I1 ), LDA )
                    440: *
                    441: *              Swap A(I2+1:N, I1) with A(I2+1:N, I2)
                    442: *
1.5       bertrand  443:                IF( I2.LT.M )
                    444:      $            CALL ZSWAP( M-I2, A( I2+1, J1+I1-1 ), 1,
                    445:      $                              A( I2+1, J1+I2-1 ), 1 )
1.1       bertrand  446: *
                    447: *              Swap A(I1, I1) with A(I2, I2)
                    448: *
                    449:                PIV = A( I1, J1+I1-1 )
                    450:                A( I1, J1+I1-1 ) = A( I2, J1+I2-1 )
                    451:                A( I2, J1+I2-1 ) = PIV
                    452: *
                    453: *              Swap H(I1, I1:J1) with H(I2, I2:J1)
                    454: *
                    455:                CALL ZSWAP( I1-1, H( I1, 1 ), LDH, H( I2, 1 ), LDH )
                    456:                IPIV( I1 ) = I2
                    457: *
                    458:                IF( I1.GT.(K1-1) ) THEN
                    459: *
                    460: *                 Swap L(1:I1-1, I1) with L(1:I1-1, I2),
                    461: *                  skipping the first column
                    462: *
                    463:                   CALL ZSWAP( I1-K1+1, A( I1, 1 ), LDA,
                    464:      $                                 A( I2, 1 ), LDA )
                    465:                END IF
                    466:             ELSE
                    467:                IPIV( J+1 ) = J+1
                    468:             ENDIF
                    469: *
                    470: *           Set A(J+1, J) = T(J+1, J)
                    471: *
                    472:             A( J+1, K ) = WORK( 2 )
                    473: *
                    474:             IF( J.LT.NB ) THEN
                    475: *
                    476: *              Copy A(J+1:N, J+1) into H(J+1:N, J),
                    477: *
                    478:                CALL ZCOPY( M-J, A( J+1, K+1 ), 1,
                    479:      $                          H( J+1, J+1 ), 1 )
                    480:             END IF
                    481: *
                    482: *           Compute L(J+2, J+1) = WORK( 3:N ) / T(J, J+1),
                    483: *            where A(J, J+1) = T(J, J+1) and A(J+2:N, J) = L(J+2:N, J+1)
                    484: *
1.5       bertrand  485:             IF( J.LT.(M-1) ) THEN
                    486:                IF( A( J+1, K ).NE.ZERO ) THEN
                    487:                   ALPHA = ONE / A( J+1, K )
                    488:                   CALL ZCOPY( M-J-1, WORK( 3 ), 1, A( J+2, K ), 1 )
                    489:                   CALL ZSCAL( M-J-1, ALPHA, A( J+2, K ), 1 )
                    490:                ELSE
                    491:                   CALL ZLASET( 'Full', M-J-1, 1, ZERO, ZERO,
                    492:      $                         A( J+2, K ), LDA )
                    493:                END IF
1.1       bertrand  494:             END IF
                    495:          END IF
                    496:          J = J + 1
                    497:          GO TO 30
                    498:  40      CONTINUE
                    499:       END IF
                    500:       RETURN
                    501: *
                    502: *     End of ZLAHEF_AA
                    503: *
                    504:       END

CVSweb interface <joel.bertrand@systella.fr>