cspsvx man page on OpenIndiana

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

cspsvx(3P)		    Sun Performance Library		    cspsvx(3P)

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

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

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

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

       CHARACTER * 1 FACT, UPLO
       COMPLEX AP(*), 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 SPSVX(FACT, UPLO, [N], [NRHS], AP, AF, IPIVOT, B, [LDB], X,
	      [LDX], RCOND, FERR, BERR, [WORK], [WORK2], [INFO])

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

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

       CHARACTER(LEN=1) :: FACT, UPLO
       COMPLEX, DIMENSION(:) :: AP, 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 cspsvx(char fact, char uplo, int n, int nrhs, complex *ap, complex
		 *af,  int  *ipivot, complex *b, int ldb, complex *x, int ldx,
		 float *rcond, float *ferr, float *berr, int *info);

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

PURPOSE
       cspsvx  uses  the  diagonal  pivoting factorization A = U*D*U**T or A =
       L*D*L**T to compute the solution to a complex system  of	 linear	 equa‐
       tions A * X = B, where A is an N-by-N symmetric 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**T,	if UPLO = 'U', or
	     A = L * D * L**T,	if UPLO = 'L',
	  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.

       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.  AP, 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.

       AP (input)
		 Complex array, dimension (N*(N+1)/2) The upper or lower  tri‐
		 angle	of the symmetric matrix A, packed columnwise in a lin‐
		 ear array.  The j-th column of A is stored in the array AP as
		 follows:  if  UPLO  =	'U',  AP(i  +  (j-1)*j/2) = A(i,j) for
		 1<=i<=j; if UPLO = 'L', AP(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 contains the block diagonal
		 matrix D and the multipliers used to obtain the factor U or L
		 from the factorization A = U*D*U**T or A = L*D*L**T  as  com‐
		 puted	by CSPTRF, 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**T
		 or  A	=  L*D*L**T  as computed by CSPTRF, 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 inter‐
		 changes and the block structure of D, as determined  by  CSP‐
		 TRF.  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 CSPTRF.

       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)
		 If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X.

       LDX (input)
		 Complex  array, dimension (LDX,NRHS) 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)
		 Complex 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	corre‐
		 sponding to X(j), FERR(j) is an estimated upper bound for the
		 magnitude of the largest element in (X(j) - XTRUE) divided by
		 the  magnitude	 of the largest element 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)
		 Complex  array,  dimension  (NRHS) The componentwise relative
		 backward error of each solution vector X(j) (i.e., the small‐
		 est  relative change in any element of A or B that makes X(j)
		 an exact solution).

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

       WORK2 (workspace)
		 Integer 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 symmetric matrix A:

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

       Packed storage of the upper triangle of A:

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

				  6 Mar 2009			    cspsvx(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