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

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: *
1.3       bertrand  139: *> \date November 2017
1.1       bertrand  140: *
                    141: *> \ingroup complex16HEcomputational
                    142: *
                    143: *  =====================================================================
                    144:       SUBROUTINE ZLAHEF_AA( UPLO, J1, M, NB, A, LDA, IPIV,
1.3       bertrand  145:      $                      H, LDH, WORK )
1.1       bertrand  146: *
1.3       bertrand  147: *  -- LAPACK computational routine (version 3.8.0) --
1.1       bertrand  148: *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
                    149: *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
1.3       bertrand  150: *     November 2017
1.1       bertrand  151: *
                    152:       IMPLICIT NONE
                    153: *
                    154: *     .. Scalar Arguments ..
                    155:       CHARACTER    UPLO
1.3       bertrand  156:       INTEGER      M, NB, J1, LDA, LDH
1.1       bertrand  157: *     ..
                    158: *     .. Array Arguments ..
                    159:       INTEGER      IPIV( * )
                    160:       COMPLEX*16   A( LDA, * ), H( LDH, * ), WORK( * )
                    161: *     ..
                    162: *
                    163: *  =====================================================================
                    164: *     .. Parameters ..
                    165:       COMPLEX*16   ZERO, ONE
                    166:       PARAMETER    ( ZERO = (0.0D+0, 0.0D+0), ONE = (1.0D+0, 0.0D+0) )
                    167: *
                    168: *     .. Local Scalars ..
1.3       bertrand  169:       INTEGER      J, K, K1, I1, I2, MJ
1.1       bertrand  170:       COMPLEX*16   PIV, ALPHA
                    171: *     ..
                    172: *     .. External Functions ..
                    173:       LOGICAL      LSAME
                    174:       INTEGER      IZAMAX, ILAENV
                    175:       EXTERNAL     LSAME, ILAENV, IZAMAX
                    176: *     ..
                    177: *     .. External Subroutines ..
1.3       bertrand  178:       EXTERNAL     ZGEMM, ZGEMV, ZAXPY, ZLACGV, ZCOPY, ZSCAL, ZSWAP,
                    179:      $             ZLASET, XERBLA
1.1       bertrand  180: *     ..
                    181: *     .. Intrinsic Functions ..
                    182:       INTRINSIC    DBLE, DCONJG, MAX
                    183: *     ..
                    184: *     .. Executable Statements ..
                    185: *
                    186:       J = 1
                    187: *
                    188: *     K1 is the first column of the panel to be factorized
                    189: *     i.e.,  K1 is 2 for the first block column, and 1 for the rest of the blocks
                    190: *
                    191:       K1 = (2-J1)+1
                    192: *
                    193:       IF( LSAME( UPLO, 'U' ) ) THEN
                    194: *
                    195: *        .....................................................
                    196: *        Factorize A as U**T*D*U using the upper triangle of A
                    197: *        .....................................................
                    198: *
                    199:  10      CONTINUE
                    200:          IF ( J.GT.MIN(M, NB) )
                    201:      $      GO TO 20
                    202: *
                    203: *        K is the column to be factorized
                    204: *         when being called from ZHETRF_AA,
                    205: *         > for the first block column, J1 is 1, hence J1+J-1 is J,
                    206: *         > for the rest of the columns, J1 is 2, and J1+J-1 is J+1,
                    207: *
                    208:          K = J1+J-1
1.3       bertrand  209:          IF( J.EQ.M ) THEN
                    210: *
                    211: *            Only need to compute T(J, J)
                    212: *
                    213:              MJ = 1
                    214:          ELSE
                    215:              MJ = M-J+1
                    216:          END IF
1.1       bertrand  217: *
                    218: *        H(J:N, J) := A(J, J:N) - H(J:N, 1:(J-1)) * L(J1:(J-1), J),
                    219: *         where H(J:N, J) has been initialized to be A(J, J:N)
                    220: *
                    221:          IF( K.GT.2 ) THEN
                    222: *
                    223: *        K is the column to be factorized
                    224: *         > for the first block column, K is J, skipping the first two
                    225: *           columns
                    226: *         > for the rest of the columns, K is J+1, skipping only the
                    227: *           first column
                    228: *
                    229:             CALL ZLACGV( J-K1, A( 1, J ), 1 )
1.3       bertrand  230:             CALL ZGEMV( 'No transpose', MJ, J-K1,
1.1       bertrand  231:      $                 -ONE, H( J, K1 ), LDH,
                    232:      $                       A( 1, J ), 1,
                    233:      $                  ONE, H( J, J ), 1 )
                    234:             CALL ZLACGV( J-K1, A( 1, J ), 1 )
                    235:          END IF
                    236: *
                    237: *        Copy H(i:n, i) into WORK
                    238: *
