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

FreeBSD Manual Pages

  
 
  

home | help
PSLAPV2(l)			       )			    PSLAPV2(l)

NAME
       PSLAPV2	-  applie  either  P (permutation matrix indicated by IPIV) or
       inv(  P	)  to  a  M-by-N  distributed  matrix  sub(   A	  )   denoting
       A(IA:IA+M-1,JA:JA+N-1), resulting in row	or column pivoting

SYNOPSIS
       SUBROUTINE PSLAPV2( DIREC,  ROWCOL,  M,	N, A, IA, JA, DESCA, IPIV, IP,
			   JP, DESCIP )

	   CHARACTER	   DIREC, ROWCOL

	   INTEGER	   IA, IP, JA, JP, M, N

	   INTEGER	   DESCA( * ), DESCIP( * ), IPIV( * )

	   REAL		   A( *	)

PURPOSE
       PSLAPV2 applies either P	(permutation matrix indicated by IPIV) or inv(
       P   )   to   a	M-by-N	 distributed   matrix	sub(   A   )  denoting
       A(IA:IA+M-1,JA:JA+N-1), resulting in row	or column pivoting. The	 pivot
       vector  should  be aligned with the distributed matrix A.  For pivoting
       the rows	of sub(	A ), IPIV should be distributed	along a	process	column
       and  replicated	over all process rows.	Similarly, IPIV	should be dis-
       tributed	along a	process	row and	replicated over	 all  process  columns
       for column pivoting.

       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
       DIREC   (global input) CHARACTER
	       Specifies  in  which  order  the	 permutation is	applied: = 'F'
	       (Forward) Applies pivots	Forward	from top of matrix.   Computes
	       P  *  sub(  A  ); = 'B' (Backward) Applies pivots Backward from
	       bottom of matrix. Computes inv( P ) * sub( A ).

       ROWCOL  (global input) CHARACTER
	       Specifies if the	rows or	columns	are to be permuted: = 'R' Rows
	       will be permuted, = 'C' Columns will be permuted.

       M       (global input) INTEGER
	       The  number  of rows to be operated on, i.e. the	number of rows
	       of the distributed submatrix sub( A ). M	>= 0.

       N       (global input) INTEGER
	       The number of columns to	be operated on,	 i.e.  the  number  of
	       columns of the distributed submatrix sub( A ). N	>= 0.

       A       (local input/local output) REAL pointer into the
	       local  memory  to  an array of dimension	(LLD_A,	LOCc(JA+N-1)).
	       On entry, this local array contains the	local  pieces  of  the
	       distributed  matrix sub(	A ) to which the row or	columns	inter-
	       changes will be applied.	On exit, this array contains the local
	       pieces of the permuted distributed matrix.

       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.

       IPIV    (input) INTEGER array, dimension	>= LOCr(M_A)+MB_A if
	       ROWCOL  = 'R', LOCc(N_A)+NB_A otherwise.	It contains the	pivot-
	       ing information.	IPIV(i)	is the global row (column), local  row
	       (column)	 i  was	 swapped with.	The last piece of the array of
	       size MB_A (resp.	NB_A) is used as workspace. IPIV  is  tied  to
	       the distributed matrix A.

       IP      (global input) INTEGER
	       IPIV's  global  row index, which	points to the beginning	of the
	       submatrix which is to be	operated on.

       JP      (global input) INTEGER
	       IPIV's global column index, which points	to  the	 beginning  of
	       the submatrix which is to be operated on.

       DESCIP  (global and local input)	INTEGER	array of dimension 8
	       The array descriptor for	the distributed	matrix IPIV.

ScaLAPACK version 1.7		13 August 2001			    PSLAPV2(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

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

home | help