chpsvx man page on OpenIndiana

Man page or keyword search:  
man Server   20441 pages
apropos Keyword Search (all sections)
Output format
OpenIndiana logo
[printable version]

chpsvx(3P)		    Sun Performance Library		    chpsvx(3P)

NAME
       chpsvx  -  use  the diagonal pivoting factorization A = U*D*U**H or A =
       L*D*L**H to compute the solution to a complex system  of	 linear	 equa‐
       tions A * X = B, where A is an N-by-N Hermitian matrix stored in packed
       format and X and B are N-by-NRHS matrices

SYNOPSIS
       SUBROUTINE CHPSVX(FACT, UPLO, N, NRHS, A, AF, IPIVOT, B, LDB, X, LDX,
	     RCOND, FERR, BERR, WORK, WORK2, INFO)

       CHARACTER * 1 FACT, UPLO
       COMPLEX A(*), AF(*), B(LDB,*), X(LDX,*), WORK(*)
       INTEGER N, NRHS, LDB, LDX, INFO
       INTEGER IPIVOT(*)
       REAL RCOND
       REAL FERR(*), BERR(*), WORK2(*)

       SUBROUTINE CHPSVX_64(FACT, UPLO, N, NRHS, A, AF, IPIVOT, B, LDB, X,
	     LDX, RCOND, FERR, BERR, WORK, WORK2, INFO)

       CHARACTER * 1 FACT, UPLO
       COMPLEX A(*), AF(*), B(LDB,*), X(LDX,*), WORK(*)
       INTEGER*8 N, NRHS, LDB, LDX, INFO
       INTEGER*8 IPIVOT(*)
       REAL RCOND
       REAL FERR(*), BERR(*), WORK2(*)

   F95 INTERFACE
       SUBROUTINE HPSVX(FACT, UPLO, [N], [NRHS], A, AF, IPIVOT, B, [LDB], X,
	      [LDX], RCOND, FERR, BERR, [WORK], [WORK2], [INFO])

       CHARACTER(LEN=1) :: FACT, UPLO
       COMPLEX, DIMENSION(:) :: A, AF, WORK
       COMPLEX, DIMENSION(:,:) :: B, X
       INTEGER :: N, NRHS, LDB, LDX, INFO
       INTEGER, DIMENSION(:) :: IPIVOT
       REAL :: RCOND
       REAL, DIMENSION(:) :: FERR, BERR, WORK2

       SUBROUTINE HPSVX_64(FACT, UPLO, [N], [NRHS], A, AF, IPIVOT, B, [LDB],
	      X, [LDX], RCOND, FERR, BERR, [WORK], [WORK2], [INFO])

       CHARACTER(LEN=1) :: FACT, UPLO
       COMPLEX, DIMENSION(:) :: A, AF, WORK
       COMPLEX, DIMENSION(:,:) :: B, X
       INTEGER(8) :: N, NRHS, LDB, LDX, INFO
       INTEGER(8), DIMENSION(:) :: IPIVOT
       REAL :: RCOND
       REAL, DIMENSION(:) :: FERR, BERR, WORK2

   C INTERFACE
       #include <sunperf.h>

       void chpsvx(char fact, char uplo, int n, int nrhs, complex *a,  complex
		 *af,  int  *ipivot, complex *b, int ldb, complex *x, int ldx,
		 float *rcond, float *ferr, float *berr, int *info);

       void chpsvx_64(char fact, char uplo, long n,  long  nrhs,  complex  *a,
		 complex  *af, long *ipivot, complex *b, long ldb, complex *x,
		 long ldx,  float  *rcond,  float  *ferr,  float  *berr,  long
		 *info);

PURPOSE
       chpsvx  uses  the  diagonal  pivoting factorization A = U*D*U**H or A =
       L*D*L**H to compute the solution to a complex system  of	 linear	 equa‐
       tions A * X = B, where A is an N-by-N Hermitian matrix stored in packed
       format and X and B are N-by-NRHS matrices.

       Error bounds on the solution and a condition  estimate  are  also  pro‐
       vided.

       The following steps are performed:

       1. If FACT = 'N', the diagonal pivoting method is used to factor A as
	     A = U * D * U**H,	if UPLO = 'U', or
	     A = L * D * L**H,	if UPLO = 'L',
	  where U (or L) is a product of permutation and unit upper (lower)
	  triangular matrices and D is Hermitian and block diagonal with
	  1-by-1 and 2-by-2 diagonal blocks.

       2. If some D(i,i)=0, so that D is exactly singular, then the routine
	  returns with INFO = i. Otherwise, the factored form of A is used
	  to estimate the condition number of the matrix A.  If the
	  reciprocal of the condition number is less than machine precision,
	  INFO = N+1 is returned as a warning, but the routine still goes on
	  to solve for X and compute error bounds as described below.

       3. The system of equations is solved for X using the factored form
	  of A.

       4. Iterative refinement is applied to improve the computed solution
	  matrix and calculate error bounds and backward error estimates
	  for it.

ARGUMENTS
       FACT (input)
		 Specifies whether or not the factored form of A has been sup‐
		 plied on entry.  = 'F':  On entry, AF and IPIVOT contain  the
		 factored  form	 of A.	AF and IPIVOT will not be modified.  =
		 'N':  The matrix A will be copied to AF and factored.

       UPLO (input)
		 = 'U':	 Upper triangle of A is stored;
		 = 'L':	 Lower triangle of A is stored.

       N (input) The number of linear equations, i.e., the order of the matrix
		 A.  N >= 0.

       NRHS (input)
		 The  number  of right hand sides, i.e., the number of columns
		 of the matrices B and X.  NRHS >= 0.

       A (input) COMPLEX array, dimension (N*(N+1)/2)
		 The upper or lower triangle of the Hermitian matrix A, packed
		 columnwise in a linear array.	The j-th column of A is stored
		 in the array A as follows: if UPLO = 'U', A(i + (j-1)*j/2)  =
		 A(i,j)	 for  1<=i<=j; if UPLO = 'L', A(i + (j-1)*(2*n-j)/2) =
		 A(i,j) for j<=i<=n.  See below for further details.

       AF (input or output) COMPLEX array, dimension (N*(N+1)/2)
		 If FACT = 'F', then AF is an input argument and on entry con‐
		 tains the block diagonal matrix D and the multipliers used to
		 obtain the factor U or L from the factorization A =  U*D*U**H
		 or  A	=  L*D*L**H  as computed by CHPTRF, stored as a packed
		 triangular matrix in the same storage format as A.

		 If FACT = 'N', then AF is an output argument and on exit con‐
		 tains the block diagonal matrix D and the multipliers used to
		 obtain the factor U or L from the factorization A =  U*D*U**H
		 or  A	=  L*D*L**H  as computed by CHPTRF, stored as a packed
		 triangular matrix in the same storage format as A.

       IPIVOT (input or output) INTEGER array, dimension (N)
		 If FACT = 'F', then IPIVOT is an input argument and on	 entry
		 contains  details of the interchanges and the block structure
		 of D, as determined by CHPTRF.	 If IPIVOT(k) > 0,  then  rows
		 and columns k and IPIVOT(k) were interchanged and D(k,k) is a
		 1-by-1 diagonal  block.   If  UPLO  =	'U'  and  IPIVOT(k)  =
		 IPIVOT(k-1)  <	 0,  then  rows and columns k-1 and -IPIVOT(k)
		 were interchanged and D(k-1:k,k-1:k)  is  a  2-by-2  diagonal
		 block.	  If  UPLO = 'L' and IPIVOT(k) = IPIVOT(k+1) < 0, then
		 rows and columns k+1 and  -IPIVOT(k)  were  interchanged  and
		 D(k:k+1,k:k+1) is a 2-by-2 diagonal block.

		 If  FACT = 'N', then IPIVOT is an output argument and on exit
		 contains details of the interchanges and the block  structure
		 of D, as determined by CHPTRF.

       B (input) COMPLEX array, dimension (LDB,NRHS)
		 The N-by-NRHS right hand side matrix B.

       LDB (input)
		 The leading dimension of the array B.	LDB >= max(1,N).

       X (output) COMPLEX array, dimension (LDX,NRHS)
		 If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X.

       LDX (input)
		 The leading dimension of the array X.	LDX >= max(1,N).

       RCOND (output)
		 The estimate of the reciprocal condition number of the matrix
		 A.  If RCOND is less than the machine precision (in  particu‐
		 lar,  if RCOND = 0), the matrix is singular to working preci‐
		 sion.	This condition is indicated by a return code of INFO >
		 0.

       FERR (output) REAL array, dimension (NRHS)
		 The  estimated	 forward  error bound for each solution vector
		 X(j) (the j-th column of the solution matrix X).  If XTRUE is
		 the  true solution corresponding to X(j), FERR(j) is an esti‐
		 mated upper bound for the magnitude of the largest element in
		 (X(j)	-  XTRUE) divided by the magnitude of the largest ele‐
		 ment in X(j).	The estimate is as reliable  as	 the  estimate
		 for  RCOND, and is almost always a slight overestimate of the
		 true error.

       BERR (output) (output) REAL array, dimension (NRHS)
		 The componentwise relative backward error  of	each  solution
		 vector	 X(j)  (i.e., the smallest relative change in any ele‐
		 ment of A or B that makes X(j) an exact solution).

       WORK (workspace)
		 COMPLEX array, dimension(2*N)

       WORK2 (workspace)
		 REAL array, dimension(N)

       INFO (output)
		 = 0: successful exit
		 < 0: if INFO = -i, the i-th argument had an illegal value
		 > 0:  if INFO = i, and i is
		 <= N:	D(i,i) is exactly zero.	 The  factorization  has  been
		 completed  but the factor D is exactly singular, so the solu‐
		 tion and error bounds could not be computed.  RCOND  =	 0  is
		 returned.   =	N+1:  D is nonsingular, but RCOND is less than
		 machine precision, meaning that the  matrix  is  singular  to
		 working  precision.   Nevertheless,  the  solution  and error
		 bounds are computed because there are a number of  situations
		 where	the  computed  solution	 can be more accurate than the
		 value of RCOND would suggest.

FURTHER DETAILS
       The packed storage scheme is illustrated by the following example  when
       N = 4, UPLO = 'U':

       Two-dimensional storage of the Hermitian matrix A:

	  a11 a12 a13 a14
	      a22 a23 a24
		  a33 a34     (aij = conjg(aji))
		      a44

       Packed storage of the upper triangle of A:

       A = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]

				  6 Mar 2009			    chpsvx(3P)
[top]

List of man pages available for OpenIndiana

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net