Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
PSGECON(l)			       )			    PSGECON(l)

NAME
       PSGECON	- estimate the reciprocal of the condition number of a general
       distributed real	matrix A(IA:IA+N-1,JA:JA+N-1), in either the 1-norm or
       the infinity-norm, using	the LU factorization computed by PSGETRF

SYNOPSIS
       SUBROUTINE PSGECON( NORM,  N,  A,  IA,  JA,  DESCA, ANORM, RCOND, WORK,
			   LWORK, IWORK, LIWORK, INFO )

	   CHARACTER	   NORM

	   INTEGER	   IA, INFO, JA, LIWORK, LWORK,	N

	   REAL		   ANORM, RCOND

	   INTEGER	   DESCA( * ), IWORK( *	)

	   REAL		   A( *	), WORK( * )

PURPOSE
       PSGECON estimates the reciprocal	of the condition number	of  a  general
       distributed real	matrix A(IA:IA+N-1,JA:JA+N-1), in either the 1-norm or
       the infinity-norm, using	the LU factorization computed by PSGETRF.   An
       estimate	is obtained for	norm(inv(A(IA:IA+N-1,JA:JA+N-1))), and the re-
       ciprocal	of the condition number	is computed as
		  RCOND	= 1 / (	norm( A(IA:IA+N-1,JA:JA+N-1)	  ) *
				norm( inv(A(IA:IA+N-1,JA:JA+N-1)) ) ).

       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 as-
       sume that its process grid has dimension	p x q.
       LOCr(  K	) denotes the number of	elements of K that a process would re-
       ceive if	K were distributed over	the p processes	of its process column.
       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
       NORM    (global input) CHARACTER
	       Specifies whether the 1-norm condition number or	the  infinity-
	       norm condition number is	required:
	       = '1' or	'O':  1-norm
	       = 'I':	      Infinity-norm

       N       (global input) INTEGER
	       The  order of the distributed matrix A(IA:IA+N-1,JA:JA+N-1).  N
	       >= 0.

       A       (local input) REAL pointer into the local memory
	       to an array of dimension	( LLD_A,  LOCc(JA+N-1)	).  On	entry,
	       this  array  contains  the  local pieces	of the factors L and U
	       from the	factorization A(IA:IA+N-1,JA:JA+N-1) = P*L*U; the unit
	       diagonal	elements of L are not stored.

       IA      (global input) INTEGER
	       The row index in	the global array A indicating the first	row of
	       sub( A ).

       JA      (global input) INTEGER
	       The column index	in the global array  A	indicating  the	 first
	       column of sub( A	).

       DESCA   (global and local input)	INTEGER	array of dimension DLEN_.
	       The array descriptor for	the distributed	matrix A.

       ANORM   (global input) REAL
	       If  NORM	 =  '1'	or 'O',	the 1-norm of the original distributed
	       matrix A(IA:IA+N-1,JA:JA+N-1).  If NORM =  'I',	the  infinity-
	       norm of the original distributed	matrix A(IA:IA+N-1,JA:JA+N-1).

       RCOND   (global output) REAL
	       The  reciprocal	of the condition number	of the distributed ma-
	       trix A(IA:IA+N-1,JA:JA+N-1), computed as
	       RCOND = 1 / ( norm( A(IA:IA+N-1,JA:JA+N-1)      ) *
	       norm( inv(A(IA:IA+N-1,JA:JA+N-1)) ) ).

       WORK    (local workspace/local output) REAL array,
	       dimension (LWORK) On exit, WORK(1) returns the minimal and  op-
	       timal LWORK.

       LWORK   (local or global	input) INTEGER
	       The dimension of	the array WORK.	 LWORK is local	input and must
	       be   at	 least	  LWORK	   >=	 2*LOCr(N+MOD(IA-1,MB_A))    +
	       2*LOCc(N+MOD(JA-1,NB_A))	  +   MAX(   2,	  MAX(	 NB_A*MAX(  1,
	       CEIL(NPROW-1,NPCOL) ), LOCc(N+MOD(JA-1,NB_A))  +	 NB_A*MAX(  1,
	       CEIL(NPCOL-1,NPROW) ) ).

	       LOCr  and  LOCc values can be computed using the	ScaLAPACK tool
	       function	NUMROC;	NPROW and NPCOL	can be determined  by  calling
	       the subroutine BLACS_GRIDINFO.

	       If LWORK	= -1, then LWORK is global input and a workspace query
	       is assumed; the routine only calculates the minimum and optimal
	       size  for  all work arrays. Each	of these values	is returned in
	       the first entry of the corresponding work array,	and  no	 error
	       message is issued by PXERBLA.

       IWORK   (local workspace/local output) INTEGER array,
	       dimension  (LIWORK)  On	exit, IWORK(1) returns the minimal and
	       optimal LIWORK.

       LIWORK  (local or global	input) INTEGER
	       The dimension of	the array IWORK.  LIWORK is  local  input  and
	       must be at least	LIWORK >= LOCr(N+MOD(IA-1,MB_A)).

	       If  LIWORK  =  -1,  then	LIWORK is global input and a workspace
	       query is	assumed; the routine only calculates the  minimum  and
	       optimal	size  for all work arrays. Each	of these values	is re-
	       turned in the first entry of the	corresponding work array,  and
	       no error	message	is issued by PXERBLA.

       INFO    (global output) INTEGER
	       = 0:  successful	exit
	       <  0:   If the i-th argument is an array	and the	j-entry	had an
	       illegal value, then INFO	= -(i*100+j), if the i-th argument  is
	       a scalar	and had	an illegal value, then INFO = -i.

ScaLAPACK version 1.7		13 August 2001			    PSGECON(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=psgecon&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help