001:       SUBROUTINE CSPTRF( UPLO, N, AP, IPIV, INFO )
002: *
003: *  -- LAPACK routine (version 3.2) --
004: *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
005: *     November 2006
006: *
007: *     .. Scalar Arguments ..
008:       CHARACTER          UPLO
009:       INTEGER            INFO, N
010: *     ..
011: *     .. Array Arguments ..
012:       INTEGER            IPIV( * )
013:       COMPLEX            AP( * )
014: *     ..
015: *
016: *  Purpose
017: *  =======
018: *
019: *  CSPTRF computes the factorization of a complex symmetric matrix A
020: *  stored in packed format using the Bunch-Kaufman diagonal pivoting
021: *  method:
022: *
023: *     A = U*D*U**T  or  A = L*D*L**T
024: *
025: *  where U (or L) is a product of permutation and unit upper (lower)
026: *  triangular matrices, and D is symmetric and block diagonal with
027: *  1-by-1 and 2-by-2 diagonal blocks.
028: *
029: *  Arguments
030: *  =========
031: *
032: *  UPLO    (input) CHARACTER*1
033: *          = 'U':  Upper triangle of A is stored;
034: *          = 'L':  Lower triangle of A is stored.
035: *
036: *  N       (input) INTEGER
037: *          The order of the matrix A.  N >= 0.
038: *
039: *  AP      (input/output) COMPLEX array, dimension (N*(N+1)/2)
040: *          On entry, the upper or lower triangle of the symmetric matrix
041: *          A, packed columnwise in a linear array.  The j-th column of A
042: *          is stored in the array AP as follows:
043: *          if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
044: *          if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
045: *
046: *          On exit, the block diagonal matrix D and the multipliers used
047: *          to obtain the factor U or L, stored as a packed triangular
048: *          matrix overwriting A (see below for further details).
049: *
050: *  IPIV    (output) INTEGER array, dimension (N)
051: *          Details of the interchanges and the block structure of D.
052: *          If IPIV(k) > 0, then rows and columns k and IPIV(k) were
053: *          interchanged and D(k,k) is a 1-by-1 diagonal block.
054: *          If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and
055: *          columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)
056: *          is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =
057: *          IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were
058: *          interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
059: *
060: *  INFO    (output) INTEGER
061: *          = 0: successful exit
062: *          < 0: if INFO = -i, the i-th argument had an illegal value
063: *          > 0: if INFO = i, D(i,i) is exactly zero.  The factorization
064: *               has been completed, but the block diagonal matrix D is
065: *               exactly singular, and division by zero will occur if it
066: *               is used to solve a system of equations.
067: *
068: *  Further Details
069: *  ===============
070: *
071: *  5-96 - Based on modifications by J. Lewis, Boeing Computer Services
072: *         Company
073: *
074: *  If UPLO = 'U', then A = U*D*U', where
075: *     U = P(n)*U(n)* ... *P(k)U(k)* ...,
076: *  i.e., U is a product of terms P(k)*U(k), where k decreases from n to
077: *  1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
078: *  and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
079: *  defined by IPIV(k), and U(k) is a unit upper triangular matrix, such
080: *  that if the diagonal block D(k) is of order s (s = 1 or 2), then
081: *
082: *             (   I    v    0   )   k-s
083: *     U(k) =  (   0    I    0   )   s
084: *             (   0    0    I   )   n-k
085: *                k-s   s   n-k
086: *
087: *  If s = 1, D(k) overwrites A(k,k), and v overwrites A(1:k-1,k).
088: *  If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
089: *  and A(k,k), and v overwrites A(1:k-2,k-1:k).
090: *
091: *  If UPLO = 'L', then A = L*D*L', where
092: *     L = P(1)*L(1)* ... *P(k)*L(k)* ...,
093: *  i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
094: *  n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
095: *  and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
096: *  defined by IPIV(k), and L(k) is a unit lower triangular matrix, such
097: *  that if the diagonal block D(k) is of order s (s = 1 or 2), then
098: *
099: *             (   I    0     0   )  k-1
100: *     L(k) =  (   0    I     0   )  s
101: *             (   0    v     I   )  n-k-s+1
102: *                k-1   s  n-k-s+1
103: *
104: *  If s = 1, D(k) overwrites A(k,k), and v overwrites A(k+1:n,k).
105: *  If s = 2, the lower triangle of D(k) overwrites A(k,k), A(k+1,k),
106: *  and A(k+1,k+1), and v overwrites A(k+2:n,k:k+1).
107: *
108: *  =====================================================================
109: *
110: *     .. Parameters ..
111:       REAL               ZERO, ONE
112:       PARAMETER          ( ZERO = 0.0E+0, ONE = 1.0E+0 )
113:       REAL               EIGHT, SEVTEN
114:       PARAMETER          ( EIGHT = 8.0E+0, SEVTEN = 17.0E+0 )
115:       COMPLEX            CONE
116:       PARAMETER          ( CONE = ( 1.0E+0, 0.0E+0 ) )
117: *     ..
118: *     .. Local Scalars ..
119:       LOGICAL            UPPER
120:       INTEGER            I, IMAX, J, JMAX, K, KC, KK, KNC, KP, KPC,
121:      $                   KSTEP, KX, NPP
122:       REAL               ABSAKK, ALPHA, COLMAX, ROWMAX
123:       COMPLEX            D11, D12, D21, D22, R1, T, WK, WKM1, WKP1, ZDUM
124: *     ..
125: *     .. External Functions ..
126:       LOGICAL            LSAME
127:       INTEGER            ICAMAX
128:       EXTERNAL           LSAME, ICAMAX
129: *     ..
130: *     .. External Subroutines ..
131:       EXTERNAL           CSCAL, CSPR, CSWAP, XERBLA
132: *     ..
133: *     .. Intrinsic Functions ..
134:       INTRINSIC          ABS, AIMAG, MAX, REAL, SQRT
135: *     ..
136: *     .. Statement Functions ..
137:       REAL               CABS1
138: *     ..
139: *     .. Statement Function definitions ..
140:       CABS1( ZDUM ) = ABS( REAL( ZDUM ) ) + ABS( AIMAG( ZDUM ) )
141: *     ..
142: *     .. Executable Statements ..
143: *
144: *     Test the input parameters.
145: *
146:       INFO = 0
147:       UPPER = LSAME( UPLO, 'U' )
148:       IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
149:          INFO = -1
150:       ELSE IF( N.LT.0 ) THEN
151:          INFO = -2
152:       END IF
153:       IF( INFO.NE.0 ) THEN
154:          CALL XERBLA( 'CSPTRF', -INFO )
155:          RETURN
156:       END IF
157: *
158: *     Initialize ALPHA for use in choosing pivot block size.
159: *
160:       ALPHA = ( ONE+SQRT( SEVTEN ) ) / EIGHT
161: *
162:       IF( UPPER ) THEN
163: *
164: *        Factorize A as U*D*U' using the upper triangle of A
165: *
166: *        K is the main loop index, decreasing from N to 1 in steps of
167: *        1 or 2
168: *
169:          K = N
170:          KC = ( N-1 )*N / 2 + 1
171:    10    CONTINUE
172:          KNC = KC
173: *
174: *        If K < 1, exit from loop
175: *
176:          IF( K.LT.1 )
177:      $      GO TO 110
178:          KSTEP = 1
179: *
180: *        Determine rows and columns to be interchanged and whether
181: *        a 1-by-1 or 2-by-2 pivot block will be used
182: *
183:          ABSAKK = CABS1( AP( KC+K-1 ) )
184: *
185: *        IMAX is the row-index of the largest off-diagonal element in
186: *        column K, and COLMAX is its absolute value
187: *
188:          IF( K.GT.1 ) THEN
189:             IMAX = ICAMAX( K-1, AP( KC ), 1 )
190:             COLMAX = CABS1( AP( KC+IMAX-1 ) )
191:          ELSE
192:             COLMAX = ZERO
193:          END IF
194: *
195:          IF( MAX( ABSAKK, COLMAX ).EQ.ZERO ) THEN
196: *
197: *           Column K is zero: set INFO and continue
198: *
199:             IF( INFO.EQ.0 )
200:      $         INFO = K
201:             KP = K
202:          ELSE
203:             IF( ABSAKK.GE.ALPHA*COLMAX ) THEN
204: *
205: *              no interchange, use 1-by-1 pivot block
206: *
207:                KP = K
208:             ELSE
209: *
210: *              JMAX is the column-index of the largest off-diagonal
211: *              element in row IMAX, and ROWMAX is its absolute value
212: *
213:                ROWMAX = ZERO
214:                JMAX = IMAX
215:                KX = IMAX*( IMAX+1 ) / 2 + IMAX
216:                DO 20 J = IMAX + 1, K
217:                   IF( CABS1( AP( KX ) ).GT.ROWMAX ) THEN
218:                      ROWMAX = CABS1( AP( KX ) )
219:                      JMAX = J
220:                   END IF
221:                   KX = KX + J
222:    20          CONTINUE
223:                KPC = ( IMAX-1 )*IMAX / 2 + 1
224:                IF( IMAX.GT.1 ) THEN
225:                   JMAX = ICAMAX( IMAX-1, AP( KPC ), 1 )
226:                   ROWMAX = MAX( ROWMAX, CABS1( AP( KPC+JMAX-1 ) ) )
227:                END IF
228: *
229:                IF( ABSAKK.GE.ALPHA*COLMAX*( COLMAX / ROWMAX ) ) THEN
230: *
231: *                 no interchange, use 1-by-1 pivot block
232: *
233:                   KP = K
234:                ELSE IF( CABS1( AP( KPC+IMAX-1 ) ).GE.ALPHA*ROWMAX ) THEN
235: *
236: *                 interchange rows and columns K and IMAX, use 1-by-1
237: *                 pivot block
238: *
239:                   KP = IMAX
240:                ELSE
241: *
242: *                 interchange rows and columns K-1 and IMAX, use 2-by-2
243: *                 pivot block
244: *
245:                   KP = IMAX
246:                   KSTEP = 2
247:                END IF
248:             END IF
249: *
250:             KK = K - KSTEP + 1
251:             IF( KSTEP.EQ.2 )
252:      $         KNC = KNC - K + 1
253:             IF( KP.NE.KK ) THEN
254: *
255: *              Interchange rows and columns KK and KP in the leading
256: *              submatrix A(1:k,1:k)
257: *
258:                CALL CSWAP( KP-1, AP( KNC ), 1, AP( KPC ), 1 )
259:                KX = KPC + KP - 1
260:                DO 30 J = KP + 1, KK - 1
261:                   KX = KX + J - 1
262:                   T = AP( KNC+J-1 )
263:                   AP( KNC+J-1 ) = AP( KX )
264:                   AP( KX ) = T
265:    30          CONTINUE
266:                T = AP( KNC+KK-1 )
267:                AP( KNC+KK-1 ) = AP( KPC+KP-1 )
268:                AP( KPC+KP-1 ) = T
269:                IF( KSTEP.EQ.2 ) THEN
270:                   T = AP( KC+K-2 )
271:                   AP( KC+K-2 ) = AP( KC+KP-1 )
272:                   AP( KC+KP-1 ) = T
273:                END IF
274:             END IF
275: *
276: *           Update the leading submatrix
277: *
278:             IF( KSTEP.EQ.1 ) THEN
279: *
280: *              1-by-1 pivot block D(k): column k now holds
281: *
282: *              W(k) = U(k)*D(k)
283: *
284: *              where U(k) is the k-th column of U
285: *
286: *              Perform a rank-1 update of A(1:k-1,1:k-1) as
287: *
288: *              A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
289: *
290:                R1 = CONE / AP( KC+K-1 )
291:                CALL CSPR( UPLO, K-1, -R1, AP( KC ), 1, AP )
292: *
293: *              Store U(k) in column k
294: *
295:                CALL CSCAL( K-1, R1, AP( KC ), 1 )
296:             ELSE
297: *
298: *              2-by-2 pivot block D(k): columns k and k-1 now hold
299: *
300: *              ( W(k-1) W(k) ) = ( U(k-1) U(k) )*D(k)
301: *
302: *              where U(k) and U(k-1) are the k-th and (k-1)-th columns
303: *              of U
304: *
305: *              Perform a rank-2 update of A(1:k-2,1:k-2) as
306: *
307: *              A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
308: *                 = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
309: *
310:                IF( K.GT.2 ) THEN
311: *
312:                   D12 = AP( K-1+( K-1 )*K / 2 )
313:                   D22 = AP( K-1+( K-2 )*( K-1 ) / 2 ) / D12
314:                   D11 = AP( K+( K-1 )*K / 2 ) / D12
315:                   T = CONE / ( D11*D22-CONE )
316:                   D12 = T / D12
317: *
318:                   DO 50 J = K - 2, 1, -1
319:                      WKM1 = D12*( D11*AP( J+( K-2 )*( K-1 ) / 2 )-
320:      $                      AP( J+( K-1 )*K / 2 ) )
321:                      WK = D12*( D22*AP( J+( K-1 )*K / 2 )-
322:      $                    AP( J+( K-2 )*( K-1 ) / 2 ) )
323:                      DO 40 I = J, 1, -1
324:                         AP( I+( J-1 )*J / 2 ) = AP( I+( J-1 )*J / 2 ) -
325:      $                     AP( I+( K-1 )*K / 2 )*WK -
326:      $                     AP( I+( K-2 )*( K-1 ) / 2 )*WKM1
327:    40                CONTINUE
328:                      AP( J+( K-1 )*K / 2 ) = WK
329:                      AP( J+( K-2 )*( K-1 ) / 2 ) = WKM1
330:    50             CONTINUE
331: *
332:                END IF
333:             END IF
334:          END IF
335: *
336: *        Store details of the interchanges in IPIV
337: *
338:          IF( KSTEP.EQ.1 ) THEN
339:             IPIV( K ) = KP
340:          ELSE
341:             IPIV( K ) = -KP
342:             IPIV( K-1 ) = -KP
343:          END IF
344: *
345: *        Decrease K and return to the start of the main loop
346: *
347:          K = K - KSTEP
348:          KC = KNC - K
349:          GO TO 10
350: *
351:       ELSE
352: *
353: *        Factorize A as L*D*L' using the lower triangle of A
354: *
355: *        K is the main loop index, increasing from 1 to N in steps of
356: *        1 or 2
357: *
358:          K = 1
359:          KC = 1
360:          NPP = N*( N+1 ) / 2
361:    60    CONTINUE
362:          KNC = KC
363: *
364: *        If K > N, exit from loop
365: *
366:          IF( K.GT.N )
367:      $      GO TO 110
368:          KSTEP = 1
369: *
370: *        Determine rows and columns to be interchanged and whether
371: *        a 1-by-1 or 2-by-2 pivot block will be used
372: *
373:          ABSAKK = CABS1( AP( KC ) )
374: *
375: *        IMAX is the row-index of the largest off-diagonal element in
376: *        column K, and COLMAX is its absolute value
377: *
378:          IF( K.LT.N ) THEN
379:             IMAX = K + ICAMAX( N-K, AP( KC+1 ), 1 )
380:             COLMAX = CABS1( AP( KC+IMAX-K ) )
381:          ELSE
382:             COLMAX = ZERO
383:          END IF
384: *
385:          IF( MAX( ABSAKK, COLMAX ).EQ.ZERO ) THEN
386: *
387: *           Column K is zero: set INFO and continue
388: *
389:             IF( INFO.EQ.0 )
390:      $         INFO = K
391:             KP = K
392:          ELSE
393:             IF( ABSAKK.GE.ALPHA*COLMAX ) THEN
394: *
395: *              no interchange, use 1-by-1 pivot block
396: *
397:                KP = K
398:             ELSE
399: *
400: *              JMAX is the column-index of the largest off-diagonal
401: *              element in row IMAX, and ROWMAX is its absolute value
402: *
403:                ROWMAX = ZERO
404:                KX = KC + IMAX - K
405:                DO 70 J = K, IMAX - 1
406:                   IF( CABS1( AP( KX ) ).GT.ROWMAX ) THEN
407:                      ROWMAX = CABS1( AP( KX ) )
408:                      JMAX = J
409:                   END IF
410:                   KX = KX + N - J
411:    70          CONTINUE
412:                KPC = NPP - ( N-IMAX+1 )*( N-IMAX+2 ) / 2 + 1
413:                IF( IMAX.LT.N ) THEN
414:                   JMAX = IMAX + ICAMAX( N-IMAX, AP( KPC+1 ), 1 )
415:                   ROWMAX = MAX( ROWMAX, CABS1( AP( KPC+JMAX-IMAX ) ) )
416:                END IF
417: *
418:                IF( ABSAKK.GE.ALPHA*COLMAX*( COLMAX / ROWMAX ) ) THEN
419: *
420: *                 no interchange, use 1-by-1 pivot block
421: *
422:                   KP = K
423:                ELSE IF( CABS1( AP( KPC ) ).GE.ALPHA*ROWMAX ) THEN
424: *
425: *                 interchange rows and columns K and IMAX, use 1-by-1
426: *                 pivot block
427: *
428:                   KP = IMAX
429:                ELSE
430: *
431: *                 interchange rows and columns K+1 and IMAX, use 2-by-2
432: *                 pivot block
433: *
434:                   KP = IMAX
435:                   KSTEP = 2
436:                END IF
437:             END IF
438: *
439:             KK = K + KSTEP - 1
440:             IF( KSTEP.EQ.2 )
441:      $         KNC = KNC + N - K + 1
442:             IF( KP.NE.KK ) THEN
443: *
444: *              Interchange rows and columns KK and KP in the trailing
445: *              submatrix A(k:n,k:n)
446: *
447:                IF( KP.LT.N )
448:      $            CALL CSWAP( N-KP, AP( KNC+KP-KK+1 ), 1, AP( KPC+1 ),
449:      $                        1 )
450:                KX = KNC + KP - KK
451:                DO 80 J = KK + 1, KP - 1
452:                   KX = KX + N - J + 1
453:                   T = AP( KNC+J-KK )
454:                   AP( KNC+J-KK ) = AP( KX )
455:                   AP( KX ) = T
456:    80          CONTINUE
457:                T = AP( KNC )
458:                AP( KNC ) = AP( KPC )
459:                AP( KPC ) = T
460:                IF( KSTEP.EQ.2 ) THEN
461:                   T = AP( KC+1 )
462:                   AP( KC+1 ) = AP( KC+KP-K )
463:                   AP( KC+KP-K ) = T
464:                END IF
465:             END IF
466: *
467: *           Update the trailing submatrix
468: *
469:             IF( KSTEP.EQ.1 ) THEN
470: *
471: *              1-by-1 pivot block D(k): column k now holds
472: *
473: *              W(k) = L(k)*D(k)
474: *
475: *              where L(k) is the k-th column of L
476: *
477:                IF( K.LT.N ) THEN
478: *
479: *                 Perform a rank-1 update of A(k+1:n,k+1:n) as
480: *
481: *                 A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
482: *
483:                   R1 = CONE / AP( KC )
484:                   CALL CSPR( UPLO, N-K, -R1, AP( KC+1 ), 1,
485:      $                       AP( KC+N-K+1 ) )
486: *
487: *                 Store L(k) in column K
488: *
489:                   CALL CSCAL( N-K, R1, AP( KC+1 ), 1 )
490:                END IF
491:             ELSE
492: *
493: *              2-by-2 pivot block D(k): columns K and K+1 now hold
494: *
495: *              ( W(k) W(k+1) ) = ( L(k) L(k+1) )*D(k)
496: *
497: *              where L(k) and L(k+1) are the k-th and (k+1)-th columns
498: *              of L
499: *
500:                IF( K.LT.N-1 ) THEN
501: *
502: *                 Perform a rank-2 update of A(k+2:n,k+2:n) as
503: *
504: *                 A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
505: *                    = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
506: *
507: *                 where L(k) and L(k+1) are the k-th and (k+1)-th
508: *                 columns of L
509: *
510:                   D21 = AP( K+1+( K-1 )*( 2*N-K ) / 2 )
511:                   D11 = AP( K+1+K*( 2*N-K-1 ) / 2 ) / D21
512:                   D22 = AP( K+( K-1 )*( 2*N-K ) / 2 ) / D21
513:                   T = CONE / ( D11*D22-CONE )
514:                   D21 = T / D21
515: *
516:                   DO 100 J = K + 2, N
517:                      WK = D21*( D11*AP( J+( K-1 )*( 2*N-K ) / 2 )-
518:      $                    AP( J+K*( 2*N-K-1 ) / 2 ) )
519:                      WKP1 = D21*( D22*AP( J+K*( 2*N-K-1 ) / 2 )-
520:      $                      AP( J+( K-1 )*( 2*N-K ) / 2 ) )
521:                      DO 90 I = J, N
522:                         AP( I+( J-1 )*( 2*N-J ) / 2 ) = AP( I+( J-1 )*
523:      $                     ( 2*N-J ) / 2 ) - AP( I+( K-1 )*( 2*N-K ) /
524:      $                     2 )*WK - AP( I+K*( 2*N-K-1 ) / 2 )*WKP1
525:    90                CONTINUE
526:                      AP( J+( K-1 )*( 2*N-K ) / 2 ) = WK
527:                      AP( J+K*( 2*N-K-1 ) / 2 ) = WKP1
528:   100             CONTINUE
529:                END IF
530:             END IF
531:          END IF
532: *
533: *        Store details of the interchanges in IPIV
534: *
535:          IF( KSTEP.EQ.1 ) THEN
536:             IPIV( K ) = KP
537:          ELSE
538:             IPIV( K ) = -KP
539:             IPIV( K+1 ) = -KP
540:          END IF
541: *
542: *        Increase K and return to the start of the main loop
543: *
544:          K = K + KSTEP
545:          KC = KNC + N - K + 2
546:          GO TO 60
547: *
548:       END IF
549: *
550:   110 CONTINUE
551:       RETURN
552: *
553: *     End of CSPTRF
554: *
555:       END
556: