LAPACK  3.6.1
LAPACK: Linear Algebra PACKage
zlasyf.f
Go to the documentation of this file.
1 *> \brief \b ZLASYF computes a partial factorization of a complex symmetric matrix using the Bunch-Kaufman diagonal pivoting method.
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
9 *> Download ZLASYF + dependencies
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zlasyf.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zlasyf.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlasyf.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE ZLASYF( UPLO, N, NB, KB, A, LDA, IPIV, W, LDW, INFO )
22 *
23 * .. Scalar Arguments ..
24 * CHARACTER UPLO
25 * INTEGER INFO, KB, LDA, LDW, N, NB
26 * ..
27 * .. Array Arguments ..
28 * INTEGER IPIV( * )
29 * COMPLEX*16 A( LDA, * ), W( LDW, * )
30 * ..
31 *
32 *
33 *> \par Purpose:
34 * =============
35 *>
36 *> \verbatim
37 *>
38 *> ZLASYF computes a partial factorization of a complex symmetric matrix
39 *> A using the Bunch-Kaufman diagonal pivoting method. The partial
40 *> factorization has the form:
41 *>
42 *> A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
43 *> ( 0 U22 ) ( 0 D ) ( U12**T U22**T )
44 *>
45 *> A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L'
46 *> ( L21 I ) ( 0 A22 ) ( 0 I )
47 *>
48 *> where the order of D is at most NB. The actual order is returned in
49 *> the argument KB, and is either NB or NB-1, or N if N <= NB.
50 *> Note that U**T denotes the transpose of U.
51 *>
52 *> ZLASYF is an auxiliary routine called by ZSYTRF. It uses blocked code
53 *> (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or
54 *> A22 (if UPLO = 'L').
55 *> \endverbatim
56 *
57 * Arguments:
58 * ==========
59 *
60 *> \param[in] UPLO
61 *> \verbatim
62 *> UPLO is CHARACTER*1
63 *> Specifies whether the upper or lower triangular part of the
64 *> symmetric matrix A is stored:
65 *> = 'U': Upper triangular
66 *> = 'L': Lower triangular
67 *> \endverbatim
68 *>
69 *> \param[in] N
70 *> \verbatim
71 *> N is INTEGER
72 *> The order of the matrix A. N >= 0.
73 *> \endverbatim
74 *>
75 *> \param[in] NB
76 *> \verbatim
77 *> NB is INTEGER
78 *> The maximum number of columns of the matrix A that should be
79 *> factored. NB should be at least 2 to allow for 2-by-2 pivot
80 *> blocks.
81 *> \endverbatim
82 *>
83 *> \param[out] KB
84 *> \verbatim
85 *> KB is INTEGER
86 *> The number of columns of A that were actually factored.
87 *> KB is either NB-1 or NB, or N if N <= NB.
88 *> \endverbatim
89 *>
90 *> \param[in,out] A
91 *> \verbatim
92 *> A is COMPLEX*16 array, dimension (LDA,N)
93 *> On entry, the symmetric matrix A. If UPLO = 'U', the leading
94 *> n-by-n upper triangular part of A contains the upper
95 *> triangular part of the matrix A, and the strictly lower
96 *> triangular part of A is not referenced. If UPLO = 'L', the
97 *> leading n-by-n lower triangular part of A contains the lower
98 *> triangular part of the matrix A, and the strictly upper
99 *> triangular part of A is not referenced.
100 *> On exit, A contains details of the partial factorization.
101 *> \endverbatim
102 *>
103 *> \param[in] LDA
104 *> \verbatim
105 *> LDA is INTEGER
106 *> The leading dimension of the array A. LDA >= max(1,N).
107 *> \endverbatim
108 *>
109 *> \param[out] IPIV
110 *> \verbatim
111 *> IPIV is INTEGER array, dimension (N)
112 *> Details of the interchanges and the block structure of D.
113 *>
114 *> If UPLO = 'U':
115 *> Only the last KB elements of IPIV are set.
116 *>
117 *> If IPIV(k) > 0, then rows and columns k and IPIV(k) were
118 *> interchanged and D(k,k) is a 1-by-1 diagonal block.
119 *>
120 *> If IPIV(k) = IPIV(k-1) < 0, then rows and columns
121 *> k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)
122 *> is a 2-by-2 diagonal block.
123 *>
124 *> If UPLO = 'L':
125 *> Only the first KB elements of IPIV are set.
126 *>
127 *> If IPIV(k) > 0, then rows and columns k and IPIV(k) were
128 *> interchanged and D(k,k) is a 1-by-1 diagonal block.
129 *>
130 *> If IPIV(k) = IPIV(k+1) < 0, then rows and columns
131 *> k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)
132 *> is a 2-by-2 diagonal block.
133 *> \endverbatim
134 *>
135 *> \param[out] W
136 *> \verbatim
137 *> W is COMPLEX*16 array, dimension (LDW,NB)
138 *> \endverbatim
139 *>
140 *> \param[in] LDW
141 *> \verbatim
142 *> LDW is INTEGER
143 *> The leading dimension of the array W. LDW >= max(1,N).
144 *> \endverbatim
145 *>
146 *> \param[out] INFO
147 *> \verbatim
148 *> INFO is INTEGER
149 *> = 0: successful exit
150 *> > 0: if INFO = k, D(k,k) is exactly zero. The factorization
151 *> has been completed, but the block diagonal matrix D is
152 *> exactly singular.
153 *> \endverbatim
154 *
155 * Authors:
156 * ========
157 *
158 *> \author Univ. of Tennessee
159 *> \author Univ. of California Berkeley
160 *> \author Univ. of Colorado Denver
161 *> \author NAG Ltd.
162 *
163 *> \date November 2013
164 *
165 *> \ingroup complex16SYcomputational
166 *
167 *> \par Contributors:
168 * ==================
169 *>
170 *> \verbatim
171 *>
172 *> November 2013, Igor Kozachenko,
173 *> Computer Science Division,
174 *> University of California, Berkeley
175 *> \endverbatim
176 *
177 * =====================================================================
178  SUBROUTINE zlasyf( UPLO, N, NB, KB, A, LDA, IPIV, W, LDW, INFO )
179 *
180 * -- LAPACK computational routine (version 3.5.0) --
181 * -- LAPACK is a software package provided by Univ. of Tennessee, --
182 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
183 * November 2013
184 *
185 * .. Scalar Arguments ..
186  CHARACTER UPLO
187  INTEGER INFO, KB, LDA, LDW, N, NB
188 * ..
189 * .. Array Arguments ..
190  INTEGER IPIV( * )
191  COMPLEX*16 A( lda, * ), W( ldw, * )
192 * ..
193 *
194 * =====================================================================
195 *
196 * .. Parameters ..
197  DOUBLE PRECISION ZERO, ONE
198  parameter ( zero = 0.0d+0, one = 1.0d+0 )
199  DOUBLE PRECISION EIGHT, SEVTEN
200  parameter ( eight = 8.0d+0, sevten = 17.0d+0 )
201  COMPLEX*16 CONE
202  parameter ( cone = ( 1.0d+0, 0.0d+0 ) )
203 * ..
204 * .. Local Scalars ..
205  INTEGER IMAX, J, JB, JJ, JMAX, JP, K, KK, KKW, KP,
206  $ kstep, kw
207  DOUBLE PRECISION ABSAKK, ALPHA, COLMAX, ROWMAX
208  COMPLEX*16 D11, D21, D22, R1, T, Z
209 * ..
210 * .. External Functions ..
211  LOGICAL LSAME
212  INTEGER IZAMAX
213  EXTERNAL lsame, izamax
214 * ..
215 * .. External Subroutines ..
216  EXTERNAL zcopy, zgemm, zgemv, zscal, zswap
217 * ..
218 * .. Intrinsic Functions ..
219  INTRINSIC abs, dble, dimag, max, min, sqrt
220 * ..
221 * .. Statement Functions ..
222  DOUBLE PRECISION CABS1
223 * ..
224 * .. Statement Function definitions ..
225  cabs1( z ) = abs( dble( z ) ) + abs( dimag( z ) )
226 * ..
227 * .. Executable Statements ..
228 *
229  info = 0
230 *
231 * Initialize ALPHA for use in choosing pivot block size.
232 *
233  alpha = ( one+sqrt( sevten ) ) / eight
234 *
235  IF( lsame( uplo, 'U' ) ) THEN
236 *
237 * Factorize the trailing columns of A using the upper triangle
238 * of A and working backwards, and compute the matrix W = U12*D
239 * for use in updating A11
240 *
241 * K is the main loop index, decreasing from N in steps of 1 or 2
242 *
243 * KW is the column of W which corresponds to column K of A
244 *
245  k = n
246  10 CONTINUE
247  kw = nb + k - n
248 *
249 * Exit from loop
250 *
251  IF( ( k.LE.n-nb+1 .AND. nb.LT.n ) .OR. k.LT.1 )
252  $ GO TO 30
253 *
254 * Copy column K of A to column KW of W and update it
255 *
256  CALL zcopy( k, a( 1, k ), 1, w( 1, kw ), 1 )
257  IF( k.LT.n )
258  $ CALL zgemv( 'No transpose', k, n-k, -cone, a( 1, k+1 ), lda,
259  $ w( k, kw+1 ), ldw, cone, w( 1, kw ), 1 )
260 *
261  kstep = 1
262 *
263 * Determine rows and columns to be interchanged and whether
264 * a 1-by-1 or 2-by-2 pivot block will be used
265 *
266  absakk = cabs1( w( k, kw ) )
267 *
268 * IMAX is the row-index of the largest off-diagonal element in
269 
270 *
271  IF( k.GT.1 ) THEN
272  imax = izamax( k-1, w( 1, kw ), 1 )
273  colmax = cabs1( w( imax, kw ) )
274  ELSE
275  colmax = zero
276  END IF
277 *
278  IF( max( absakk, colmax ).EQ.zero ) THEN
279 *
280 * Column K is zero or underflow: set INFO and continue
281 *
282  IF( info.EQ.0 )
283  $ info = k
284  kp = k
285  ELSE
286  IF( absakk.GE.alpha*colmax ) THEN
287 *
288 * no interchange, use 1-by-1 pivot block
289 *
290  kp = k
291  ELSE
292 *
293 * Copy column IMAX to column KW-1 of W and update it
294 *
295  CALL zcopy( imax, a( 1, imax ), 1, w( 1, kw-1 ), 1 )
296  CALL zcopy( k-imax, a( imax, imax+1 ), lda,
297  $ w( imax+1, kw-1 ), 1 )
298  IF( k.LT.n )
299  $ CALL zgemv( 'No transpose', k, n-k, -cone,
300  $ a( 1, k+1 ), lda, w( imax, kw+1 ), ldw,
301  $ cone, w( 1, kw-1 ), 1 )
302 *
303 * JMAX is the column-index of the largest off-diagonal
304 * element in row IMAX, and ROWMAX is its absolute value
305 *
306  jmax = imax + izamax( k-imax, w( imax+1, kw-1 ), 1 )
307  rowmax = cabs1( w( jmax, kw-1 ) )
308  IF( imax.GT.1 ) THEN
309  jmax = izamax( imax-1, w( 1, kw-1 ), 1 )
310  rowmax = max( rowmax, cabs1( w( jmax, kw-1 ) ) )
311  END IF
312 *
313  IF( absakk.GE.alpha*colmax*( colmax / rowmax ) ) THEN
314 *
315 * no interchange, use 1-by-1 pivot block
316 *
317  kp = k
318  ELSE IF( cabs1( w( imax, kw-1 ) ).GE.alpha*rowmax ) THEN
319 *
320 * interchange rows and columns K and IMAX, use 1-by-1
321 * pivot block
322 *
323  kp = imax
324 *
325 * copy column KW-1 of W to column KW of W
326 *
327  CALL zcopy( k, w( 1, kw-1 ), 1, w( 1, kw ), 1 )
328  ELSE
329 *
330 * interchange rows and columns K-1 and IMAX, use 2-by-2
331 * pivot block
332 *
333  kp = imax
334  kstep = 2
335  END IF
336  END IF
337 *
338 * ============================================================
339 *
340 * KK is the column of A where pivoting step stopped
341 *
342  kk = k - kstep + 1
343 *
344 * KKW is the column of W which corresponds to column KK of A
345 *
346  kkw = nb + kk - n
347 *
348 * Interchange rows and columns KP and KK.
349 * Updated column KP is already stored in column KKW of W.
350 *
351  IF( kp.NE.kk ) THEN
352 *
353 * Copy non-updated column KK to column KP of submatrix A
354 * at step K. No need to copy element into column K
355 * (or K and K-1 for 2-by-2 pivot) of A, since these columns
356 * will be later overwritten.
357 *
358  a( kp, kp ) = a( kk, kk )
359  CALL zcopy( kk-1-kp, a( kp+1, kk ), 1, a( kp, kp+1 ),
360  $ lda )
361  IF( kp.GT.1 )
362  $ CALL zcopy( kp-1, a( 1, kk ), 1, a( 1, kp ), 1 )
363 *
364 * Interchange rows KK and KP in last K+1 to N columns of A
365 * (columns K (or K and K-1 for 2-by-2 pivot) of A will be
366 * later overwritten). Interchange rows KK and KP
367 * in last KKW to NB columns of W.
368 *
369  IF( k.LT.n )
370  $ CALL zswap( n-k, a( kk, k+1 ), lda, a( kp, k+1 ),
371  $ lda )
372  CALL zswap( n-kk+1, w( kk, kkw ), ldw, w( kp, kkw ),
373  $ ldw )
374  END IF
375 *
376  IF( kstep.EQ.1 ) THEN
377 *
378 * 1-by-1 pivot block D(k): column kw of W now holds
379 *
380 * W(kw) = U(k)*D(k),
381 *
382 * where U(k) is the k-th column of U
383 *
384 * Store subdiag. elements of column U(k)
385 * and 1-by-1 block D(k) in column k of A.
386 * NOTE: Diagonal element U(k,k) is a UNIT element
387 * and not stored.
388 * A(k,k) := D(k,k) = W(k,kw)
389 * A(1:k-1,k) := U(1:k-1,k) = W(1:k-1,kw)/D(k,k)
390 *
391  CALL zcopy( k, w( 1, kw ), 1, a( 1, k ), 1 )
392  r1 = cone / a( k, k )
393  CALL zscal( k-1, r1, a( 1, k ), 1 )
394 *
395  ELSE
396 *
397 * 2-by-2 pivot block D(k): columns kw and kw-1 of W now hold
398 *
399 * ( W(kw-1) W(kw) ) = ( U(k-1) U(k) )*D(k)
400 *
401 * where U(k) and U(k-1) are the k-th and (k-1)-th columns
402 * of U
403 *
404 * Store U(1:k-2,k-1) and U(1:k-2,k) and 2-by-2
405 * block D(k-1:k,k-1:k) in columns k-1 and k of A.
406 * NOTE: 2-by-2 diagonal block U(k-1:k,k-1:k) is a UNIT
407 * block and not stored.
408 * A(k-1:k,k-1:k) := D(k-1:k,k-1:k) = W(k-1:k,kw-1:kw)
409 * A(1:k-2,k-1:k) := U(1:k-2,k:k-1:k) =
410 * = W(1:k-2,kw-1:kw) * ( D(k-1:k,k-1:k)**(-1) )
411 *
412  IF( k.GT.2 ) THEN
413 *
414 * Compose the columns of the inverse of 2-by-2 pivot
415 * block D in the following way to reduce the number
416 * of FLOPS when we myltiply panel ( W(kw-1) W(kw) ) by
417 * this inverse
418 *
419 * D**(-1) = ( d11 d21 )**(-1) =
420 * ( d21 d22 )
421 *
422 * = 1/(d11*d22-d21**2) * ( ( d22 ) (-d21 ) ) =
423 * ( (-d21 ) ( d11 ) )
424 *
425 * = 1/d21 * 1/((d11/d21)*(d22/d21)-1) *
426 *
427 * * ( ( d22/d21 ) ( -1 ) ) =
428 * ( ( -1 ) ( d11/d21 ) )
429 *
430 * = 1/d21 * 1/(D22*D11-1) * ( ( D11 ) ( -1 ) ) =
431 * ( ( -1 ) ( D22 ) )
432 *
433 * = 1/d21 * T * ( ( D11 ) ( -1 ) )
434 * ( ( -1 ) ( D22 ) )
435 *
436 * = D21 * ( ( D11 ) ( -1 ) )
437 * ( ( -1 ) ( D22 ) )
438 *
439  d21 = w( k-1, kw )
440  d11 = w( k, kw ) / d21
441  d22 = w( k-1, kw-1 ) / d21
442  t = cone / ( d11*d22-cone )
443  d21 = t / d21
444 *
445 * Update elements in columns A(k-1) and A(k) as
446 * dot products of rows of ( W(kw-1) W(kw) ) and columns
447 * of D**(-1)
448 *
449  DO 20 j = 1, k - 2
450  a( j, k-1 ) = d21*( d11*w( j, kw-1 )-w( j, kw ) )
451  a( j, k ) = d21*( d22*w( j, kw )-w( j, kw-1 ) )
452  20 CONTINUE
453  END IF
454 *
455 * Copy D(k) to A
456 *
457  a( k-1, k-1 ) = w( k-1, kw-1 )
458  a( k-1, k ) = w( k-1, kw )
459  a( k, k ) = w( k, kw )
460 *
461  END IF
462 *
463  END IF
464 *
465 * Store details of the interchanges in IPIV
466 *
467  IF( kstep.EQ.1 ) THEN
468  ipiv( k ) = kp
469  ELSE
470  ipiv( k ) = -kp
471  ipiv( k-1 ) = -kp
472  END IF
473 *
474 * Decrease K and return to the start of the main loop
475 *
476  k = k - kstep
477  GO TO 10
478 *
479  30 CONTINUE
480 *
481 * Update the upper triangle of A11 (= A(1:k,1:k)) as
482 *
483 * A11 := A11 - U12*D*U12**T = A11 - U12*W**T
484 *
485 * computing blocks of NB columns at a time
486 *
487  DO 50 j = ( ( k-1 ) / nb )*nb + 1, 1, -nb
488  jb = min( nb, k-j+1 )
489 *
490 * Update the upper triangle of the diagonal block
491 *
492  DO 40 jj = j, j + jb - 1
493  CALL zgemv( 'No transpose', jj-j+1, n-k, -cone,
494  $ a( j, k+1 ), lda, w( jj, kw+1 ), ldw, cone,
495  $ a( j, jj ), 1 )
496  40 CONTINUE
497 *
498 * Update the rectangular superdiagonal block
499 *
500  CALL zgemm( 'No transpose', 'Transpose', j-1, jb, n-k,
501  $ -cone, a( 1, k+1 ), lda, w( j, kw+1 ), ldw,
502  $ cone, a( 1, j ), lda )
503  50 CONTINUE
504 *
505 * Put U12 in standard form by partially undoing the interchanges
506 * in columns k+1:n looping backwards from k+1 to n
507 *
508  j = k + 1
509  60 CONTINUE
510 *
511 * Undo the interchanges (if any) of rows JJ and JP at each
512 * step J
513 *
514 * (Here, J is a diagonal index)
515  jj = j
516  jp = ipiv( j )
517  IF( jp.LT.0 ) THEN
518  jp = -jp
519 * (Here, J is a diagonal index)
520  j = j + 1
521  END IF
522 * (NOTE: Here, J is used to determine row length. Length N-J+1
523 * of the rows to swap back doesn't include diagonal element)
524  j = j + 1
525  IF( jp.NE.jj .AND. j.LE.n )
526  $ CALL zswap( n-j+1, a( jp, j ), lda, a( jj, j ), lda )
527  IF( j.LT.n )
528  $ GO TO 60
529 *
530 * Set KB to the number of columns factorized
531 *
532  kb = n - k
533 *
534  ELSE
535 *
536 * Factorize the leading columns of A using the lower triangle
537 * of A and working forwards, and compute the matrix W = L21*D
538 * for use in updating A22
539 *
540 * K is the main loop index, increasing from 1 in steps of 1 or 2
541 *
542  k = 1
543  70 CONTINUE
544 *
545 * Exit from loop
546 *
547  IF( ( k.GE.nb .AND. nb.LT.n ) .OR. k.GT.n )
548  $ GO TO 90
549 *
550 * Copy column K of A to column K of W and update it
551 *
552  CALL zcopy( n-k+1, a( k, k ), 1, w( k, k ), 1 )
553  CALL zgemv( 'No transpose', n-k+1, k-1, -cone, a( k, 1 ), lda,
554  $ w( k, 1 ), ldw, cone, w( k, k ), 1 )
555 *
556  kstep = 1
557 *
558 * Determine rows and columns to be interchanged and whether
559 * a 1-by-1 or 2-by-2 pivot block will be used
560 *
561  absakk = cabs1( w( k, k ) )
562 *
563 * IMAX is the row-index of the largest off-diagonal element in
564 
565 *
566  IF( k.LT.n ) THEN
567  imax = k + izamax( n-k, w( k+1, k ), 1 )
568  colmax = cabs1( w( imax, k ) )
569  ELSE
570  colmax = zero
571  END IF
572 *
573  IF( max( absakk, colmax ).EQ.zero ) THEN
574 *
575 * Column K is zero or underflow: set INFO and continue
576 *
577  IF( info.EQ.0 )
578  $ info = k
579  kp = k
580  ELSE
581  IF( absakk.GE.alpha*colmax ) THEN
582 *
583 * no interchange, use 1-by-1 pivot block
584 *
585  kp = k
586  ELSE
587 *
588 * Copy column IMAX to column K+1 of W and update it
589 *
590  CALL zcopy( imax-k, a( imax, k ), lda, w( k, k+1 ), 1 )
591  CALL zcopy( n-imax+1, a( imax, imax ), 1, w( imax, k+1 ),
592  $ 1 )
593  CALL zgemv( 'No transpose', n-k+1, k-1, -cone, a( k, 1 ),
594  $ lda, w( imax, 1 ), ldw, cone, w( k, k+1 ),
595  $ 1 )
596 *
597 * JMAX is the column-index of the largest off-diagonal
598 * element in row IMAX, and ROWMAX is its absolute value
599 *
600  jmax = k - 1 + izamax( imax-k, w( k, k+1 ), 1 )
601  rowmax = cabs1( w( jmax, k+1 ) )
602  IF( imax.LT.n ) THEN
603  jmax = imax + izamax( n-imax, w( imax+1, k+1 ), 1 )
604  rowmax = max( rowmax, cabs1( w( jmax, k+1 ) ) )
605  END IF
606 *
607  IF( absakk.GE.alpha*colmax*( colmax / rowmax ) ) THEN
608 *
609 * no interchange, use 1-by-1 pivot block
610 *
611  kp = k
612  ELSE IF( cabs1( w( imax, k+1 ) ).GE.alpha*rowmax ) THEN
613 *
614 * interchange rows and columns K and IMAX, use 1-by-1
615 * pivot block
616 *
617  kp = imax
618 *
619 * copy column K+1 of W to column K of W
620 *
621  CALL zcopy( n-k+1, w( k, k+1 ), 1, w( k, k ), 1 )
622  ELSE
623 *
624 * interchange rows and columns K+1 and IMAX, use 2-by-2
625 * pivot block
626 *
627  kp = imax
628  kstep = 2
629  END IF
630  END IF
631 *
632 * ============================================================
633 *
634 * KK is the column of A where pivoting step stopped
635 *
636  kk = k + kstep - 1
637 *
638 * Interchange rows and columns KP and KK.
639 * Updated column KP is already stored in column KK of W.
640 *
641  IF( kp.NE.kk ) THEN
642 *
643 * Copy non-updated column KK to column KP of submatrix A
644 * at step K. No need to copy element into column K
645 * (or K and K+1 for 2-by-2 pivot) of A, since these columns
646 * will be later overwritten.
647 *
648  a( kp, kp ) = a( kk, kk )
649  CALL zcopy( kp-kk-1, a( kk+1, kk ), 1, a( kp, kk+1 ),
650  $ lda )
651  IF( kp.LT.n )
652  $ CALL zcopy( n-kp, a( kp+1, kk ), 1, a( kp+1, kp ), 1 )
653 *
654 * Interchange rows KK and KP in first K-1 columns of A
655 * (columns K (or K and K+1 for 2-by-2 pivot) of A will be
656 * later overwritten). Interchange rows KK and KP
657 * in first KK columns of W.
658 *
659  IF( k.GT.1 )
660  $ CALL zswap( k-1, a( kk, 1 ), lda, a( kp, 1 ), lda )
661  CALL zswap( kk, w( kk, 1 ), ldw, w( kp, 1 ), ldw )
662  END IF
663 *
664  IF( kstep.EQ.1 ) THEN
665 *
666 * 1-by-1 pivot block D(k): column k of W now holds
667 *
668 * W(k) = L(k)*D(k),
669 *
670 * where L(k) is the k-th column of L
671 *
672 * Store subdiag. elements of column L(k)
673 * and 1-by-1 block D(k) in column k of A.
674 * (NOTE: Diagonal element L(k,k) is a UNIT element
675 * and not stored)
676 * A(k,k) := D(k,k) = W(k,k)
677 * A(k+1:N,k) := L(k+1:N,k) = W(k+1:N,k)/D(k,k)
678 *
679  CALL zcopy( n-k+1, w( k, k ), 1, a( k, k ), 1 )
680  IF( k.LT.n ) THEN
681  r1 = cone / a( k, k )
682  CALL zscal( n-k, r1, a( k+1, k ), 1 )
683  END IF
684 *
685  ELSE
686 *
687 * 2-by-2 pivot block D(k): columns k and k+1 of W now hold
688 *
689 * ( W(k) W(k+1) ) = ( L(k) L(k+1) )*D(k)
690 *
691 * where L(k) and L(k+1) are the k-th and (k+1)-th columns
692 * of L
693 *
694 * Store L(k+2:N,k) and L(k+2:N,k+1) and 2-by-2
695 * block D(k:k+1,k:k+1) in columns k and k+1 of A.
696 * (NOTE: 2-by-2 diagonal block L(k:k+1,k:k+1) is a UNIT
697 * block and not stored)
698 * A(k:k+1,k:k+1) := D(k:k+1,k:k+1) = W(k:k+1,k:k+1)
699 * A(k+2:N,k:k+1) := L(k+2:N,k:k+1) =
700 * = W(k+2:N,k:k+1) * ( D(k:k+1,k:k+1)**(-1) )
701 *
702  IF( k.LT.n-1 ) THEN
703 *
704 * Compose the columns of the inverse of 2-by-2 pivot
705 * block D in the following way to reduce the number
706 * of FLOPS when we myltiply panel ( W(k) W(k+1) ) by
707 * this inverse
708 *
709 * D**(-1) = ( d11 d21 )**(-1) =
710 * ( d21 d22 )
711 *
712 * = 1/(d11*d22-d21**2) * ( ( d22 ) (-d21 ) ) =
713 * ( (-d21 ) ( d11 ) )
714 *
715 * = 1/d21 * 1/((d11/d21)*(d22/d21)-1) *
716 *
717 * * ( ( d22/d21 ) ( -1 ) ) =
718 * ( ( -1 ) ( d11/d21 ) )
719 *
720 * = 1/d21 * 1/(D22*D11-1) * ( ( D11 ) ( -1 ) ) =
721 * ( ( -1 ) ( D22 ) )
722 *
723 * = 1/d21 * T * ( ( D11 ) ( -1 ) )
724 * ( ( -1 ) ( D22 ) )
725 *
726 * = D21 * ( ( D11 ) ( -1 ) )
727 * ( ( -1 ) ( D22 ) )
728 *
729  d21 = w( k+1, k )
730  d11 = w( k+1, k+1 ) / d21
731  d22 = w( k, k ) / d21
732  t = cone / ( d11*d22-cone )
733  d21 = t / d21
734 *
735 * Update elements in columns A(k) and A(k+1) as
736 * dot products of rows of ( W(k) W(k+1) ) and columns
737 * of D**(-1)
738 *
739  DO 80 j = k + 2, n
740  a( j, k ) = d21*( d11*w( j, k )-w( j, k+1 ) )
741  a( j, k+1 ) = d21*( d22*w( j, k+1 )-w( j, k ) )
742  80 CONTINUE
743  END IF
744 *
745 * Copy D(k) to A
746 *
747  a( k, k ) = w( k, k )
748  a( k+1, k ) = w( k+1, k )
749  a( k+1, k+1 ) = w( k+1, k+1 )
750 *
751  END IF
752 *
753  END IF
754 *
755 * Store details of the interchanges in IPIV
756 *
757  IF( kstep.EQ.1 ) THEN
758  ipiv( k ) = kp
759  ELSE
760  ipiv( k ) = -kp
761  ipiv( k+1 ) = -kp
762  END IF
763 *
764 * Increase K and return to the start of the main loop
765 *
766  k = k + kstep
767  GO TO 70
768 *
769  90 CONTINUE
770 *
771 * Update the lower triangle of A22 (= A(k:n,k:n)) as
772 *
773 * A22 := A22 - L21*D*L21**T = A22 - L21*W**T
774 *
775 * computing blocks of NB columns at a time
776 *
777  DO 110 j = k, n, nb
778  jb = min( nb, n-j+1 )
779 *
780 * Update the lower triangle of the diagonal block
781 *
782  DO 100 jj = j, j + jb - 1
783  CALL zgemv( 'No transpose', j+jb-jj, k-1, -cone,
784  $ a( jj, 1 ), lda, w( jj, 1 ), ldw, cone,
785  $ a( jj, jj ), 1 )
786  100 CONTINUE
787 *
788 * Update the rectangular subdiagonal block
789 *
790  IF( j+jb.LE.n )
791  $ CALL zgemm( 'No transpose', 'Transpose', n-j-jb+1, jb,
792  $ k-1, -cone, a( j+jb, 1 ), lda, w( j, 1 ),
793  $ ldw, cone, a( j+jb, j ), lda )
794  110 CONTINUE
795 *
796 * Put L21 in standard form by partially undoing the interchanges
797 * of rows in columns 1:k-1 looping backwards from k-1 to 1
798 *
799  j = k - 1
800  120 CONTINUE
801 *
802 * Undo the interchanges (if any) of rows JJ and JP at each
803 * step J
804 *
805 * (Here, J is a diagonal index)
806  jj = j
807  jp = ipiv( j )
808  IF( jp.LT.0 ) THEN
809  jp = -jp
810 * (Here, J is a diagonal index)
811  j = j - 1
812  END IF
813 * (NOTE: Here, J is used to determine row length. Length J
814 * of the rows to swap back doesn't include diagonal element)
815  j = j - 1
816  IF( jp.NE.jj .AND. j.GE.1 )
817  $ CALL zswap( j, a( jp, 1 ), lda, a( jj, 1 ), lda )
818  IF( j.GT.1 )
819  $ GO TO 120
820 *
821 * Set KB to the number of columns factorized
822 *
823  kb = k - 1
824 *
825  END IF
826  RETURN
827 *
828 * End of ZLASYF
829 *
830  END
zcopy
subroutine zcopy(N, ZX, INCX, ZY, INCY)
ZCOPY
Definition: zcopy.f:52
zlasyf
subroutine zlasyf(UPLO, N, NB, KB, A, LDA, IPIV, W, LDW, INFO)
ZLASYF computes a partial factorization of a complex symmetric matrix using the Bunch-Kaufman diagona...
Definition: zlasyf.f:179
zgemv
subroutine zgemv(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
ZGEMV
Definition: zgemv.f:160
zswap
subroutine zswap(N, ZX, INCX, ZY, INCY)
ZSWAP
Definition: zswap.f:52
zgemm
subroutine zgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
ZGEMM
Definition: zgemm.f:189
zscal
subroutine zscal(N, ZA, ZX, INCX)
ZSCAL
Definition: zscal.f:54