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

FreeBSD Manual Pages

  
 
  

home | help
PZLARFC(l)			       )			    PZLARFC(l)

NAME
       PZLARFC - applie	a complex elementary reflector Q**H to a complex M-by-
       N distributed matrix sub( C ) = C(IC:IC+M-1,JC:JC+N-1),

SYNOPSIS
       SUBROUTINE PZLARFC( SIDE, M, N, V, IV, JV, DESCV, INCV, TAU, C, IC, JC,
			   DESCC, WORK )

	   CHARACTER	   SIDE

	   INTEGER	   IC, INCV, IV, JC, JV, M, N

	   INTEGER	   DESCC( * ), DESCV( *	)

	   COMPLEX*16	   C( *	), TAU(	* ), V(	* ), WORK( * )

PURPOSE
       PZLARFC applies a complex elementary reflector Q**H to a	complex	M-by-N
       distributed matrix sub( C ) = C(IC:IC+M-1,JC:JC+N-1), from  either  the
       left or the right. Q is represented in the form

	     Q = I - tau * v * v'

       where tau is a complex scalar and v is a	complex	vector.

       If tau =	0, then	Q is taken to be the unit matrix.

       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

       Because	vectors	may be viewed as a subclass of matrices, a distributed
       vector is considered to be a distributed	matrix.

       Restrictions
       ============

       If SIDE = 'Left'	and INCV = 1, then the row process  having  the	 first
       entry  V(IV,JV)	must  also  have  the first row	of sub(	C ). Moreover,
       MOD(IV-1,MB_V) must be equal to MOD(IC-1,MB_C), if INCV=M_V,  only  the
       last equality must be satisfied.

       If  SIDE	 =  'Right'  and INCV =	M_V then the column process having the
       first entry V(IV,JV) must also have the first column of sub(  C	)  and
       MOD(JV-1,NB_V)  must  be	 equal to MOD(JC-1,NB_C), if INCV = 1 only the
       last equality must be satisfied.

ARGUMENTS
       SIDE    (global input) CHARACTER
	       = 'L': form  Q**H * sub(	C ),
	       = 'R': form  sub( C ) * Q**H.

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

       V       (local input) COMPLEX*16	pointer	into the local memory
	       to an array of dimension	(LLD_V,*) containing the local	pieces
	       of  the	distributed  vectors  V	 representing  the Householder
	       transformation Q, V(IV:IV+M-1,JV) if SIDE = 'L' and INCV	= 1,
	       V(IV,JV:JV+M-1) if SIDE = 'L' and INCV =	M_V,
	       V(IV:IV+N-1,JV) if SIDE = 'R' and INCV =	1,
	       V(IV,JV:JV+N-1) if SIDE = 'R' and INCV =	M_V,

	       The vector v in the representation of Q.	V is not used if TAU =
	       0.

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

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

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

       INCV    (global input) INTEGER
	       The  global increment for the elements of V. Only two values of
	       INCV are	supported in this version, namely  1  and  M_V.	  INCV
	       must not	be zero.

       TAU     (local input) COMPLEX*16, array,	dimension  LOCc(JV) if
	       INCV  =	1,  and	 LOCr(IV)  otherwise.  This array contains the
	       Householder scalars related to the Householder vectors.	TAU is
	       tied to the distributed matrix V.

       C       (local input/local output) COMPLEX*16 pointer into the
	       local  memory  to an array of dimension (LLD_C, LOCc(JC+N-1) ),
	       containing the local pieces of sub( C ).	On exit, sub( C	 )  is
	       overwritten by the Q**H * sub( C	) if SIDE = 'L', or sub( C ) *
	       Q**H if SIDE = 'R'.

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

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

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

       WORK    (local workspace) COMPLEX*16 array, dimension (LWORK)
	       If INCV = 1, if SIDE = 'L', if IVCOL =  ICCOL,  LWORK  >=  NqC0
	       else  LWORK >= MpC0 + MAX( 1, NqC0 ) end	if else	if SIDE	= 'R',
	       LWORK  >=  NqC0	+  MAX(	 MAX(  1,  MpC0	 ),  NUMROC(   NUMROC(
	       N+ICOFFC,NB_V,0,0,NPCOL ),NB_V,0,0,LCMQ ) ) end if else if INCV
	       = M_V, if SIDE =	'L', LWORK >= MpC0 + MAX( MAX( 1, NqC0 ), NUM-
	       ROC(  NUMROC(  M+IROFFC,MB_V,0,0,NPROW ),MB_V,0,0,LCMP )	) else
	       if SIDE = 'R', if IVROW = ICROW,	LWORK >= MpC0  else  LWORK  >=
	       NqC0 + MAX( 1, MpC0 ) end if end	if end if

	       where  LCM  is the least	common multiple	of NPROW and NPCOL and
	       LCM = ILCM( NPROW, NPCOL	), LCMP	= LCM /	NPROW, LCMQ  =	LCM  /
	       NPCOL,

	       IROFFC =	MOD( IC-1, MB_C	), ICOFFC = MOD( JC-1, NB_C ), ICROW =
	       INDXG2P(	IC, MB_C, MYROW, RSRC_C, NPROW ), ICCOL	= INDXG2P( JC,
	       NB_C,  MYCOL,  CSRC_C,  NPCOL ),	MpC0 = NUMROC( M+IROFFC, MB_C,
	       MYROW, ICROW, NPROW ), NqC0 = NUMROC(  N+ICOFFC,	 NB_C,	MYCOL,
	       ICCOL, NPCOL ),

	       ILCM,  INDXG2P  and NUMROC are ScaLAPACK	tool functions;	MYROW,
	       MYCOL, NPROW and	NPCOL can be determined	by calling the subrou-
	       tine BLACS_GRIDINFO.

	       Alignment requirements ======================

	       The     distributed     submatrices     V(IV:*,	  JV:*)	   and
	       C(IC:IC+M-1,JC:JC+N-1) must verify some	alignment  properties,
	       namely the following expressions	should be true:

	       MB_V = NB_V,

	       If   INCV   =  1,  If  SIDE  =  'Left',	(  MB_V.EQ.MB_C	 .AND.
	       IROFFV.EQ.IROFFC	.AND. IVROW.EQ.ICROW ) If SIDE	=  'Right',  (
	       MB_V.EQ.NB_A  .AND.  MB_V.EQ.NB_C .AND. IROFFV.EQ.ICOFFC	) else
	       if  INCV	 =  M_V,  If  SIDE  =  'Left',	(  MB_V.EQ.NB_V	 .AND.
	       MB_V.EQ.MB_C  .AND.  ICOFFV.EQ.IROFFC  )	 If  SIDE = 'Right', (
	       NB_V.EQ.NB_C .AND. ICOFFV.EQ.ICOFFC .AND. IVCOL.EQ.ICCOL	)  end
	       if

ScaLAPACK version 1.7		13 August 2001			    PZLARFC(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

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

home | help