Parallel Engineering and Scientific Subroutine Library for AIX Version 2 Release 3: Guide and Reference

PDSYGST and PZHEGST--Reduce a Real Symmetric or Complex Hermitian Positive Definite Generalized Eigenproblem to Standard Form

|These subroutines reduce a real symmetric or complex Hermitian |positive definite generalized eigenproblem to standard form and solves the |following problem types:

If ibtype = 1, the problem is Ax = lambdaBx
If ibtype = 2, the problem is ABx = lambdax
If ibtype = 3, the problem is BAx = lambdax

B must have been previously factored by a call to PDPOTRF |or PZPOTRF.

In the formulas above:

A represents the global real symmetric |or complex Hermitian submatrix A_{ia:ia+n-1,
ja:ja+n-1}

B represents the global real symmetric |or complex Hermitian submatrix B_{ib:ib+n-1,
jb:jb+n-1}

If n = 0, no computation is performed and the subroutine returns after doing some parameter checking.

See reference [13].
|

|Table 105. Data Types

A, B	`scale`	Subroutine
Long-precision real	Long-precision real	PDSYGST
Long-precision complex	Long-precision real	PZHEGST

Syntax

Fortran	CALL PDSYGST\|PZHEGST (`ibtype`, `uplo`, `n`, `a`, `ia`, `ja`, `desc_a`, `b`, `ib`, `jb`, `desc_b`, `scale`, `info`)
C and C++	pdsygst\|pzhegst (`ibtype`, `uplo`, `n`, `a`, `ia`, `ja`, `desc_a`, `b`, `ib`, `jb`, `desc_b`, `scale`, `info`);

On Entry

ibtype

specifies the problem type, where:

If ibtype = 1, the problem is Ax = lambdaBx

If ibtype = 2, the problem is ABx = lambdax

If ibtype = 3, the problem is BAx = lambdax

Scope: global

Specified as: a fullword integer; ibtype = 1, 2, or 3.

uplo

indicates whether the upper or lower triangular part of the |global submatrix A is referenced, and how the global |submatrix B has been factored, where:

If uplo = 'U', the upper triangular part is referenced.

If uplo = 'L', the lower triangular part is referenced.

Scope: global

Specified as: a single character; uplo = 'U' or 'L'.

n

is the order of submatrices A and B used in the computation.

Scope: global

Specified as: a fullword integer; n >= 0.

a

is the local part of the global |real symmetric |or complex Hermitian matrix A. This identifies the first element of the local array A. This subroutine computes the location of the first element of the local subarray used, based on ia, ja, desc_a, p, q, myrow, and mycol; therefore, the leading LOCp(ia+n-1) by LOCq(ja+n-1) part of the local array A must contain the local pieces of the leading ia+n-1 by ja+n-1 part of the global matrix, and:

If uplo = 'U', the leading n × n upper triangular part of the global submatrix A_{ia:ia+n-1,
ja:ja+n-1} must contain the upper triangular part of the submatrix, and the strictly lower triangular part is not referenced.
If uplo = 'L', the leading n × n lower triangular part of the global submatrix A_{ia:ia+n-1,
ja:ja+n-1} must contain the lower triangular part of the submatrix, and the strictly upper triangular part is not referenced.

Scope: local

Specified as: an LLD_A by (at least) LOCq(N_A) array, containing numbers of the data type indicated in Table 105. Details about the square block-cyclic data distribution of global matrix A are stored in desc_a.

ia

is the row index of the global matrix A, identifying the first row of the submatrix A.

Scope: global

Specified as: a fullword integer; 1 <= ia <= M_A and ia+n-1 <= M_A.

ja

is the column index of the global matrix A, identifying the first column of the submatrix A.

Scope: global

Specified as: a fullword integer; 1 <= ja <= N_A and ja+n-1 <= N_A.

desc_a

is the array descriptor for global matrix A, described in the following table:

