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

FreeBSD Manual Pages

  
 
  

home | help
PDLACPY(l)			       )			    PDLACPY(l)

NAME
       PDLACPY	-  copie all or	part of	a distributed matrix A to another dis-
       tributed	matrix B

SYNOPSIS
       SUBROUTINE PDLACPY( UPLO, M, N, A, IA, JA, DESCA, B, IB,	JB, DESCB )

	   CHARACTER	   UPLO

	   INTEGER	   IA, IB, JA, JB, M, N

	   INTEGER	   DESCA( * ), DESCB( *	)

	   DOUBLE	   PRECISION A(	* ), B(	* )

PURPOSE
       PDLACPY copies all or part of a distributed matrix A  to	 another  dis-
       tributed	 matrix	 B.  No	communication is performed, PDLACPY performs a
       local  copy  sub(  A  )	:=  sub(  B  ),	 where	sub(   A   )   denotes
       A(IA:IA+M-1,JA:JA+N-1) and sub( B ) denotes B(IB:IB+M-1,JB:JB+N-1).

       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
       UPLO    (global input) CHARACTER
	       Specifies  the  part  of	 the distributed matrix	sub( A ) to be
	       copied:
	       = 'U':	Upper triangular part is copied;  the  strictly	 lower
	       triangular  part	 of sub( A ) is	not referenced;	= 'L':	 Lower
	       triangular part is copied; the strictly upper  triangular  part
	       of  sub(	 A  ) is not referenced; Otherwise:  All of the	matrix
	       sub( A )	is copied.

       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 col-
	       umns of the distributed submatrix sub( A	). N >=	0.

       A       (local input) DOUBLE PRECISION pointer into the local memory
	       to an array of dimension	(LLD_A,	 LOCc(JA+N-1)  ).  This	 array
	       contains	the local pieces of the	distributed matrix sub(	A ) to
	       be copied from.

       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.

       B       (local output) DOUBLE PRECISION pointer into the	local memory
	       to an array of dimension	(LLD_B,	 LOCc(JB+N-1)  ).  This	 array
	       contains	 on  exit  the	local pieces of	the distributed	matrix
	       sub( B )	set as follows:

	       if UPLO = 'U', B(IB+i-1,JB+j-1)	=  A(IA+i-1,JA+j-1),  1<=i<=j,
	       1<=j<=N;	 if  UPLO  = 'L', B(IB+i-1,JB+j-1) = A(IA+i-1,JA+j-1),
	       j<=i<=M,	   1<=j<=N;    otherwise,	 B(IB+i-1,JB+j-1)    =
	       A(IA+i-1,JA+j-1), 1<=i<=M, 1<=j<=N.

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

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

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

ScaLAPACK version 1.7		13 August 2001			    PDLACPY(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

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

home | help