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

FreeBSD Manual Pages

  
 
  

home | help
PCUNG2R(l)			       )			    PCUNG2R(l)

NAME
       PCUNG2R	-  generate  an	 M-by-N	 complex distributed matrix Q denoting
       A(IA:IA+M-1,JA:JA+N-1) with orthonormal columns,	which  is  defined  as
       the  first N columns of a product of K elementary reflectors of order M
       Q = H(1)	H(2)

SYNOPSIS
       SUBROUTINE PCUNG2R( M, N, K, A, IA, JA, DESCA, TAU, WORK, LWORK,	INFO )

	   INTEGER	   IA, INFO, JA, K, LWORK, M, N

	   INTEGER	   DESCA( * )

	   COMPLEX	   A( *	), TAU(	* ), WORK( * )

PURPOSE
       PCUNG2R generates an  M-by-N  complex  distributed  matrix  Q  denoting
       A(IA:IA+M-1,JA:JA+N-1)  with  orthonormal  columns, which is defined as
       the first N columns of a	product	of K elementary	reflectors of order  M
       Q = H(1)	H(2) . . . H(k)	as returned by PCGEQRF.

       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
       M       (global input) INTEGER
	       The  number of rows to be operated on i.e the number of rows of
	       the distributed submatrix Q. M >= 0.

       N       (global input) INTEGER
	       The number of columns to	be operated on i.e the number of  col-
	       umns of the distributed submatrix Q. M >= N >= 0.

       K       (global input) INTEGER
	       The  number  of elementary reflectors whose product defines the
	       matrix Q. N >= K	>= 0.

       A       (local input/local output) COMPLEX pointer into the
	       local memory to an array	of dimension (LLD_A,LOCc(JA+N-1)).  On
	       entry,  the  j-th  column must contain the vector which defines
	       the elementary reflector	H(j), JA <= j <= JA+K-1,  as  returned
	       by   PCGEQRF   in   the	 K   columns  of  its  array  argument
	       A(IA:*,JA:JA+K-1). On  exit,  this  array  contains  the	 local
	       pieces of the M-by-N distributed	matrix Q.

       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.

       TAU     (local input) COMPLEX, array, dimension LOCc(JA+K-1).
	       This array contains the scalar factors TAU(j) of	the elementary
	       reflectors H(j) as returned by PCGEQRF.	TAU  is	 tied  to  the
	       distributed matrix A.

       WORK    (local workspace/local output) COMPLEX 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 >= MpA0 + MAX(	1, NqA0	), where

	       IROFFA =	MOD( IA-1, MB_A	), ICOFFA = MOD( JA-1, NB_A ), IAROW =
	       INDXG2P(	IA, MB_A, MYROW, RSRC_A, NPROW ), IACOL	= INDXG2P( JA,
	       NB_A,  MYCOL,  CSRC_A,  NPCOL ),	MpA0 = NUMROC( M+IROFFA, MB_A,
	       MYROW, IAROW, NPROW ), NqA0 = NUMROC(  N+ICOFFA,	 NB_A,	MYCOL,
	       IACOL, NPCOL ),

	       INDXG2P	and NUMROC are ScaLAPACK tool functions; MYROW,	MYCOL,
	       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.

       INFO    (local 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			    PCUNG2R(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

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

home | help