`desc_a`	Name	Description	Limits	Scope
1	DTYPE_A	Descriptor type	DTYPE_A=1	Global
2	CTXT_A	BLACS context	Valid value, as returned by BLACS_GRIDINIT or BLACS_GRIDMAP	Global
3	M_A	Number of rows in the global matrix	If `n` = 0: M_A >= 0 Otherwise: M_A >= 1	Global
4	N_A	Number of columns in the global matrix	If `n` = 0: N_A >= 0 Otherwise: N_A >= 1	Global
5	MB_A	Row block size	MB_A >= 1	Global
6	NB_A	Column block size	NB_A >= 1	Global
7	RSRC_A	The process row of the `p` × `q` grid over which the first row of the global matrix is distributed	0 <= RSRC_A < `p`	Global
8	CSRC_A	The process column of the `p` × `q` grid over which the first column of the global matrix is distributed	0 <= CSRC_A < `q`	Global
9	LLD_A	The leading dimension of the local array	LLD_A >= max(1,LOCp(M_A))	Local

Specified as: an array of (at least) length 9, containing fullword integers.

b

is the local part of the global |real symmetric or complex Hermitian matrix B, containing the results of the Cholesky factorization computed by PDPOTRF |or PZPOTRF. This identifies the first element of the local array B. This subroutine computes the location of the first element of the local subarray used, based on ib, jb, desc_b, p, q, myrow, and mycol; therefore, the leading LOCp(ib+n-1) by LOCq(jb+n-1) part of the local array B must contain the local pieces of the leading ib+n-1 by jb+n-1 part of the global matrix.

Scope: local

Specified as: an LLD_B by (at least) LOCq(N_B) array, containing numbers of the data type indicated in Table 105. Details about the square block-cyclic data distribution of global matrix B are stored in desc_b.

ib

is the row index of the global matrix B, identifying the first row of the submatrix B.

Scope: global

Specified as: a fullword integer; 1 <= ib <= M_B and ib+n-1 <= M_B.

jb

is the column index of the global matrix B, identifying the first column of the submatrix B.

Scope: global

Specified as: a fullword integer; 1 <= jb <= N_B and jb+n-1 <= N_B.

desc_b

is the array descriptor for global matrix B, described in the following table:

`desc_b`	Name	Description	Limits	Scope
1	DTYPE_B	Descriptor type	DTYPE_B=1	Global
2	CTXT_B	BLACS context	Valid value, as returned by BLACS_GRIDINIT or BLACS_GRIDMAP	Global
3	M_B	Number of rows in the global matrix	If `n` = 0: M_B >= 0 Otherwise: M_B >= 1	Global
4	N_B	Number of columns in the global matrix	If `n` = 0: N_B >= 0 Otherwise: N_B >= 1	Global
5	MB_B	Row block size	MB_B >= 1	Global
6	NB_B	Column block size	NB_B >= 1	Global
7	RSRC_B	The process row of the `p` × `q` grid over which the first row of the global matrix is distributed	0 <= RSRC_B < `p`	Global
8	CSRC_B	The process column of the `p` × `q` grid over which the first column of the global matrix is distributed	0 <= CSRC_B < `q`	Global
9	LLD_B	The leading dimension of the local array	LLD_B >= max(1,LOCp(M_B))	Local

Specified as: an array of (at least) length 9, containing fullword integers.

scale

See On Return.

info

See On Return.

On Return

a

is the updated local part of the global matrix A, containing the transformed matrix, where:

|For PDSYGST:
- If ibtype = 1, global matrix A is overwritten by:
  
  A = U^-TAU^-1 if uplo = 'U'.
  A = L^-1AL^-T if uplo = 'L'.
- If ibtype = 2 or 3, global matrix A is overwritten by:
  
  A = UAU^T if uplo = 'U'.
  A = L^TAL if uplo = 'L'.
|For PZHEGST: |
- |If ibtype = 1, global matrix A is overwritten |by: |
  
  |A = U^-HAU^-1 |if uplo = 'U'.
  |A = L^-1AL^-H |if uplo = 'L'. |
- |If ibtype = 2 or 3, global matrix A is |overwritten by: |
  
  |A = UAU^H if |uplo = 'U'.
  |A = L^HAL if |uplo = 'L'. |
  |

See Function, for more information.

Scope: local

Returned as: an LLD_A by (at least) LOCq(N_A) array, containing numbers of the data type indicated in Table 105. Details about the square block-cyclic data distribution of global matrix A are stored in desc_a.

scale

reserved for future use.

Scope: global

Returned as: a long-precision real number; scale = 1.0

info

indicates that a successful computation occurred.

Scope: global

