LAPACK 3.12.1
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ ssytrd_2stage()

subroutine ssytrd_2stage ( character vect,
character uplo,
integer n,
real, dimension( lda, * ) a,
integer lda,
real, dimension( * ) d,
real, dimension( * ) e,
real, dimension( * ) tau,
real, dimension( * ) hous2,
integer lhous2,
real, dimension( * ) work,
integer lwork,
integer info )

SSYTRD_2STAGE

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

Purpose:
!>
!> SSYTRD_2STAGE reduces a real symmetric matrix A to real symmetric
!> tridiagonal form T by a orthogonal similarity transformation:
!> Q1**T Q2**T* A * Q2 * Q1 = T.
!>
Parameters
[in]VECT
!>          VECT is CHARACTER*1
!>          = 'N':  No need for the Housholder representation,
!>                  in particular for the second stage (Band to
!>                  tridiagonal) and thus LHOUS2 is of size max(1, 4*N);
!>          = 'V':  the Householder representation is needed to
!>                  either generate Q1 Q2 or to apply Q1 Q2,
!>                  then LHOUS2 is to be queried and computed.
!>                  (NOT AVAILABLE IN THIS RELEASE).
!>
[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 REAL 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, if UPLO = 'U', the band superdiagonal
!>          of A are overwritten by the corresponding elements of the
!>          internal band-diagonal matrix AB, and the elements above
!>          the KD superdiagonal, with the array TAU, represent the orthogonal
!>          matrix Q1 as a product of elementary reflectors; if UPLO
!>          = 'L', the diagonal and band subdiagonal of A are over-
!>          written by the corresponding elements of the internal band-diagonal
!>          matrix AB, and the elements below the KD subdiagonal, with
!>          the array TAU, represent the orthogonal matrix Q1 as a product
!>          of elementary reflectors. See Further Details.
!>
[in]LDA
!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,N).
!>
[out]D
!>          D is REAL array, dimension (N)
!>          The diagonal elements of the tridiagonal matrix T.
!>
[out]E
!>          E is REAL array, dimension (N-1)
!>          The off-diagonal elements of the tridiagonal matrix T.
!>
[out]TAU
!>          TAU is REAL array, dimension (N-KD)
!>          The scalar factors of the elementary reflectors of
!>          the first stage (see Further Details).
!>
[out]HOUS2
!>          HOUS2 is REAL array, dimension (MAX(1,LHOUS2))
!>          Stores the Householder representation of the stage2
!>          band to tridiagonal.
!>
[in]LHOUS2
!>          LHOUS2 is INTEGER
!>          The dimension of the array HOUS2.
!>          LHOUS2 >= 1.
!>
!>          If LWORK = -1, or LHOUS2 = -1,
!>          then a query is assumed; the routine
!>          only calculates the optimal size of the HOUS2 array, returns
!>          this value as the first entry of the HOUS2 array, and no error
!>          message related to LHOUS2 is issued by XERBLA.
!>          If VECT='N', LHOUS2 = max(1, 4*n);
!>          if VECT='V', option not yet available.
!>
[out]WORK
!>          WORK is REAL array, dimension (LWORK)
!>
[in]LWORK
!>          LWORK is INTEGER
!>          The dimension of the array WORK.
!>          If N = 0, LWORK >= 1, else LWORK = MAX(1, dimension).
!>
!>          If LWORK = -1, or LHOUS2 = -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.
!>          LWORK = MAX(1, dimension) where
!>          dimension   = max(stage1,stage2) + (KD+1)*N
!>                      = N*KD + N*max(KD+1,FACTOPTNB)
!>                        + max(2*KD*KD, KD*NTHREADS)
!>                        + (KD+1)*N
!>          where KD is the blocking size of the reduction,
!>          FACTOPTNB is the blocking used by the QR or LQ
!>          algorithm, usually FACTOPTNB=128 is a good choice
!>          NTHREADS is the number of threads used when
!>          openMP compilation is enabled, otherwise =1.
!>
[out]INFO
!>          INFO is INTEGER
!>          = 0:  successful exit
!>          < 0:  if INFO = -i, the i-th argument had an illegal value
!>
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Further Details:
!>
!>  Implemented by Azzam Haidar.
!>
!>  All details are available on technical report, SC11, SC13 papers.
!>
!>  Azzam Haidar, Hatem Ltaief, and Jack Dongarra.
!>  Parallel reduction to condensed forms for symmetric eigenvalue problems
!>  using aggregated fine-grained and memory-aware kernels. In Proceedings
!>  of 2011 International Conference for High Performance Computing,
!>  Networking, Storage and Analysis (SC '11), New York, NY, USA,
!>  Article 8 , 11 pages.
!>  http://doi.acm.org/10.1145/2063384.2063394
!>
!>  A. Haidar, J. Kurzak, P. Luszczek, 2013.
!>  An improved parallel singular value algorithm and its implementation
!>  for multicore hardware, In Proceedings of 2013 International Conference
!>  for High Performance Computing, Networking, Storage and Analysis (SC '13).
!>  Denver, Colorado, USA, 2013.
!>  Article 90, 12 pages.
!>  http://doi.acm.org/10.1145/2503210.2503292
!>
!>  A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra.
!>  A novel hybrid CPU-GPU generalized eigensolver for electronic structure
!>  calculations based on fine-grained memory aware tasks.
!>  International Journal of High Performance Computing Applications.
!>  Volume 28 Issue 2, Pages 196-209, May 2014.
!>  http://hpc.sagepub.com/content/28/2/196
!>
!>

Definition at line 224 of file ssytrd_2stage.f.

226*
227 IMPLICIT NONE
228*
229* -- LAPACK computational routine --
230* -- LAPACK is a software package provided by Univ. of Tennessee, --
231* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
232*
233* .. Scalar Arguments ..
234 CHARACTER VECT, UPLO
235 INTEGER N, LDA, LWORK, LHOUS2, INFO
236* ..
237* .. Array Arguments ..
238 REAL D( * ), E( * )
239 REAL A( LDA, * ), TAU( * ),
240 $ HOUS2( * ), WORK( * )
241* ..
242*
243* =====================================================================
244* ..
245* .. Local Scalars ..
246 LOGICAL LQUERY, UPPER, WANTQ
247 INTEGER KD, IB, LWMIN, LHMIN, LWRK, LDAB, WPOS, ABPOS
248* ..
249* .. External Subroutines ..
250 EXTERNAL xerbla, ssytrd_sy2sb, ssytrd_sb2st
251* ..
252* .. External Functions ..
253 LOGICAL LSAME
254 INTEGER ILAENV2STAGE
255 EXTERNAL lsame, ilaenv2stage
256* ..
257* .. Executable Statements ..
258*
259* Test the input parameters
260*
261 info = 0
262 wantq = lsame( vect, 'V' )
263 upper = lsame( uplo, 'U' )
264 lquery = ( lwork.EQ.-1 ) .OR. ( lhous2.EQ.-1 )
265*
266* Determine the block size, the workspace size and the hous size.
267*
268 kd = ilaenv2stage( 1, 'SSYTRD_2STAGE', vect, n, -1, -1,
269 $ -1 )
270 ib = ilaenv2stage( 2, 'SSYTRD_2STAGE', vect, n, kd, -1,
271 $ -1 )
272 IF( n.EQ.0 ) THEN
273 lhmin = 1
274 lwmin = 1
275 ELSE
276 lhmin = ilaenv2stage( 3, 'SSYTRD_2STAGE', vect, n, kd, ib,
277 $ -1 )
278 lwmin = ilaenv2stage( 4, 'SSYTRD_2STAGE', vect, n, kd, ib,
279 $ -1 )
280 END IF
281*
282 IF( .NOT.lsame( vect, 'N' ) ) THEN
283 info = -1
284 ELSE IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
285 info = -2
286 ELSE IF( n.LT.0 ) THEN
287 info = -3
288 ELSE IF( lda.LT.max( 1, n ) ) THEN
289 info = -5
290 ELSE IF( lhous2.LT.lhmin .AND. .NOT.lquery ) THEN
291 info = -10
292 ELSE IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
293 info = -12
294 END IF
295*
296 IF( info.EQ.0 ) THEN
297 hous2( 1 ) = real( lhmin )
298 work( 1 ) = real( lwmin )
299 END IF
300*
301 IF( info.NE.0 ) THEN
302 CALL xerbla( 'SSYTRD_2STAGE', -info )
303 RETURN
304 ELSE IF( lquery ) THEN
305 RETURN
306 END IF
307*
308* Quick return if possible
309*
310 IF( n.EQ.0 ) THEN
311 work( 1 ) = 1
312 RETURN
313 END IF
314*
315* Determine pointer position
316*
317 ldab = kd+1
318 lwrk = lwork-ldab*n
319 abpos = 1
320 wpos = abpos + ldab*n
321 CALL ssytrd_sy2sb( uplo, n, kd, a, lda, work( abpos ), ldab,
322 $ tau, work( wpos ), lwrk, info )
323 IF( info.NE.0 ) THEN
324 CALL xerbla( 'SSYTRD_SY2SB', -info )
325 RETURN
326 END IF
327 CALL ssytrd_sb2st( 'Y', vect, uplo, n, kd,
328 $ work( abpos ), ldab, d, e,
329 $ hous2, lhous2, work( wpos ), lwrk, info )
330 IF( info.NE.0 ) THEN
331 CALL xerbla( 'SSYTRD_SB2ST', -info )
332 RETURN
333 END IF
334*
335*
336 work( 1 ) = real( lwmin )
337 RETURN
338*
339* End of SSYTRD_2STAGE
340*
xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285
ssytrd_sb2st
subroutine ssytrd_sb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)
SSYTRD_SB2ST reduces a real symmetric band matrix A to real symmetric tridiagonal form T
Definition ssytrd_sb2st.F:233
ssytrd_sy2sb
subroutine ssytrd_sy2sb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)
SSYTRD_SY2SB
Definition ssytrd_sy2sb.f:243
ilaenv2stage
integer function ilaenv2stage(ispec, name, opts, n1, n2, n3, n4)
ILAENV2STAGE
Definition ilaenv2stage.f:148
lsame
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
Here is the call graph for this function:
Here is the caller graph for this function: