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

FreeBSD Manual Pages

  
 
  

home | help
PSLARZB(l)			       )			    PSLARZB(l)

NAME
       PSLARZB	-  applie  a real block	reflector Q or its transpose Q**T to a
       real distributed	M-by-N matrix sub( C ) = C(IC:IC+M-1,JC:JC+N-1)

SYNOPSIS
       SUBROUTINE PSLARZB( SIDE, TRANS,	DIRECT,	STOREV,	M, N, K, L, V, IV, JV,
			   DESCV, T, C,	IC, JC,	DESCC, WORK )

	   CHARACTER	   DIRECT, SIDE, STOREV, TRANS

	   INTEGER	   IC, IV, JC, JV, K, L, M, N

	   INTEGER	   DESCC( * ), DESCV( *	)

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

PURPOSE
       PSLARZB	applies	 a  real  block	reflector Q or its transpose Q**T to a
       real distributed	M-by-N matrix sub( C ) =  C(IC:IC+M-1,JC:JC+N-1)  from
       the left	or the right.

       Q is a product of k elementary reflectors as returned by	PSTZRZF.

       Currently, only STOREV =	'R' and	DIRECT = 'B' are supported.

       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
       SIDE    (global input) CHARACTER
	       = 'L': apply Q or Q**T from the Left;
	       = 'R': apply Q or Q**T from the Right.

       TRANS   (global input) CHARACTER
	       = 'N':  No transpose, apply Q;
	       = 'T':  Transpose, apply	Q**T.

       DIRECT  (global input) CHARACTER
	       Indicates  how H	is formed from a product of elementary reflec-
	       tors = 'F': H = H(1) H(2) . . . H(k)  (Forward,	not  supported
	       yet)
	       = 'B': H	= H(k) . . . H(2) H(1) (Backward)

       STOREV  (global input) CHARACTER
	       Indicates  how  the vectors which define	the elementary reflec-
	       tors are	stored:
	       = 'C': Columnwise			(not supported yet)
	       = 'R': Rowwise

       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.

       K       (global input) INTEGER
	       The order of the	matrix T (= the	number of  elementary  reflec-
	       tors whose product defines the block reflector).

       L       (global input) INTEGER
	       The  columns  of	 the distributed submatrix sub(	A ) containing
	       the meaningful part of the Householder reflectors.  If  SIDE  =
	       'L', M >= L >= 0, if SIDE = 'R',	N >= L >= 0.

       V       (local input) REAL pointer into the local memory
	       to  an  array of	dimension (LLD_V, LOCc(JV+M-1))	if SIDE	= 'L',
	       (LLD_V, LOCc(JV+N-1)) if	SIDE =	'R'.  It  contains  the	 local
	       pieces  of  the	distributed  vectors V representing the	House-
	       holder  transformation  as  returned  by	 PSTZRZF.   LLD_V   >=
	       LOCr(IV+K-1).

       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.

       T       (local input) REAL array, dimension MB_V	by MB_V
	       The  lower  triangular  matrix  T  in the representation	of the
	       block reflector.

       C       (local input/local output) REAL pointer into the
	       local memory to an array	of dimension (LLD_C,LOCc(JC+N-1)).  On
	       entry,  the M-by-N distributed matrix sub( C ). On exit,	sub( C
	       ) is overwritten	by Q*sub( C ) or Q'*sub( C ) or	sub( C )*Q  or
	       sub( C )*Q'.

       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  STOREV  =  'C', if SIDE = 'L', LWORK	>= ( NqC0 + MpC0 ) * K
	       else if SIDE = 'R', LWORK >= ( NqC0 + MAX( NpV0 + NUMROC(  NUM-
	       ROC(  N+ICOFFC, NB_V, 0,	0, NPCOL ), NB_V, 0, 0,	LCMQ ),	MpC0 )
	       ) * K end if else if STOREV = 'R', if SIDE = 'L',  LWORK	 >=  (
	       MpC0  + MAX( MqV0 + NUMROC( NUMROC( M+IROFFC, MB_V, 0, 0, NPROW
	       ), MB_V,	0, 0, LCMP ), NqC0 ) ) * K else	if SIDE	=  'R',	 LWORK
	       >= ( MpC0 + NqC0	) * K end if end if

	       where LCMQ = LCM	/ NPCOL	with LCM = ICLM( NPROW,	NPCOL ),

	       IROFFV =	MOD( IV-1, MB_V	), ICOFFV = MOD( JV-1, NB_V ), IVROW =
	       INDXG2P(	IV, MB_V, MYROW, RSRC_V, NPROW ), IVCOL	= INDXG2P( JV,
	       NB_V,  MYCOL,  CSRC_V,  NPCOL ),	MqV0 = NUMROC( M+ICOFFV, NB_V,
	       MYCOL, IVCOL, NPCOL ), NpV0 = NUMROC(  N+IROFFV,	 MB_V,	MYROW,
	       IVROW, NPROW ),

	       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 ), NpC0 = NUMROC(  N+ICOFFC,	 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:

	       If STOREV = 'Columnwise'	If SIDE	= 'Left', ( MB_V.EQ.MB_C .AND.
	       IROFFV.EQ.IROFFC	 .AND.	IVROW.EQ.ICROW	) If SIDE = 'Right', (
	       MB_V.EQ.NB_C .AND. IROFFV.EQ.ICOFFC ) else if  STOREV  =	 'Row-
	       wise' If	SIDE = 'Left', ( NB_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			    PSLARZB(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

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

home | help