Returned as: a fullword integer; info = 0.

Notes and Coding Rules

This subroutine accepts lowercase letters for the uplo argument.
In your C program, arguments scale and info must be passed by reference.
Matrices A and B must have no common elements; otherwise, results are unpredictable.
The NUMROC utility subroutine can be used to determine the values of LOCp(M_) and LOCq(N_) used in the argument descriptions above. For details, see Determining the Number of Rows and Columns in Your Local Arrays and NUMROC--Compute the Number of Rows or Columns of a Block-Cyclically Distributed Matrix Contained in a Process.
The |global matrix A must be distributed using a square block-cyclic distribution; that is, MB_A = NB_A.
The |global matrix A must be aligned on a block boundary; that is:
- ia-1 must be a multiple of MB_A
- ja-1 must be a multiple of NB_A
In the process grid, the process row containing the first row of the submatrix A must also contain the first row of the submatrix B; that is: iarow = ibrow
where:
- iarow = mod(RSRC_A+(ia-1)/MB_A, p)
- ibrow = mod(RSRC_B+(ib-1)/MB_B, p)
In the process grid, the process column containing the first column of the submatrix A must also contain the first column of the submatrix B; that is: iacol = ibcol
where:
- iacol = mod(CSRC_A+(ja-1)/NB_A, q)
- ibcol = mod(CSRC_B+(jb-1)/NB_B, q)
The block row offset of the global matrix A must be equal to the block row offset of the global matrix B; that is:
- mod((ia-1, MB_A) = mod(ib-1, MB_B))
The block column offset of the global matrix A must be equal to the block column offset of the global matrix B; that is:
- mod((ja-1, NB_A) = mod(jb-1, NB_B))
The following values must be equal:
- MB_A = MB_B
- NB_A = NB_B
- CTXT_A = CTXT_B
For suggested block sizes, see Coding Tips for Optimizing Parallel Performance.

Function

|These subroutines reduce a real symmetric or complex Hermitian positive definite generalized Eigenproblem to standard form.

|For PDSYGST:

If ibtype = 1, the problem is Ax = lambdaBX, and on output

A = U^-TAU^-1 if uplo = 'U'.
A = L^-1AL^-T if uplo = 'L'.
If ibtype = 2, the problem is ABx = lambdax, and on output

A = UAU^T if uplo = 'U'.
A = L^TAL if uplo = 'L'.
If ibtype = 3, the problem is BAx = lambdax, and on output

A = UAU^T if uplo = 'U'.
A = L^TAL if uplo = 'L'.
B must have been previously factored by a call to PDPOTRF, as:

A = U^TU if uplo = 'U'.
A = LL^T if uplo = 'L'.

|For PZHEGST:

If ibtype = 1, the problem is Ax = lambdaBX, and on output

A = U^-HAU^-1 if uplo = 'U'.
A = L^-1AL^-H if uplo = 'L'.
If ibtype = 2, the problem is ABx = lambdax, and on output

A = UAU^H if uplo = 'U'.
A = L^HAL if uplo = 'L'.
If ibtype = 3, the problem is BAx = lambdax, and on output

A = UAU^H if uplo = 'U'.
A = L^HAL if uplo = 'L'.
B must have been previously factored by a call to PZPOTRF, as:

A = U^HU if uplo = 'U'.
A = LL^H if uplo = 'L'.

In the formulas above:

A represents the |global submatrix A_{ia:ia+n-1,
ja:ja+n-1}

B represents the |global submatrix B_{ib:ib+n-1,
jb:jb+n-1}

L is a lower triangular matrix.

U is an upper triangular matrix.

Error Conditions

Computational Errors

None

Resource Errors

None

Input-Argument and Miscellaneous Errors

Stage 1:

DTYPE_A is invalid.
DTYPE_B is invalid.

Stage 2:

CTXT_A is invalid.

Stage 3:

This subroutine has been called from outside the process grid.

Stage 4:

