la_geamv(3)

📦
version 3.12.1 · 9 versions
, in arch rolling

💅 la_geamv(3) — the group-chat guide 💅

okay so bestie, welcome to la_geamv(3) from the Library Functions Manual. This is the one about matrix-vector multiply with |A| * |x|, general flavored. Four routines, all doing the same iconic thing in different precisions. Let's get into it 🫶

✨ NAME ✨

la_geamv — la_geamv: matrix-vector multiply |A| * |x|, general. that's the whole vibe. absolute values everywhere, no cap.

🦋 SYNOPSIS 🦋

🌈 Functions 🌈

  • subroutine cla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) — CLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds. the complex one 💜
  • subroutine dla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) — DLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds. the double precision one ✨
  • subroutine sla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) — SLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds. the real single precision one 🌸
  • subroutine zla_geamv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) — ZLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds. the double complex one 👑

like… same energy, different types. pick your flavor 🍓

🌟 Detailed Description 🌟

(that's it. that's the section. the real tea is all down below 👇)

🔥 Function Documentation 🔥

💅 subroutine cla_geamv 💅

subroutine cla_geamv (integer trans, integer m, integer n, real alpha,
    complex, dimension( lda, * ) a, integer lda, complex, dimension( * ) x,
    integer incx, real beta, real, dimension( * ) y, integer incy)

CLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds. periodt.

🎀 Purpose 🎀

lowkey the whole point of this function, straight from the source:

!>
!> CLA_GEAMV  performs one of the matrix-vector operations
!>
!>         y := alpha*abs(A)*abs(x) + beta*abs(y),
!>    or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),
!>
!> where alpha and beta are scalars, x and y are vectors and A is an
!> m by n matrix.
!>
!> This function is primarily used in calculating error bounds.
!> To protect against underflow during evaluation, components in
!> the resulting vector are perturbed away from zero by (N+1)
!> times the underflow threshold.  To prevent unnecessarily large
!> errors for block-structure embedded in general matrices,
!>  zero components are not perturbed.  A zero
!> entry is considered  if all multiplications involved
!> in computing that entry have at least one zero multiplicand.
!>

so basically: it's for error bounds 🫶 and it nudges tiny components away from zero by (N+1) times the underflow threshold so underflow doesn't wreck the evaluation. but zero entries stay zero — a zero entry counts as zero if every multiplication that went into computing it had at least one zero multiplicand. it's giving "protect the vibe, not the zeros" 💀

🌸 Parameters 🌸

  • TRANS — TRANS is INTEGER. on entry, TRANS specifies the operation to be performed, like so:
BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)
BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)
BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)

unchanged on exit. yes bestie, BLAS_TRANS and BLAS_CONJ_TRANS give you the same line here — that's literally what the page says, don't come for me 🙈

  • M — M is INTEGER. on entry, M specifies the number of rows of the matrix A. M must be at least zero. unchanged on exit.
  • N — N is INTEGER. on entry, N specifies the number of columns of the matrix A. N must be at least zero. unchanged on exit.
  • ALPHA — ALPHA is REAL. on entry, ALPHA specifies the scalar alpha. unchanged on exit.
  • A — A is COMPLEX array, dimension (LDA,n). before entry, the leading m by n part of the array A must contain the matrix of coefficients. unchanged on exit.
  • LDA — LDA is INTEGER. on entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least max( 1, m ). unchanged on exit.
  • X — X is COMPLEX array, dimension ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. before entry, the incremented array X must contain the vector x. unchanged on exit.
  • INCX — INCX is INTEGER. on entry, INCX specifies the increment for the elements of X. INCX must not be zero. unchanged on exit. 🚫 no zero increments, that's the rule.
  • BETA — BETA is REAL. on entry, BETA specifies the scalar beta. when BETA is supplied as zero then Y need not be set on input. unchanged on exit. (free pass when it's zero, we love efficiency ✨)
  • Y — Y is REAL array, dimension ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. before entry with BETA non-zero, the incremented array Y must contain the vector y. on exit, Y is overwritten by the updated vector y. if either m or n is zero, then Y not referenced and the function performs a quick return. 🏃‍♀️💨
  • INCY — INCY is INTEGER. on entry, INCY specifies the increment for the elements of Y. INCY must not be zero. unchanged on exit.
Level 2 Blas routine. that's the whole note, and honestly? iconic.

👑 Author 👑

  • Univ. of Tennessee
  • Univ. of California Berkeley
  • Univ. of Colorado Denver
  • NAG Ltd.

⭐ Definition ⭐

Definition at line 175 of file cla_geamv.f.

🦋 subroutine dla_geamv 🦋

subroutine dla_geamv (integer trans, integer m, integer n, double precision
    alpha, double precision, dimension( lda, * ) a, integer lda, double
    precision, dimension( * ) x, integer incx, double precision beta, double
    precision, dimension( * ) y, integer incy)

DLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds. same assignment, double precision era 💜

🎀 Purpose 🎀

!>
!> DLA_GEAMV  performs one of the matrix-vector operations
!>
!>         y := alpha*abs(A)*abs(x) + beta*abs(y),
!>    or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),
!>
!> where alpha and beta are scalars, x and y are vectors and A is an
!> m by n matrix.
!>
!> This function is primarily used in calculating error bounds.
!> To protect against underflow during evaluation, components in
!> the resulting vector are perturbed away from zero by (N+1)
!> times the underflow threshold.  To prevent unnecessarily large
!> errors for block-structure embedded in general matrices,
!>  zero components are not perturbed.  A zero
!> entry is considered  if all multiplications involved
!> in computing that entry have at least one zero multiplicand.
!>

identical purpose, identical nudge by (N+1) times the underflow threshold, identical "zeros stay zero" energy. it's consistent, and we respect that 💅

🌸 Parameters 🌸

  • TRANS — TRANS is INTEGER. on entry, TRANS specifies the operation to be performed as follows:
BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)
BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)
BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)

unchanged on exit.

  • M — M is INTEGER. on entry, M specifies the number of rows of the matrix A. M must be at least zero. unchanged on exit.
  • N — N is INTEGER. on entry, N specifies the number of columns of the matrix A. N must be at least zero. unchanged on exit.
  • ALPHA — ALPHA is DOUBLE PRECISION. on entry, ALPHA specifies the scalar alpha. unchanged on exit.
  • A — A is DOUBLE PRECISION array, dimension ( LDA, n ). before entry, the leading m by n part of the array A must contain the matrix of coefficients. unchanged on exit.
  • LDA — LDA is INTEGER. on entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least max( 1, m ). unchanged on exit.
  • X — X is DOUBLE PRECISION array, dimension ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. before entry, the incremented array X must contain the vector x. unchanged on exit.
  • INCX — INCX is INTEGER. on entry, INCX specifies the increment for the elements of X. INCX must not be zero. unchanged on exit.
  • BETA — BETA is DOUBLE PRECISION. on entry, BETA specifies the scalar beta. when BETA is supplied as zero then Y need not be set on input. unchanged on exit.
  • Y — Y is DOUBLE PRECISION array, dimension at least ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. before entry with BETA non-zero, the incremented array Y must contain the vector y. on exit, Y is overwritten by the updated vector y. if either m or n is zero, then Y not referenced and the function performs a quick return. 🙈
  • INCY — INCY is INTEGER. on entry, INCY specifies the increment for the elements of Y. INCY must not be zero. unchanged on exit.
Level 2 Blas routine. still iconic, still true.

👑 Author 👑

  • Univ. of Tennessee
  • Univ. of California Berkeley
  • Univ. of Colorado Denver
  • NAG Ltd.

⭐ Definition ⭐

Definition at line 174 of file dla_geamv.f.

🌈 subroutine sla_geamv 🌈

subroutine sla_geamv (integer trans, integer m, integer n, real alpha, real,
    dimension( lda, * ) a, integer lda, real, dimension( * ) x, integer
    incx, real beta, real, dimension( * ) y, integer incy)

SLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds. single precision bestie, real numbers only, still slaying 🌸

🎀 Purpose 🎀

(the tea continues in part 2, don't go anywhere 🫶)

🌸 Parameters 🌸

okay so sla_geamv rolls with ten arguments and every single one has a whole personality — let's go 💅

  • TRANS — INTEGER. on entry, this tells us which operation we're doing, and the menu is:
BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)
BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)
BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)

