Reduction from Generalized to Standard Form (HEGST)#

Background#

HEGST (symmetric or HErmitian Generalized eigenproblem to STandard form) reduces a batched symmetric or Hermitian-definite generalized eigenvalue problem to a standard form. It is typically used when an eigenproblem involves two matrices, \(A\) and \(B\). After \(B\) has been factored by Cholesky, HEGST transforms \(A\) so that a standard Hermitian or symmetric eigensolver, such as HEEV, can be applied to the resulting single-matrix problem.

Consider the generalized eigensolver problem:

\[\begin{split}\begin{aligned} A V = B V \Lambda \quad & (\text{Eig type} = 1), \\ A B V = V \Lambda \quad & (\text{Eig type} = 2), \\ B A V = V \Lambda \quad & (\text{Eig type} = 3). \end{aligned}\end{split}\]

where

  • \(A\) is an \(M \times M\) symmetric or Hermitian matrix,

  • \(B\) is an \(M \times M\) symmetric or Hermitian positive-definite matrix, already Cholesky factorized,

  • \(\Lambda\) is an \(M \times M\) diagonal matrix containing the eigenvalues, and

  • \(V\) is an \(M \times M\) unitary matrix containing the eigenvectors.

Note

\(\Lambda\) and \(V\) are not solved by the function HEGST. They are the eigenvalues and eigenvectors of the generalized, Hermitian-definite eigenvalue problem, and can be obtained after solving the reduced standard form problem.

Device API#

The cuSolverDx hegst device functions are as follows (see Execution Methods):

// Reduction using default, compile-time LeadingDimensions of A and B
__device__ void execute(data_type* A, const data_type* B, data_type* workspace);

// Runtime leading dimensions
__device__ void execute(data_type* A, const data_type* B, const unsigned int ldb,
                        data_type* workspace);
__device__ void execute(data_type* A, const unsigned int lda, const data_type* B,
                        const unsigned int ldb, data_type* workspace);
__device__ void execute(data_type* A, const unsigned int lda, const data_type* B,
                        const unsigned int ldb, data_type* workspace);

Parameters:

  • A: Batched \(M \times M\) Hermitian matrix, with leading dimension \(\mathrm{lda} \geq M\). On entry, the matrix data in the triangle selected by the FillMode operator is the stored triangular part of \(A\). On exit, that triangle is overwritten with the transformed matrix \(C\) (see below). The matrix data in the opposite triangle is left unchanged.

  • B: Batched \(M \times M\) input symmetric or Hermitian positive-definite matrix, with leading dimension \(\mathrm{ldb} \geq M\), already Cholesky factorized. The Cholesky triangle is stored in \(B\) in the same fill mode as \(A\).

  • workspace: Temporary buffer preallocated by the user. The required size can be obtained via workspace_size. Note that depending on the size and configuration of the problem, the workspace size could be zero. Use a nullptr if the required workspace size is zero.

EigType#

The congruence \(C\) is computed depending on EigType operator, with \(\mathrm{EigType} \in \{1,2,3\}\), matching LAPACK’s itype argument in the {he,sy}gst functions:

  • EigType 1 — use the inverse Cholesky factor:

    • If \(A\) is Lower fill: \(C = L^{-1} A L^{-H}\).

    • If \(A\) is Upper fill: \(C = U^{-H} A U^{-1}\).

  • EigType 2 or 3 — use the Cholesky factor without inversion:

    • If \(A\) is Lower fill: \(C = L^{H} A L\).

    • If \(A\) is Upper fill: \(C = U A U^{H}\).

Supported Configurations#

  1. Arrangement: Layouts of A and the Cholesky factor in B can independently use column-major or row-major layouts using the Arrangement<Arr, Brr> operator (see Arrangement operator).

  2. Leading Dimensions: Leading dimensions for A and B can be set independently using the LeadingDimension<LDA, LDB> operator (see LeadingDimension operator).

  3. Fill mode: A and the stored factor in B have to be the same FillMode (lower or upper). The operator is required to be defined for hegst.

  4. EigType: \(\mathrm{EigType} \in \{1,2,3\}\), as described above (see EigType Operator), and if omitted, the default is EigType<1>.