ibtype <> 1, 2, or 3
uplo <> 'U' or 'L'
n < 0
M_A < 0 and n = 0; M_A < 1 otherwise
N_A < 0 and n = 0; N_A < 1 otherwise
MB_A < 1
NB_A < 1
RSRC_A < 0 or RSRC_A >= p
CSRC_A < 0 or CSRC_A >= q
ia < 1
ja < 1
M_B < 0 and n = 0; M_B < 1 otherwise
N_B < 0 and n = 0; N_B < 1 otherwise
MB_B < 1
NB_B < 1
RSRC_B < 0 or RSRC_B >= p
CSRC_B < 0 or CSRC_B >= q
ib < 1
jb < 1
CTXT_A <> CTXT_B

Stage 5: If n <> 0:

ia > M_A
ja > N_A
ia+n-1 > M_A
ja+n-1 > N_A
ib > M_B
jb > N_B
ib+n-1 > M_B
jb+n-1 > N_B

In all cases:

MB_A <> NB_A
mod(ia-1, MB_A) <> 0
mod(ja-1, NB_A) <> 0
MB_A <> MB_B
NB_A <> NB_B
mod(ib-1, MB_B) <> mod(ia-1, MB_A)
mod(jb-1, NB_B) <> mod(ja-1, NB_A)
In the process grid, the process row containing the first row of the submatrix A does not contain the first row of the submatrix B; that is, iarow <> ibrow, where:

iarow = mod(RSRC_A + (ia-1)/MB_A, p)
ibrow = mod(RSRC_B + (ib-1)/MB_B, p)
In the process grid, the process column containing the first column of the submatrix A does not contain the first column of the submatrix B; that is, iacol <> ibcol, where:

iacol = mod(CSRC_A + (ja-1)/NB_A, q)
ibcol = mod(CSRC_B + (jb-1)/NB_B, q)

Stage 6:

LLD_A < max(1, LOCp(M_A))
LLD_B < max(1, LOCp(M_B))

Stage 7:

Each of the following global input arguments are checked to determine whether its value differs from the value specified on process P₀₀:

ibtype differs.
uplo differs.
n differs.
ia differs.
ja differs.
DTYPE_A differs.
M_A differs.
N_A differs.
MB_A differs.
NB_A differs.
RSRC_A differs.
CSRC_A differs.
ib differs.
jb differs.
DTYPE_B differs.
M_B differs.
N_B differs.
MB_B differs.
NB_B differs.
RSRC_B differs.
CSRC_B differs.

Example 1

This example shows the reduction of a real symmetric positive definite generalized eigenproblem to standard form, using a 2 × 2 process grid.

Call Statements and Input

ORDER = 'R'
NPROW = 2
NPCOL = 2
CALL BLACS_GET(0, 0, ICONTXT)
CALL BLACS_GRIDINIT(ICONTXT, ORDER, NPROW, NPCOL)
CALL BLACS_GRIDINFO(ICONTXT, NPROW, NPCOL, MYROW, MYCOL)
 
              UPLO  N   B   IB   JB   DESCB  INFO
               |    |   |    |    |     |      |
CALL PDPOTRF( 'L',  4,  B,   1,   1,  DESCB, INFO )
                                                       
                                                       
             IBTYPE  UPLO   N   A   IA   JA   DESCA   B   IB   JB   DESCB  SCALE  INFO
               |      |     |   |    |    |     |     |    |    |     |      |      |
CALL PDSYGST(  1,    'L',   4,  A,   1,   1,  DESCA,  B,   1,   1,  DESCB, SCALE, INFO )

	DESC_A	DESC_B
DTYPE_	1	1
CTXT_	`icontxt`^(IITOOT3)	`icontxt`^(IITOOT3)
M_	4	4
N_	4	4
MB_	1	1
NB_	1	1
RSRC_	0	0
CSRC_	0	0
LLD_	See below^(EPSSTL3)	See below^(EPSSTL3)
Notes: `icontxt` is the output of the BLACS_GRIDINIT call. Each process should set the LLD_ as follows: LLD_A = MAX(1,NUMROC(M_A, MB_A, MYROW, RSRC_A, NPROW)) LLD_B = MAX(1,NUMROC(M_B, MB_B, MYROW, RSRC_B, NPROW)) In this example, LLD_A and LLD_B = 2 on all processes.

Global |real symmetric matrix A of order 4, stored in lower storage mode, with block sizes 1 × 1:

