/home/abui...C/zher2k.f(3)

💅 ZHER2K — like, the hermitian rank 2k tea ☕✨

okay so this page is from the Library Functions Manual, and bestie, it's the manual entry for /home/abui...C/zher2k.f(3). yes the filename is literally that. we love a mysterious path. 🎀

---

🌸 NAME 🌸

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/BLAS/SRC/zher2k.f

(that's the whole name. it's giving "i live in a build directory and i'm proud of it". no cap. 💀)

---

✨ SYNOPSIS ✨

Functions/Subroutines

subroutine ZHER2K (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c,
    ldc)

ZHER2K — that's the icon, that's the moment. 👑

---

🦋 Function/Subroutine Documentation 🦋

the actual signature, verbatim, no edits fr fr

subroutine ZHER2K (character uplo, character trans, integer n, integer k,
    complex*16 alpha, complex*16, dimension(lda,*) a, integer lda,
    complex*16, dimension(ldb,*) b, integer ldb, double precision beta,
    complex*16, dimension(ldc,*) c, integer ldc)

ZHER2K

🎯 Purpose:

!>
!> ZHER2K  performs one of the hermitian rank 2k operations
!>
!>    C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C,
!>
!> or
!>
!>    C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C,
!>
!> where  alpha and beta  are scalars with  beta  real,  C is an  n by n
!> hermitian matrix and  A and B  are  n by k matrices in the first case
!> and  k by n  matrices in the second case.
!>

so basically: it does one of those two hermitian rank 2k ops. alpha and beta are scalars and beta is real (important, lowkey). C is n by n and hermitian. A and B are n by k in the first case, k by n in the second. periodt. 💜

---

👑 Parameters 👑

• UPLO

!>          UPLO is CHARACTER*1
!>           On  entry,   UPLO  specifies  whether  the  upper  or  lower
!>           triangular  part  of the  array  C  is to be  referenced  as
!>           follows:
!>
!>              UPLO = 'U' or 'u'   Only the  upper triangular part of  C
!>                                  is to be referenced.
!>
!>              UPLO = 'L' or 'l'   Only the  lower triangular part of  C
!>                                  is to be referenced.
!>

so on entry you tell it which triangle of C we're looking at. 'U' or 'u' = upper only, 'L' or 'l' = lower only. pick one bestie, it's not that deep 🫶

• TRANS

!>          TRANS is CHARACTER*1
!>           On entry,  TRANS  specifies the operation to be performed as
!>           follows:
!>
!>              TRANS = 'N' or 'n'    C := alpha*A*B**H          +
!>                                         conjg( alpha )*B*A**H +
!>                                         beta*C.
!>
!>              TRANS = 'C' or 'c'    C := alpha*A**H*B          +
!>                                         conjg( alpha )*B**H*A +
!>                                         beta*C.
!>

'N' or 'n' = first operation, 'C' or 'c' = second one. the whole vibe check of the call lives here. ✨

• N

!>          N is INTEGER
!>           On entry,  N specifies the order of the matrix C.  N must be
!>           at least zero.
!>

order of C, and it must be at least zero. no negatives, we don't do that here. 🙈

• K

!>          K is INTEGER
!>           On entry with  TRANS = 'N' or 'n',  K  specifies  the number
!>           of  columns  of the  matrices  A and B,  and on  entry  with
!>           TRANS = 'C' or 'c',  K  specifies the number of rows of the
!>           matrices  A and B.  K must be at least zero.
!>

so with TRANS = 'N' or 'n' it's the number of columns of A and B; with TRANS = 'C' or 'c' it's the number of rows. also must be at least zero. 💅

• ALPHA

!>          ALPHA is COMPLEX*16 .
!>           On entry, ALPHA specifies the scalar alpha.
!>

it's COMPLEX*16 and it's the scalar alpha. that's the whole story. 🍓

• A

!>          A is COMPLEX*16 array, dimension ( LDA, ka ), where ka is
!>           k  when  TRANS = 'N' or 'n',  and is  n  otherwise.
!>           Before entry with  TRANS = 'N' or 'n',  the  leading  n by k
!>           part of the array  A  must contain the matrix  A,  otherwise
!>           the leading  k by n  part of the array  A  must contain  the
!>           matrix A.
!>

COMPLEX*16 array, dimension ( LDA, ka ), where ka is k when TRANS = 'N' or 'n' and n otherwise. TRANS = 'N'/'n' → leading n by k part holds the matrix A; otherwise the leading k by n part does. iykyk 🌈

• LDA

!>          LDA is INTEGER
!>           On entry, LDA specifies the first dimension of A as declared
!>           in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
!>           then  LDA must be at least  max( 1, n ), otherwise  LDA must
!>           be at least  max( 1, k ).
!>

first dimension of A as declared in the calling (sub)program. TRANS = 'N'/'n' → LDA must be at least max( 1, n ); otherwise at least max( 1, k ). math, but make it fashion. 🔥