unchanged on exit, bestie ✨

  • M — INTEGER. on entry it's the number of rows of the matrix A. M has to be at least zero (M >= 0, no cap 🥲). unchanged on exit.
  • N — INTEGER. on entry it's the number of columns of the matrix A. N must be at least zero too. unchanged on exit.
  • ALPHA — REAL. on entry it's the scalar alpha. unchanged on exit. she's just vibing, not changing.
  • A — REAL array, dimension ( LDA, n ). before entry, the leading m by n part of the array A must contain the matrix of coefficients 🔥. unchanged on exit.
  • LDA — INTEGER. on entry it's the first dimension of A as declared in the calling (sub) program. LDA must be at least max( 1, m ). unchanged on exit.
  • X — REAL array, dimension ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n', and at least ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. before entry, the incremented array X must contain the vector x. unchanged on exit 🦋
  • INCX — INTEGER. on entry it's the increment for the elements of X. INCX must not be zero — fr fr, do not do that 🚫. unchanged on exit.
  • BETA — REAL. on entry it's the scalar beta. and here's the cute part: when BETA is supplied as zero, Y doesn't even need to be set on input, she's off the hook 💅. unchanged on exit.
  • Y — REAL array, dimension at least ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n', and at least ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. before entry with BETA non-zero, the incremented array Y must contain the vector y. on exit, Y is overwritten by the updated vector y — she's been through a whole transformation, periodt. and if either m or n is zero, then Y is not referenced and the function performs a quick return 🏃‍♀️💨
  • INCY — INTEGER. on entry it's the increment for the elements of Y. INCY must not be zero (same rule, no exceptions). unchanged on exit.
Level 2 Blas routine. that's the whole flex. icon behavior only 👑

👑 Author 👑

  • Univ. of Tennessee
  • Univ. of California Berkeley
  • Univ. of Colorado Denver
  • NAG Ltd.

definition at line 174 of file sla_geamv.f. the receipts are right there 🧾

🦋 subroutine zla_geamv 🦋

the complex edition, and honestly she ate:

subroutine zla_geamv (integer trans, integer m, integer n, double precision
    alpha, complex*16, dimension( lda, * ) a, integer lda, complex*16,
    dimension( * ) x, integer incx, double precision beta, double precision,
    dimension( * ) y, integer incy)

ZLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds. same job, bigger numbers, more sparkle ✨

💜 Purpose 💜

okay so ZLA_GEAMV performs one of these matrix-vector operations:

y := alpha*abs(A)*abs(x) + beta*abs(y),

or

y := alpha*abs(A)**T*abs(x) + beta*abs(y),

where alpha and beta are scalars, x and y are vectors, and A is an m by n matrix.

this function is primarily used in calculating error bounds. to protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. that's the safety net, she's got your back 🫶

to prevent unnecessarily large errors for block-structure embedded in general matrices, zero components are not perturbed. and a zero entry is considered if all multiplications involved in computing that entry have at least one zero multiplicand. iykyk — that's the whole rule 💀

🎀 Parameters 🎀

same ten besties, but now with complex energy:

  • TRANS — INTEGER. on entry, TRANS specifies the operation to be performed as follows:
BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)
BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)
BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)

unchanged on exit.

  • M — INTEGER. on entry, M specifies the number of rows of the matrix A. M must be at least zero. unchanged on exit.
  • N — INTEGER. on entry, N specifies the number of columns of the matrix A. N must be at least zero. unchanged on exit.
  • ALPHA — DOUBLE PRECISION. on entry, ALPHA specifies the scalar alpha. unchanged on exit.
  • A — COMPLEX*16 array, dimension ( LDA, n ). before entry, the leading m by n part of the array A must contain the matrix of coefficients. unchanged on exit.
  • LDA — INTEGER. on entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least max( 1, m ). unchanged on exit.
  • X — COMPLEX*16 array, dimension at least ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. before entry, the incremented array X must contain the vector x. unchanged on exit 🌈
  • INCX — INTEGER. on entry, INCX specifies the increment for the elements of X. INCX must not be zero. unchanged on exit.
  • BETA — DOUBLE PRECISION. on entry, BETA specifies the scalar beta. when BETA is supplied as zero then Y need not be set on input. unchanged on exit.
  • Y — DOUBLE PRECISION array, dimension ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. before entry with BETA non-zero, the incremented array Y must contain the vector y. on exit, Y is overwritten by the updated vector y. and if either m or n is zero, then Y is not referenced and the function performs a quick return 😴
  • INCY — INTEGER. on entry, INCY specifies the increment for the elements of Y. INCY must not be zero. unchanged on exit.
Level 2 Blas routine. again. consistency is the moment 👏

🌟 Author 🌟

  • Univ. of Tennessee
  • Univ. of California Berkeley
  • Univ. of Colorado Denver
  • NAG Ltd.

definition at line 175 of file zla_geamv.f. and that's the complex receipt, stamped and everything 🧾✨

🫶 Author 🫶

generated automatically by Doxygen for LAPACK from the source code. so like, a robot wrote this one, but she understood the assignment ngl 🤖💖

aaaand that's a wrap bestie 🎀 this whole page is from LAPACK, Version 3.12.0, and it's dated la_geamv(3) — go forth, call your error bounds, and slay 💅✨🔥

📦 where this page comes from