B,D     0        1        2        3
     *                                 *
 0   | -1.0  |    .   |    .   |    .  |
     | ------|--------|--------|------ |
 1   |  1.0  |   1.0  |    .   |    .  |
     | ------|--------|--------|------ |
 2   | -1.0  |  -1.0  |   1.0  |    .  |
     | ------|--------|--------|------ |
 3   |  1.0  |   1.0  |  -1.0  |   1.0 |
     *                                 *

The following is the 2 × 2 process grid:

B,D  |  0 2  |1 3
-----|-------|-----
0    |   P₀₀   |  P₀₁
2    |       |
-----|-------|-----
1    |   P₁₀   |  P₁₁
3    |       |

Local arrays for A:

p,q  |     0      |      1
-----|------------|------------
 0   | -1.0   .   |    .    . 
     | -1.0  1.0  |  -1.0   . 
-----|------------|------------
 1   |  1.0   .   |   1.0   . 
     |  1.0 -1.0  |   1.0  1.0

Input to PDPOTRF:

Global |real symmetric positive definite matrix B of order 4, stored in lower storage mode, with block sizes 1 × 1:

B,D      0         1         2         3
     *                                     *
 0   |  2.0   |    .    |    .    |    .   |
     | -------|---------|---------|------- |
 1   |  1.0   |   2.0   |    .    |    .   |
     | -------|---------|---------|------- |
 2   |  0.0   |   1.0   |   2.0   |    .   |
     | -------|---------|---------|------- |
 3   |  0.0   |   0.0   |   1.0   |   2.0  |
     *                                     *

The following is the 2 × 2 process grid:

B,D  |  0 2  |1 3
-----|-------|-----
0    |   P₀₀   |  P₀₁
2    |       |
-----|-------|-----
1    |   P₁₀   |  P₁₁
3    |       |

Local arrays for B:

p,q  |      0       |       1
-----|--------------|--------------
 0   |  2.0    .    |    .     .  
     |  0.0   2.0   |   1.0    .  
-----|--------------|--------------
 1   |  1.0    .    |   2.0    .  
     |  0.0   1.0   |   0.0   2.0

Output from PDPOTRF and input to PDSYGST:

Global |real symmetric positive definite matrix B of order 4, stored in lower storage mode, with block sizes 1 × 1:

B,D       0           1           2           3
     *                                             *
 0   |  1.4142  |     .     |     .     |     .    |
     | ---------|-----------|-----------|--------- |
 1   |  0.7071  |   1.2247  |     .     |     .    |
     | ---------|-----------|-----------|--------- |
 2   |  0.0000  |   0.8165  |   1.1547  |     .    |
     | ---------|-----------|-----------|--------- |
 3   |  0.0000  |   0.0000  |   0.8660  |  1.1180  |
     *                                             *

The following is the 2 × 2 process grid:

B,D  |  0 2  |1 3
-----|-------|-----
0    |   P₀₀   |  P₀₁
2    |       |
-----|-------|-----
1    |   P₁₀   |  P₁₁
3    |       |

Local arrays for B:

p,q  |        0          |         1
-----|-------------------|-------------------
 0   |  1.4142    .      |    .        .     
     |  0.0000   1.1547  |   0.8165    .     
-----|-------------------|-------------------
 1   |  0.7071    .      |   1.2247    .     
     |  0.0000   0.8660  |   0.0000   1.1180

Output from PDSYGST:

Global |real symmetric matrix A of order 4, stored in lower storage mode, with block sizes 1 × 1:

B,D       0           1           2           3
     *                                             *
 0   | -0.5000  |     .     |     .     |     .    |
     | ---------|-----------|-----------|--------- |
 1   |  0.8660  |  -0.1667  |     .     |     .    |
     | ---------|-----------|-----------|--------- |
 2   | -1.2247  |  -0.2357  |   1.1667  |     .    |
     | ---------|-----------|-----------|--------- |
 3   |  1.5811  |   0.5477  |  -1.9365  |  3.1000  |
     *                                             *

The following is the 2 × 2 process grid:

B,D  |  0 2  |1 3
-----|-------|-----
0    |   P₀₀   |  P₀₁
2    |       |
-----|-------|-----
1    |   P₁₀   |  P₁₁
3    |       |

Local arrays for A:

p,q  |        0          |         1
-----|-------------------|-------------------
 0   | -0.5000    .      |    .        .     
     | -1.2247   1.1667  |  -0.2357    .     
-----|-------------------|-------------------
 1   |  0.8660    .      |  -0.1667    .     
     |  1.5811  -1.9365  |   0.5477   3.1000

The value of scale is 1.0 on all processes.

The value of info is 0 on all processes.

|Example 2

|This example shows the reduction of a complex Hermitian positive definite |generalized eigenproblem to standard form, using a 2 × 2 process |grid.

|Call Statements and Input

|ORDER = 'R'
|NPROW = 2
|NPCOL = 2
|CALL BLACS_GET(0, 0, ICONTXT)
|CALL BLACS_GRIDINIT(ICONTXT, ORDER, NPROW, NPCOL)
|CALL BLACS_GRIDINFO(ICONTXT, NPROW, NPCOL, MYROW, MYCOL)
| 
|              UPLO  N   B   IB   JB   DESCB  INFO
|               |    |   |    |    |     |      |
|CALL PZPOTRF( 'L',  4,  B,   1,   1,  DESCB, INFO )
|                                                       
|                                                       
|             IBTYPE  UPLO   N   A   IA   JA   DESCA   B   IB   JB   DESCB  SCALE  INFO
|               |      |     |   |    |    |     |     |    |    |     |      |      |
|CALL PZHEGST(  1,    'L',   4,  A,   1,   1,  DESCA,  B,   1,   1,  DESCB, SCALE, INFO )

	DESC_A	DESC_B
DTYPE_	1	1
CTXT_	`icontxt`^(IITOOT4)	`icontxt`^(IITOOT4)
M_	4	4
N_	4	4
MB_	1	1
NB_	1	1
RSRC_	0	0
CSRC_	0	0
LLD_	See below^(EPSSTL4)	See below^(EPSSTL4)
Notes: `icontxt` is the output of the BLACS_GRIDINIT call. Each process should set the LLD_ as follows: LLD_A = MAX(1,NUMROC(M_A, MB_A, MYROW, RSRC_A, NPROW)) LLD_B = MAX(1,NUMROC(M_B, MB_B, MYROW, RSRC_B, NPROW)) In this example, LLD_A and LLD_B = 2 on all processes.

|Global complex Hermitian matrix A of order 4, stored in lower |storage mode, with block sizes 1 × 1:

|B,D         0              1              2              3
|     *                                                         *
| 0   | (1.0,  0.0) |       .      |       .      |       .     |
|     | ------------|--------------|--------------|------------ |
| 1   | (5.0, -2.0) | (10.0,  0.0) |       .      |       .     |
|     | ------------|--------------|--------------|------------ |
| 2   | (7.0,  4.0) | (15.0,  6.0) | (20.0,  0.0) |       .     |
|     | ------------|--------------|--------------|------------ |
| 3   | (9.0, -6.0) | (20.0, -4.0) | (25.0, -9.0) | (30.0, 0.0) |
|     *                                                         *

|The following is the 2 × 2 process grid:

|B,D  |  0 2  |1 3
|-----|-------|-----
|0    |   P₀₀   |  P₀₁
|2    |       |
|-----|-------|-----
|1    |   P₁₀   |  P₁₁
|3    |       |

|Local arrays for A:

|p,q  |       0                  |            1
|-----|--------------------------|-----------------------
| 0   | ( 1.0,   . )       .     |       .           . 
|     | ( 7.0,  4.0) (20.0,   . )| (15.0, 6.0)       . 
|-----|--------------------------|-----------------------
| 1   | ( 5.0, -2.0)       .     | (10.0,  . )       . 
|     | ( 9.0, -6.0) (25.0, -9.0)| (20.0,-4.0) (30.0, . )

|Input to PZPOTRF:

|Global complex Hermitian positive definite matrix B of order 4, |stored in lower storage mode, with block sizes 1 × 1:

|B,D         0              1              2              3
|     *                                                         *
| 0   | (9.0,  0.0) |       .      |       .      |       .     |
|     | ------------|--------------|--------------|------------ |
| 1   | (3.0, -3.0) | (18.0,  0.0) |       .      |       .     |
|     | ------------|--------------|--------------|------------ |
| 2   | (3.0,  3.0) | ( 8.0,  6.0) | (27.0,  0.0) |       .     |
|     | ------------|--------------|--------------|------------ |
| 3   | (3.0, -3.0) | ( 8.0, -6.0) | (12.0, -9.0) | (61.0, 0.0) |
|     *                                                         *