• B

!>          B is COMPLEX*16 array, dimension ( LDB, kb ), where kb is
!>           k  when  TRANS = 'N' or 'n',  and is  n  otherwise.
!>           Before entry with  TRANS = 'N' or 'n',  the  leading  n by k
!>           part of the array  B  must contain the matrix  B,  otherwise
!>           the leading  k by n  part of the array  B  must contain  the
!>           matrix B.
!>

same energy as A but for B: COMPLEX*16 array, dimension ( LDB, kb ), kb is k when TRANS = 'N'/'n' and n otherwise. 🦋

• LDB

!>          LDB is INTEGER
!>           On entry, LDB specifies the first dimension of B as declared
!>           in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
!>           then  LDB must be at least  max( 1, n ), otherwise  LDB must
!>           be at least  max( 1, k ).
!>           Unchanged on exit.
!>

first dimension of B as declared in the calling (sub)program; max( 1, n ) when TRANS = 'N'/'n', else max( 1, k ). and yes: Unchanged on exit. she said "i'm not moving, don't @ me". 💀

• BETA

!>          BETA is DOUBLE PRECISION .
!>           On entry, BETA specifies the scalar beta.
!>

DOUBLE PRECISION, it's the scalar beta. real one. 🎀

• C

!>          C is COMPLEX*16 array, dimension ( LDC, N )
!>           Before entry  with  UPLO = 'U' or 'u',  the leading  n by n
!>           upper triangular part of the array C must contain the upper
!>           triangular part  of the  hermitian matrix  and the strictly
!>           lower triangular part of C is not referenced.  On exit, the
!>           upper triangular part of the array  C is overwritten by the
!>           upper triangular part of the updated matrix.
!>           Before entry  with  UPLO = 'L' or 'l',  the leading  n by n
!>           lower triangular part of the array C must contain the lower
!>           triangular part  of the  hermitian matrix  and the strictly
!>           upper triangular part of C is not referenced.  On exit, the
!>           lower triangular part of the array  C is overwritten by the
!>           lower triangular part of the updated matrix.
!>           Note that the imaginary parts of the diagonal elements need
!>           not be set,  they are assumed to be zero,  and on exit they
!>           are set to zero.
!>

okay this one is the main character fr. COMPLEX*16 array, dimension ( LDC, N ).

• UPLO = 'U'/'u' → the leading n by n upper triangular part of C must contain the upper triangular part of the hermitian matrix, and the strictly lower triangular part is not referenced. on exit, the upper triangular part of C is overwritten by the upper triangular part of the updated matrix.
• UPLO = 'L'/'l' → the leading n by n lower triangular part of C must contain the lower triangular part of the hermitian matrix, and the strictly upper triangular part is not referenced. on exit, the lower triangular part of C is overwritten by the lower triangular part of the updated matrix.
• ⚠️ and bestie, note: the imaginary parts of the diagonal elements need not be set — they're assumed to be zero, and on exit they are set to zero. not me warning you politely 💅
• LDC

!>          LDC is INTEGER
!>           On entry, LDC specifies the first dimension of C as declared
!>           in  the  calling  (sub)  program.   LDC  must  be  at  least
!>           max( 1, n ).
!>

first dimension of C as declared in the calling (sub)program, and LDC must be at least max( 1, n ). no exceptions, slay. ⭐

---

🧚 Author 🧚

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

the whole squad behind it. icons only. 🫶

---

💖 Further Details: 💖

!>
!>  Level 3 Blas routine.
!>
!>  -- Written on 8-February-1989.
!>     Jack Dongarra, Argonne National Laboratory.
!>     Iain Duff, AERE Harwell.
!>     Jeremy Du Croz, Numerical Algorithms Group Ltd.
!>     Sven Hammarling, Numerical Algorithms Group Ltd.
!>
!>  -- Modified 8-Nov-93 to set C(J,J) to DBLE( C(J,J) ) when BETA = 1.
!>     Ed Anderson, Cray Research Inc.
!>

a Level 3 Blas routine, written 8-February-1989 by Jack Dongarra (Argonne National Laboratory), Iain Duff (AERE Harwell), Jeremy Du Croz (Numerical Algorithms Group Ltd.) and Sven Hammarling (Numerical Algorithms Group Ltd.). then modified 8-Nov-93 to set C(J,J) to DBLE( C(J,J) ) when BETA = 1, by Ed Anderson, Cray Research Inc. vintage but still serving looks. 🕰️👑

---

🌟 Definition 🌟

Definition at line 197 of file zher2k.f.

---

🎀 Author (the auto-gen one) 🎀

Generated automatically by Doxygen for LAPACK from the source code. (not a human, just a little robot doing its best 🫡)

---

okay bestie that's the whole page, no crumbs left. bye bestie, go call ZHER2K responsibly 💜✨

LAPACK — Version 3.12.0 🦋 /home/abui...C/zher2k.f(3)