PSRSCL(l)

📦 version 1.5, in ubuntu jammy

💖 PSRSCL — the "divide my whole vector by a scalar" bestie 💖

okay so real talk, this is PSRSCL from the LAPACK auxiliary routines (the l in the corner means it's a library routine, not a driver). She's a ScaLAPACK girlie: she takes an N-element real distributed vector sub( X ) and divides the whole thing by the real scalar a — aka multiplies by 1/a. Slay. 💅

✨ SYNOPSIS ✨

SUBROUTINE PSRSCL( N, SA, SX, IX, JX, DESCX, INCX )

    INTEGER        IX, INCX, JX, N

    REAL           SA

    INTEGER        DESCX( * )

    REAL           SX( * )

🎯 PURPOSE 🎯

PSRSCL multiplies an N-element real distributed vector sub( X ) by the real scalar 1/a. This is done without overflow or underflow as long as the final result sub( X )/a does not overflow or underflow. no cap, that's the whole point — she's careful about it. 🫶

where sub( X ) denotes:

  • X(IX:IX+N-1,JX:JX), if INCX = 1
  • X(IX:IX,JX:JX+N-1), if INCX = M_X

📝 Notes

Each global data object is described by an associated description vector. This vector stores the information required to establish the mapping 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".

okay here's the whole notation vibe check, one bullet at a time because tables are not the moment:

  • DT_A — stored in descA[ DT_ ] — (global) The descriptor type. In this case, DT_A = 1.
  • CTXT_A — stored in descA[ CTXT_ ] — (global) The BLACS context handle, indicating the BLACS process grid A is distributed over. The context itself is global, but the handle (the integer value) may vary.
  • M_A — stored in descA[ M_ ] — (global) The number of rows in the global array A.
  • N_A — stored in descA[ N_ ] — (global) The number of columns in the global array A.
  • MB_A — stored in descA[ MB_ ] — (global) The blocking factor used to distribute the rows of the array.
  • NB_A — stored in descA[ NB_ ] — (global) The blocking factor used to distribute the columns of the array.
  • RSRC_A — stored in descA[ RSRC_ ] — (global) The process row over which the first row of the array A is distributed.
  • CSRC_A — stored in descA[ CSRC_ ] — (global) The process column over which the first column of the array A is distributed.
  • LLD_A — stored in descA[ LLD_ ] — (local) 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 assume that its process grid has dimension p x q.

LOCr( K ) denotes the number of elements of K that a process would receive 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 seen as particular matrices, a distributed vector is considered to be a distributed matrix. 🦋 (yes bestie, a vector is just a matrix with extra steps. iconic.)

🌸 ARGUMENTS 🌸

  • N — (global input) pointer to INTEGER — The number of components of the distributed vector sub( X ). N >= 0.
  • SA — (global input) REAL — The scalar a which is used to divide each component of sub( X ). SA must be >= 0, or the subroutine will divide by zero. 🚨
okay so genuinely: SA must be >= 0 or she divides by zero. do not do that to her. that's the whole warning. 💀
  • SX — (local input/local output) REAL array — containing the local pieces of a distributed matrix of dimension of at least ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) ). This array contains the entries of the distributed vector sub( X ).
  • IX — (global input) pointer to INTEGER — The global row index of the submatrix of the distributed matrix X to operate on.
  • JX — (global input) pointer to INTEGER — The global column index of the submatrix of the distributed matrix X to operate on.
  • DESCX — (global and local input) INTEGER array of dimension 8. The array descriptor of the distributed matrix X.
  • INCX — (global input) pointer to INTEGER — The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
ngl, that last one is a whole mood: only 1 and M_X are supported in this version. anything else is not invited to the party. 🙈

and that's the whole page, bestie ✨ go forth and divide responsibly 🎀

this was PSRSCL(l), from LAPACK auxiliary routine version 1.5, dated 12 May 1997 — yes she's vintage, she's still that girl, and she's still serving. periodt. 👑💜

📦 where this page comes from