LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ zsytrf_rook()

subroutine zsytrf_rook ( character  UPLO,
integer  N,
complex*16, dimension( lda, * )  A,
integer  LDA,
integer, dimension( * )  IPIV,
complex*16, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

ZSYTRF_ROOK

Download ZSYTRF_ROOK + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 ZSYTRF_ROOK computes the factorization of a complex symmetric matrix A
 using the bounded Bunch-Kaufman ("rook") diagonal pivoting method.
 The form of the factorization is

    A = U*D*U**T  or  A = L*D*L**T

 where U (or L) is a product of permutation and unit upper (lower)
 triangular matrices, and D is symmetric and block diagonal with
 1-by-1 and 2-by-2 diagonal blocks.

 This is the blocked version of the algorithm, calling Level 3 BLAS.
Parameters
[in]UPLO
          UPLO is CHARACTER*1
          = 'U':  Upper triangle of A is stored;
          = 'L':  Lower triangle of A is stored.
[in]N
          N is INTEGER
          The order of the matrix A.  N >= 0.
[in,out]A
          A is COMPLEX*16 array, dimension (LDA,N)
          On entry, the symmetric matrix A.  If UPLO = 'U', the leading
          N-by-N upper triangular part of A contains the upper
          triangular part of the matrix A, and the strictly lower
          triangular part of A is not referenced.  If UPLO = 'L', the
          leading N-by-N lower triangular part of A contains the lower
          triangular part of the matrix A, and the strictly upper
          triangular part of A is not referenced.

          On exit, the block diagonal matrix D and the multipliers used
          to obtain the factor U or L (see below for further details).
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).
[out]IPIV
          IPIV is INTEGER array, dimension (N)
          Details of the interchanges and the block structure of D.

          If UPLO = 'U':
               If IPIV(k) > 0, then rows and columns k and IPIV(k)
               were interchanged and D(k,k) is a 1-by-1 diagonal block.

               If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
               columns k and -IPIV(k) were interchanged and rows and
               columns k-1 and -IPIV(k-1) were inerchaged,
               D(k-1:k,k-1:k) is a 2-by-2 diagonal block.

          If UPLO = 'L':
               If IPIV(k) > 0, then rows and columns k and IPIV(k)
               were interchanged and D(k,k) is a 1-by-1 diagonal block.

               If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
               columns k and -IPIV(k) were interchanged and rows and
               columns k+1 and -IPIV(k+1) were inerchaged,
               D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
[out]WORK
          WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)).
          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]LWORK
          LWORK is INTEGER
          The length of WORK.  LWORK >=1.  For best performance
          LWORK >= N*NB, where NB is the block size returned by ILAENV.

          If LWORK = -1, then a workspace query is assumed; the routine
          only calculates the optimal size of the WORK array, returns
          this value as the first entry of the WORK array, and no error
          message related to LWORK is issued by XERBLA.
[out]INFO
          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value
          > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization
                has been completed, but the block diagonal matrix D is
                exactly singular, and division by zero will occur if it
                is used to solve a system of equations.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Further Details:
  If UPLO = 'U', then A = U*D*U**T, where
     U = P(n)*U(n)* ... *P(k)U(k)* ...,
  i.e., U is a product of terms P(k)*U(k), where k decreases from n to
  1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
  and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
  defined by IPIV(k), and U(k) is a unit upper triangular matrix, such
  that if the diagonal block D(k) is of order s (s = 1 or 2), then

             (   I    v    0   )   k-s
     U(k) =  (   0    I    0   )   s
             (   0    0    I   )   n-k
                k-s   s   n-k

  If s = 1, D(k) overwrites A(k,k), and v overwrites A(1:k-1,k).
  If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
  and A(k,k), and v overwrites A(1:k-2,k-1:k).

  If UPLO = 'L', then A = L*D*L**T, where
     L = P(1)*L(1)* ... *P(k)*L(k)* ...,
  i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
  n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
  and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
  defined by IPIV(k), and L(k) is a unit lower triangular matrix, such
  that if the diagonal block D(k) is of order s (s = 1 or 2), then

             (   I    0     0   )  k-1
     L(k) =  (   0    I     0   )  s
             (   0    v     I   )  n-k-s+1
                k-1   s  n-k-s+1

  If s = 1, D(k) overwrites A(k,k), and v overwrites A(k+1:n,k).
  If s = 2, the lower triangle of D(k) overwrites A(k,k), A(k+1,k),
  and A(k+1,k+1), and v overwrites A(k+2:n,k:k+1).
Contributors:
   June 2016, Igor Kozachenko,
                  Computer Science Division,
                  University of California, Berkeley

  September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
                  School of Mathematics,
                  University of Manchester

Definition at line 207 of file zsytrf_rook.f.