|The following is the 2 × 2 process grid:

|B,D  |  0 2  |1 3
|-----|-------|-----
|0    |   P₀₀   |  P₀₁
|2    |       |
|-----|-------|-----
|1    |   P₁₀   |  P₁₁
|3    |       |

|Local arrays for B:

|p,q  |            0            |            1
|-----|-------------------------|-----------------------
| 0   | (9.0,   . )       .     |       .           .   
|     | (3.0,  3.0) (27.0,   .) | ( 8.0, 6.0)       .   
|-----|-------------------------|-----------------------
| 1   | (3.0, -3.0)       .     | (18.0,  . )       .   
|     | (3.0, -3.0) (12.0, -9.0)| ( 8.0,-6.0) (61.0, . )
|

|Output from PZPOTRF and input to PZHEGST:

|Global complex Hermitian positive definite matrix B of order 4, |stored in lower storage mode, with block sizes 1 × 1:

|B,D         0              1               2                   3
|     *                                                               *
| 0   | (3.0,  0.0) |      .      |         .         |         .     |
|     | ------------|-------------|-------------------|-------------- |
| 1   | (1.0, -1.0) | (4.0,  0.0) |         .         |         .     |
|     | ------------|-------------|-------------------|-------------- |
| 2   | (1.0,  1.0) | (2.0,  0.0) | (4.4721,  0.0)    |         .     |
|     | ------------|-------------|-------------------|-------------- |
| 3   | (1.0, -1.0) | (1.5, -1.5) | (2.3479,  -.5590) | (6.9767, 0.0) |
|     *                                                               *

|The following is the 2 × 2 process grid:

|B,D  |  0 2  |1 3
|-----|-------|-----
|0    |   P₀₀   |  P₀₁
|2    |       |
|-----|-------|-----
|1    |   P₁₀   |  P₁₁
|3    |       |

|Local arrays for B:

|p,q  |             0               |           1
|-----|-----------------------------|--------------------------
| 0   | (3.0,  0.0)         .       |      .             .     
|     | (1.0,  1.0) (4.4721, 0.0)   | (2.0, 1.0)         .     
|-----|-----------------------------|--------------------------
| 1   | (1.0, -1.0)         .       | (4.0, 0.0)       .       
|     | (1.0, -1.0) (2.3479, -.5590)| (1.5,-1.5) (6.9767, 0.0 )
|

|Output from PZHEGST:

|Global complex Hermitian matrix A of order 4, stored in lower |storage mode, with block sizes 1 × 1:

|B,D           0                 1                 2                3
|     *                                                                     *
| 0   | (.1111, 0.0   ) |        .        |         .       |         .     |
|     | ----------------|-----------------|-----------------|-------------- |
| 1   | (.3889, -.1389) | (.3472,  0.0  ) |         .       |         .     |
|     | ----------------|-----------------|-----------------|-------------- |
| 2   | (.2919,  .2485) | (.5714, -.0652) | (.0757, 0.0)    |         .     |
|     | ----------------|-----------------|-----------------|-------------- |
| 3   | (.2422, -.2175) | (.2001, -.0009) | (.4003,  .2645) | (-.0488, 0.0) |
|     *                                                                     *

|The following is the 2 × 2 process grid:

|B,D  |  0 2  |1 3
|-----|-------|-----
|0    |   P₀₀   |  P₀₁
|2    |       |
|-----|-------|-----
|1    |   P₁₀   |  P₁₁
|3    |       |

|Local arrays for A:

|p,q  |                0               |                1
|-----|--------------------------------|-------------------------------
| 0   | (.1111, 0.0   )        .       |        .                .     
|     | (.2919,  .2485) (.0757, 0.0)   | (.5714, -.0652)         .     
|-----|--------------------------------|-------------------------------
| 1   | (.3889, -.1389)        .       | (.3472, 0.0   )         .     
|     | (.2442, -.2175) (.4003, .2645) | (.2001, -.0009) (-.0488, 0.0 )
|

|The value of scale is 1.0 on all processes.

|The value of info is 0 on all processes.

[ Top of Page | Previous Page | Next Page | Table of Contents | Index ]