1.3       bertrand  239:          CALL ZCOPY( MJ, H( J, J ), 1, WORK( 1 ), 1 )
1.1       bertrand  240: *
                    241:          IF( J.GT.K1 ) THEN
                    242: *
                    243: *           Compute WORK := WORK - L(J-1, J:N) * T(J-1,J),
                    244: *            where A(J-1, J) stores T(J-1, J) and A(J-2, J:N) stores U(J-1, J:N)
                    245: *
                    246:             ALPHA = -DCONJG( A( K-1, J ) )
1.3       bertrand  247:             CALL ZAXPY( MJ, ALPHA, A( K-2, J ), LDA, WORK( 1 ), 1 )
1.1       bertrand  248:          END IF
                    249: *
                    250: *        Set A(J, J) = T(J, J)
                    251: *
                    252:          A( K, J ) = DBLE( WORK( 1 ) )
                    253: *
                    254:          IF( J.LT.M ) THEN
                    255: *
                    256: *           Compute WORK(2:N) = T(J, J) L(J, (J+1):N)
                    257: *            where A(J, J) stores T(J, J) and A(J-1, (J+1):N) stores U(J, (J+1):N)
                    258: *
                    259:             IF( K.GT.1 ) THEN
                    260:                ALPHA = -A( K, J )
                    261:                CALL ZAXPY( M-J, ALPHA, A( K-1, J+1 ), LDA,
                    262:      $                                 WORK( 2 ), 1 )
                    263:             ENDIF
                    264: *
                    265: *           Find max(|WORK(2:n)|)
                    266: *
                    267:             I2 = IZAMAX( M-J, WORK( 2 ), 1 ) + 1
                    268:             PIV = WORK( I2 )
                    269: *
                    270: *           Apply hermitian pivot
                    271: *
                    272:             IF( (I2.NE.2) .AND. (PIV.NE.0) ) THEN
                    273: *
                    274: *              Swap WORK(I1) and WORK(I2)
                    275: *
                    276:                I1 = 2
                    277:                WORK( I2 ) = WORK( I1 )
                    278:                WORK( I1 ) = PIV
                    279: *
                    280: *              Swap A(I1, I1+1:N) with A(I1+1:N, I2)
                    281: *
                    282:                I1 = I1+J-1
                    283:                I2 = I2+J-1
                    284:                CALL ZSWAP( I2-I1-1, A( J1+I1-1, I1+1 ), LDA,
                    285:      $                              A( J1+I1, I2 ), 1 )
                    286:                CALL ZLACGV( I2-I1, A( J1+I1-1, I1+1 ), LDA )
                    287:                CALL ZLACGV( I2-I1-1, A( J1+I1, I2 ), 1 )
                    288: *
                    289: *              Swap A(I1, I2+1:N) with A(I2, I2+1:N)
                    290: *
1.5     ! bertrand  291:                IF( I2.LT.M )
        !           292:      $            CALL ZSWAP( M-I2, A( J1+I1-1, I2+1 ), LDA,
        !           293:      $                              A( J1+I2-1, I2+1 ), LDA )
1.1       bertrand  294: *
                    295: *              Swap A(I1, I1) with A(I2,I2)
                    296: *
                    297:                PIV = A( I1+J1-1, I1 )
                    298:                A( J1+I1-1, I1 ) = A( J1+I2-1, I2 )
                    299:                A( J1+I2-1, I2 ) = PIV
                    300: *
                    301: *              Swap H(I1, 1:J1) with H(I2, 1:J1)
                    302: *
                    303:                CALL ZSWAP( I1-1, H( I1, 1 ), LDH, H( I2, 1 ), LDH )
                    304:                IPIV( I1 ) = I2
                    305: *
                    306:                IF( I1.GT.(K1-1) ) THEN
                    307: *
                    308: *                 Swap L(1:I1-1, I1) with L(1:I1-1, I2),
                    309: *                  skipping the first column
                    310: *
                    311:                   CALL ZSWAP( I1-K1+1, A( 1, I1 ), 1,
                    312:      $                                 A( 1, I2 ), 1 )
                    313:                END IF
                    314:             ELSE
                    315:                IPIV( J+1 ) = J+1
                    316:             ENDIF
                    317: *
                    318: *           Set A(J, J+1) = T(J, J+1)
                    319: *
                    320:             A( K, J+1 ) = WORK( 2 )
                    321: *
                    322:             IF( J.LT.NB ) THEN
                    323: *
                    324: *              Copy A(J+1:N, J+1) into H(J:N, J),
                    325: *
                    326:                CALL ZCOPY( M-J, A( K+1, J+1 ), LDA,
                    327:      $                          H( J+1, J+1 ), 1 )
                    328:             END IF
                    329: *
                    330: *           Compute L(J+2, J+1) = WORK( 3:N ) / T(J, J+1),
                    331: *            where A(J, J+1) = T(J, J+1) and A(J+2:N, J) = L(J+2:N, J+1)
                    332: *
1.5     ! bertrand  333:             IF( J.LT.(M-1) ) THEN
        !           334:                IF( A( K, J+1 ).NE.ZERO ) THEN
        !           335:                   ALPHA = ONE / A( K, J+1 )
        !           336:                   CALL ZCOPY( M-J-1, WORK( 3 ), 1, A( K, J+2 ), LDA )
        !           337:                   CALL ZSCAL( M-J-1, ALPHA, A( K, J+2 ), LDA )
        !           338:                ELSE
        !           339:                   CALL ZLASET( 'Full', 1, M-J-1, ZERO, ZERO,
        !           340:      $                         A( K, J+2 ), LDA)
        !           341:                END IF
1.1       bertrand  342:             END IF
                    343:          END IF
                    344:          J = J + 1
                    345:          GO TO 10
                    346:  20      CONTINUE
                    347: *
                    348:       ELSE
                    349: *
                    350: *        .....................................................
                    351: *        Factorize A as L*D*L**T using the lower triangle of A
                    352: *        .....................................................
                    353: *
                    354:  30      CONTINUE
                    355:          IF( J.GT.MIN( M, NB ) )
                    356:      $      GO TO 40
                    357: *
                    358: *        K is the column to be factorized
                    359: *         when being called from ZHETRF_AA,
                    360: *         > for the first block column, J1 is 1, hence J1+J-1 is J,
                    361: *         > for the rest of the columns, J1 is 2, and J1+J-1 is J+1,
                    362: *
                    363:          K = J1+J-1
1.3       bertrand  364:          IF( J.EQ.M ) THEN
                    365: *
                    366: *            Only need to compute T(J, J)
                    367: *
                    368:              MJ = 1
                    369:          ELSE
                    370:              MJ = M-J+1
                    371:          END IF
1.1       bertrand  372: *
                    373: *        H(J:N, J) := A(J:N, J) - H(J:N, 1:(J-1)) * L(J, J1:(J-1))^T,
                    374: *         where H(J:N, J) has been initialized to be A(J:N, J)
                    375: *
                    376:          IF( K.GT.2 ) THEN
                    377: *
                    378: *        K is the column to be factorized
                    379: *         > for the first block column, K is J, skipping the first two
                    380: *           columns
                    381: *         > for the rest of the columns, K is J+1, skipping only the
                    382: *           first column
                    383: *
                    384:             CALL ZLACGV( J-K1, A( J, 1 ), LDA )
1.3       bertrand  385:             CALL ZGEMV( 'No transpose', MJ, J-K1,
1.1       bertrand  386:      $                 -ONE, H( J, K1 ), LDH,
                    387:      $                       A( J, 1 ), LDA,
                    388:      $                  ONE, H( J, J ), 1 )
                    389:             CALL ZLACGV( J-K1, A( J, 1 ), LDA )
                    390:          END IF
                    391: *
                    392: *        Copy H(J:N, J) into WORK
                    393: *
1.3       bertrand  394:          CALL ZCOPY( MJ, H( J, J ), 1, WORK( 1 ), 1 )
1.1       bertrand  395: *
                    396:          IF( J.GT.K1 ) THEN
                    397: *
                    398: *           Compute WORK := WORK - L(J:N, J-1) * T(J-1,J),
                    399: *            where A(J-1, J) = T(J-1, J) and A(J, J-2) = L(J, J-1)
                    400: *
                    401:             ALPHA = -DCONJG( A( J, K-1 ) )
1.3       bertrand  402:             CALL ZAXPY( MJ, ALPHA, A( J, K-2 ), 1, WORK( 1 ), 1 )
1.1       bertrand  403:          END IF
                    404: *
                    405: *        Set A(J, J) = T(J, J)
                    406: *
                    407:          A( J, K ) = DBLE( WORK( 1 ) )
                    408: *
                    409:          IF( J.LT.M ) THEN
                    410: *
                    411: *           Compute WORK(2:N) = T(J, J) L((J+1):N, J)
                    412: *            where A(J, J) = T(J, J) and A((J+1):N, J-1) = L((J+1):N, J)
                    413: *
                    414:             IF( K.GT.1 ) THEN
                    415:                ALPHA = -A( J, K )
                    416:                CALL ZAXPY( M-J, ALPHA, A( J+1, K-1 ), 1,
                    417:      $                                 WORK( 2 ), 1 )
                    418:             ENDIF
                    419: *
                    420: *           Find max(|WORK(2:n)|)
                    421: *
                    422:             I2 = IZAMAX( M-J, WORK( 2 ), 1 ) + 1
                    423:             PIV = WORK( I2 )
                    424: *
                    425: *           Apply hermitian pivot
                    426: *
                    427:             IF( (I2.NE.2) .AND. (PIV.NE.0) ) THEN
                    428: *
                    429: *              Swap WORK(I1) and WORK(I2)
                    430: *
                    431:                I1 = 2
                    432:                WORK( I2 ) = WORK( I1 )
                    433:                WORK( I1 ) = PIV
                    434: *
                    435: *              Swap A(I1+1:N, I1) with A(I2, I1+1:N)
                    436: *
                    437:                I1 = I1+J-1
                    438:                I2 = I2+J-1
                    439:                CALL ZSWAP( I2-I1-1, A( I1+1, J1+I1-1 ), 1,
                    440:      $                              A( I2, J1+I1 ), LDA )
                    441:                CALL ZLACGV( I2-I1, A( I1+1, J1+I1-1 ), 1 )
                    442:                CALL ZLACGV( I2-I1-1, A( I2, J1+I1 ), LDA )
                    443: *
                    444: *              Swap A(I2+1:N, I1) with A(I2+1:N, I2)
                    445: *
1.5     ! bertrand  446:                IF( I2.LT.M )
        !           447:      $            CALL ZSWAP( M-I2, A( I2+1, J1+I1-1 ), 1,
        !           448:      $                              A( I2+1, J1+I2-1 ), 1 )
1.1       bertrand  449: *
                    450: *              Swap A(I1, I1) with A(I2, I2)
                    451: *
                    452:                PIV = A( I1, J1+I1-1 )
                    453:                A( I1, J1+I1-1 ) = A( I2, J1+I2-1 )
                    454:                A( I2, J1+I2-1 ) = PIV
                    455: *
                    456: *              Swap H(I1, I1:J1) with H(I2, I2:J1)
                    457: *
                    458:                CALL ZSWAP( I1-1, H( I1, 1 ), LDH, H( I2, 1 ), LDH )
                    459:                IPIV( I1 ) = I2
                    460: *
                    461:                IF( I1.GT.(K1-1) ) THEN
                    462: *
                    463: *                 Swap L(1:I1-1, I1) with L(1:I1-1, I2),
                    464: *                  skipping the first column
                    465: *
                    466:                   CALL ZSWAP( I1-K1+1, A( I1, 1 ), LDA,
                    467:      $                                 A( I2, 1 ), LDA )
                    468:                END IF
                    469:             ELSE
                    470:                IPIV( J+1 ) = J+1
                    471:             ENDIF
                    472: *
                    473: *           Set A(J+1, J) = T(J+1, J)
                    474: *
                    475:             A( J+1, K ) = WORK( 2 )
                    476: *
                    477:             IF( J.LT.NB ) THEN
                    478: *
                    479: *              Copy A(J+1:N, J+1) into H(J+1:N, J),
                    480: *
                    481:                CALL ZCOPY( M-J, A( J+1, K+1 ), 1,
                    482:      $                          H( J+1, J+1 ), 1 )
                    483:             END IF
                    484: *
                    485: *           Compute L(J+2, J+1) = WORK( 3:N ) / T(J, J+1),
                    486: *            where A(J, J+1) = T(J, J+1) and A(J+2:N, J) = L(J+2:N, J+1)
                    487: *
1.5     ! bertrand  488:             IF( J.LT.(M-1) ) THEN
        !           489:                IF( A( J+1, K ).NE.ZERO ) THEN
        !           490:                   ALPHA = ONE / A( J+1, K )
        !           491:                   CALL ZCOPY( M-J-1, WORK( 3 ), 1, A( J+2, K ), 1 )
        !           492:                   CALL ZSCAL( M-J-1, ALPHA, A( J+2, K ), 1 )
        !           493:                ELSE
        !           494:                   CALL ZLASET( 'Full', M-J-1, 1, ZERO, ZERO,
        !           495:      $                         A( J+2, K ), LDA )
        !           496:                END IF
1.1       bertrand  497:             END IF
                    498:          END IF
                    499:          J = J + 1
                    500:          GO TO 30
                    501:  40      CONTINUE
                    502:       END IF
                    503:       RETURN
                    504: *
                    505: *     End of ZLAHEF_AA
                    506: *
                    507:       END

CVSweb interface <joel.bertrand@systella.fr>