208 *
209 * -- LAPACK computational routine --
210 * -- LAPACK is a software package provided by Univ. of Tennessee, --
211 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
212 *
213 * .. Scalar Arguments ..
214  CHARACTER UPLO
215  INTEGER INFO, LDA, LWORK, N
216 * ..
217 * .. Array Arguments ..
218  INTEGER IPIV( * )
219  COMPLEX*16 A( LDA, * ), WORK( * )
220 * ..
221 *
222 * =====================================================================
223 *
224 * .. Local Scalars ..
225  LOGICAL LQUERY, UPPER
226  INTEGER IINFO, IWS, J, K, KB, LDWORK, LWKOPT, NB, NBMIN
227 * ..
228 * .. External Functions ..
229  LOGICAL LSAME
230  INTEGER ILAENV
231  EXTERNAL lsame, ilaenv
232 * ..
233 * .. External Subroutines ..
234  EXTERNAL zlasyf_rook, zsytf2_rook, xerbla
235 * ..
236 * .. Intrinsic Functions ..
237  INTRINSIC max
238 * ..
239 * .. Executable Statements ..
240 *
241 * Test the input parameters.
242 *
243  info = 0
244  upper = lsame( uplo, 'U' )
245  lquery = ( lwork.EQ.-1 )
246  IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
247  info = -1
248  ELSE IF( n.LT.0 ) THEN
249  info = -2
250  ELSE IF( lda.LT.max( 1, n ) ) THEN
251  info = -4
252  ELSE IF( lwork.LT.1 .AND. .NOT.lquery ) THEN
253  info = -7
254  END IF
255 *
256  IF( info.EQ.0 ) THEN
257 *
258 * Determine the block size
259 *
260  nb = ilaenv( 1, 'ZSYTRF_ROOK', uplo, n, -1, -1, -1 )
261  lwkopt = max( 1, n*nb )
262  work( 1 ) = lwkopt
263  END IF
264 *
265  IF( info.NE.0 ) THEN
266  CALL xerbla( 'ZSYTRF_ROOK', -info )
267  RETURN
268  ELSE IF( lquery ) THEN
269  RETURN
270  END IF
271 *
272  nbmin = 2
273  ldwork = n
274  IF( nb.GT.1 .AND. nb.LT.n ) THEN
275  iws = ldwork*nb
276  IF( lwork.LT.iws ) THEN
277  nb = max( lwork / ldwork, 1 )
278  nbmin = max( 2, ilaenv( 2, 'ZSYTRF_ROOK',
279  $ uplo, n, -1, -1, -1 ) )
280  END IF
281  ELSE
282  iws = 1
283  END IF
284  IF( nb.LT.nbmin )
285  $ nb = n
286 *
287  IF( upper ) THEN
288 *
289 * Factorize A as U*D*U**T using the upper triangle of A
290 *
291 * K is the main loop index, decreasing from N to 1 in steps of
292 * KB, where KB is the number of columns factorized by ZLASYF_ROOK;
293 * KB is either NB or NB-1, or K for the last block
294 *
295  k = n
296  10 CONTINUE
297 *
298 * If K < 1, exit from loop
299 *
300  IF( k.LT.1 )
301  $ GO TO 40
302 *
303  IF( k.GT.nb ) THEN
304 *
305 * Factorize columns k-kb+1:k of A and use blocked code to
306 * update columns 1:k-kb
307 *
308  CALL zlasyf_rook( uplo, k, nb, kb, a, lda,
309  $ ipiv, work, ldwork, iinfo )
310  ELSE
311 *
312 * Use unblocked code to factorize columns 1:k of A
313 *
314  CALL zsytf2_rook( uplo, k, a, lda, ipiv, iinfo )
315  kb = k
316  END IF
317 *
318 * Set INFO on the first occurrence of a zero pivot
319 *
320  IF( info.EQ.0 .AND. iinfo.GT.0 )
321  $ info = iinfo
322 *
323 * No need to adjust IPIV
324 *
325 * Decrease K and return to the start of the main loop
326 *
327  k = k - kb
328  GO TO 10
329 *
330  ELSE
331 *
332 * Factorize A as L*D*L**T using the lower triangle of A
333 *
334 * K is the main loop index, increasing from 1 to N in steps of
335 * KB, where KB is the number of columns factorized by ZLASYF_ROOK;
336 * KB is either NB or NB-1, or N-K+1 for the last block
337 *
338  k = 1
339  20 CONTINUE
340 *
341 * If K > N, exit from loop
342 *
343  IF( k.GT.n )
344  $ GO TO 40
345 *
346  IF( k.LE.n-nb ) THEN
347 *
348 * Factorize columns k:k+kb-1 of A and use blocked code to
349 * update columns k+kb:n
350 *
351  CALL zlasyf_rook( uplo, n-k+1, nb, kb, a( k, k ), lda,
352  $ ipiv( k ), work, ldwork, iinfo )
353  ELSE
354 *
355 * Use unblocked code to factorize columns k:n of A
356 *
357  CALL zsytf2_rook( uplo, n-k+1, a( k, k ), lda, ipiv( k ),
358  $ iinfo )
359  kb = n - k + 1
360  END IF
361 *
362 * Set INFO on the first occurrence of a zero pivot
363 *
364  IF( info.EQ.0 .AND. iinfo.GT.0 )
365  $ info = iinfo + k - 1
366 *
367 * Adjust IPIV
368 *
369  DO 30 j = k, k + kb - 1
370  IF( ipiv( j ).GT.0 ) THEN
371  ipiv( j ) = ipiv( j ) + k - 1
372  ELSE
373  ipiv( j ) = ipiv( j ) - k + 1
374  END IF
375  30 CONTINUE
376 *
377 * Increase K and return to the start of the main loop
378 *
379  k = k + kb
380  GO TO 20
381 *
382  END IF
383 *
384  40 CONTINUE
385  work( 1 ) = lwkopt
386  RETURN
387 *
388 * End of ZSYTRF_ROOK
389 *
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine zlasyf_rook(UPLO, N, NB, KB, A, LDA, IPIV, W, LDW, INFO)
ZLASYF_ROOK computes a partial factorization of a complex symmetric matrix using the bounded Bunch-Ka...
Definition: zlasyf_rook.f:184
subroutine zsytf2_rook(UPLO, N, A, LDA, IPIV, INFO)
ZSYTF2_ROOK computes the factorization of a complex symmetric indefinite matrix using the bounded Bun...
Definition: zsytf2_rook.f:194
Here is the call graph for this function:
Here is the caller graph for this function: