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

FreeBSD Manual Pages

  
 
  

home | help
PSLARF(l)			       )			     PSLARF(l)

NAME
       PSLARF -	applie a real elementary reflector Q (or Q**T) to a real M-by-
       N distributed matrix sub( C ) = C(IC:IC+M-1,JC:JC+N-1), from either the
       left or the right

SYNOPSIS
       SUBROUTINE PSLARF( 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( * )

	   REAL		  C( * ), TAU( * ), V( * ), WORK( * )

PURPOSE
       PSLARF applies a	real elementary	reflector Q (or	Q**T) to a real	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 real scalar and v	is a real 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 *	sub( C ),
	       = 'R': form  sub( C ) * Q, Q = Q**T.

       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) REAL 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) REAL, 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) REAL 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 * sub( C ) if SIDE = 'L', or sub( C	) *  Q
	       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) REAL 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			     PSLARF(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

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

home | help