PSLAQR4(3) ScaLAPACK routine of NEC Numeric Library Collection PSLAQR4(3)
NAME
PSLAQR4 - is an auxiliary routine used to find the Schur decomposition
and or eigenvalues of a matrix already in Hessenberg form from cols ILO
to IHI
SYNOPSIS
SUBROUTINE PSLAQR4( WANTT, WANTZ, N, ILO, IHI, A, DESCA, WR, WI, ILOZ,
IHIZ, Z, DESCZ, T, LDT, V, LDV, WORK, LWORK, INFO )
LOGICAL WANTT, WANTZ
INTEGER IHI, IHIZ, ILO, ILOZ, INFO, LDT, LDV, LWORK, N
INTEGER DESCA( * ), DESCZ( * )
REAL A( * ), T( LDT, * ), V( LDV, * ), WI( * ), WORK( *
), WR( * ), Z( * )
PURPOSE
PSLAQR4 is an auxiliary routine used to find the Schur decomposition
and or eigenvalues of a matrix already in Hessenberg form from cols ILO
to IHI. This routine requires that the active block is small enough,
i.e. IHI-ILO+1 .LE. LDT, so that it can be solved by LAPACK. Normally,
it is called by PSLAQR1. All the inputs are assumed to be valid with-
out checking.
Notes
=====
Each global data object is described by an associated description vec-
tor. This vector stores the information required to establish the map-
ping between an object element and its corresponding process and memory
location.
Let A be a generic term for any 2D block cyclicly distributed array.
Such a global array has an associated description vector DESCA. In the
following comments, the character _ should be read as "of the global
array".
NOTATION STORED IN EXPLANATION
--------------- -------------- --------------------------------------
DTYPE_A(global) DESCA( DTYPE_ )The descriptor type. In this case,
DTYPE_A = 1.
CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
the BLACS process grid A is distribu-
ted over. The context itself is glo-
bal, but the handle (the integer
value) may vary.
M_A (global) DESCA( M_ ) The number of rows in the global
array A.
N_A (global) DESCA( N_ ) The number of columns in the global
array A.
MB_A (global) DESCA( MB_ ) The blocking factor used to distribute
the rows of the array.
NB_A (global) DESCA( NB_ ) The blocking factor used to distribute
the columns of the array.
RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
row of the array A is distributed.
CSRC_A (global) DESCA( CSRC_ ) The process column over which the
first column of the array A is
distributed.
LLD_A (local) DESCA( LLD_ ) The leading dimension of the local
array. LLD_A >= MAX(1,LOCr(M_A)).
Let K be the number of rows or columns of a distributed matrix, and
assume that its process grid has dimension p x q.
LOCr( K ) denotes the number of elements of K that a process would
receive if K were distributed over the p processes of its process col-
umn.
Similarly, LOCc( K ) denotes the number of elements of K that a process
would receive if K were distributed over the q processes of its process
row.
The values of LOCr() and LOCc() may be determined via a call to the
ScaLAPACK tool function, NUMROC:
LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).
An upper bound for these quantities may be computed by:
LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A
ARGUMENTS
WANTT (global input) LOGICAL
= .TRUE. : the full Schur form T is required;
= .FALSE.: only eigenvalues are required.
WANTZ (global input) LOGICAL
= .TRUE. : the matrix of Schur vectors Z is required;
= .FALSE.: Schur vectors are not required.
N (global input) INTEGER
The order of the Hessenberg matrix A (and Z if WANTZ).
N >= 0.
ILO (global input) INTEGER
IHI (global input) INTEGER
It is assumed that A is already upper quasi-triangular in rows
and columns IHI+1:N, and that A(ILO,ILO-1) = 0 (unless ILO =
1). PSLAQR4 works primarily with the Hessenberg submatrix in
rows and columns ILO to IHI, but applies transformations to all
of H if WANTT is .TRUE..
1 <= ILO <= max(1,IHI); IHI <= N.
A (global input/output) REAL array, dimension (DESCA(LLD_),*)
On entry, the upper Hessenberg matrix A.
On exit, if WANTT is .TRUE., A is upper quasi-triangular in
rows and columns ILO:IHI, with any 2-by-2 or larger diagonal
blocks not yet in standard form. If WANTT is .FALSE., the con-
tents of A are unspecified on exit.
DESCA (global and local input) INTEGER array of dimension DLEN_.
The array descriptor for the distributed matrix A.
WR (global replicated output) REAL array, dimension (N)
WI (global replicated output) REAL array, dimension (N)
The real and imaginary parts, respectively, of the computed
eigenvalues ILO to IHI are stored in the corresponding elements
of WR and WI. If two eigenvalues are computed as a complex con-
jugate pair, they are stored in consecutive elements of WR and
WI, say the i-th and (i+1)th, with WI(i) > 0 and WI(i+1) < 0.
If WANTT is .TRUE., the eigenvalues are stored in the same
order as on the diagonal of the Schur form returned in A. A
may be returned with larger diagonal blocks until the next
release.
ILOZ (global input) INTEGER
IHIZ (global input) INTEGER
Specify the rows of Z to which transformations must be applied
if WANTZ is .TRUE..
1 <= ILOZ <= ILO; IHI <= IHIZ <= N.
Z (global input/output) REAL array.
If WANTZ is .TRUE., on entry Z must contain the current matrix
Z of transformations accumulated by PDHSEQR, and on exit Z has
been updated; transformations are applied only to the submatrix
Z(ILOZ:IHIZ,ILO:IHI).
If WANTZ is .FALSE., Z is not referenced.
DESCZ (global and local input) INTEGER array of dimension DLEN_.
The array descriptor for the distributed matrix Z.
T (local workspace) REAL array, dimension LDT*NW.
LDT (local input) INTEGER
The leading dimension of the array T.
LDT >= IHI-ILO+1.
V (local workspace) REAL array, dimension LDV*NW.
LDV (local input) INTEGER
The leading dimension of the array V.
LDV >= IHI-ILO+1.
WORK (local workspace) REAL array, dimension LWORK.
LWORK (local input) INTEGER
The dimension of the work array WORK.
LWORK >= IHI-ILO+1.
WORK(LWORK) is a local array and LWORK is assumed big enough.
Typically LWORK >= 4*LDS*LDS if this routine is called by
PSLAQR1. (LDS = 385, see PSLAQR1)
INFO (global output) INTEGER
< 0: parameter number -INFO incorrect or inconsistent;
= 0: successful exit;
> 0: PSLAQR4 failed to compute all the eigenvalues ILO to IHI
in a total of 30*(IHI-ILO+1) iterations; if INFO = i,
elements i+1:ihi of WR and WI contain those eigenvalues
which have been successfully computed.
ScaLAPACK routine 31 October 2017 PSLAQR4(3)