### Check SLEPc Installation

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/quickstart.md

Runs test examples to verify a smooth installation. Examine the output for any errors.

```console
$ make check
```

--------------------------------

### Install Miniforge

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/faq.md

Install Miniforge in the user's home directory. This command executes the downloaded installer script with batch mode and specifies the installation path.

```console
$ bash Miniforge3-Linux-x86_64.sh -b -p ~/miniforge
```

--------------------------------

### Compiling the Example

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on8.md

Command to build the executable for the quadratic eigenvalue problem solver example.

```console
$ make ex16
```

--------------------------------

### SLEPc Prefix-based Installation with PETSc

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/intro.md

Prepare a prefix-based SLEPc installation by setting PETSC_DIR, unsetting PETSC_ARCH, configuring SLEPc with a prefix, and then building and installing.

```bash
export PETSC_DIR=/opt/petsc-{{env.config.release}}-linux-gnu-c-debug
unset PETSC_ARCH
cd $SLEPC_DIR
./configure --prefix=/opt/slepc-{{env.config.release}}-linux-gnu-c-debug
make
make install
export SLEPC_DIR=/opt/slepc-{{env.config.release}}-linux-gnu-c-debug
```

--------------------------------

### Install SLEPc

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/quickstart.md

Installs SLEPc if an installation directory was specified during configuration using the --prefix option. Useful for building as a regular user.

```console
$ make install
```

--------------------------------

### Command-line Example: Sequential Solves with Partitions

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/st.md

Example demonstrating parallel spectrum slicing using sequential linear solves by setting the number of partitions equal to the number of MPI processes. This configuration uses 4 partitions, each with one process.

```console
$ mpiexec -n 4 ./ex25 -eps_interval 0.4,0.8 -eps_krylovschur_partitions 4 -st_type sinvert -st_ksp_type preonly -st_pc_type cholesky
```

--------------------------------

### Install SLEPc from Source

Source: https://context7.com/slepc/slepc/llms.txt

Set environment variables for PETSc and SLEPc directories, then unpack, configure, build, and test SLEPc. Optional configurations include external packages like ARPACK, Python bindings, or a prefix-based install.

```bash
# Set environment variables
export PETSC_DIR=/home/user/petsc-3.25
export PETSC_ARCH=arch-linux-gnu-c-debug
export SLEPC_DIR=/home/user/slepc-3.25

# Unpack, configure, build and test
tar xzf slepc-3.25.tar.gz
cd slepc-3.25
./configure
make
make check

# With optional external packages (e.g., ARPACK)
./configure --with-arpack-dir=/usr/software/ARPACK

# With Python bindings (slepc4py)
./configure --with-slepc4py

# Prefix-based install
./configure --prefix=/opt/slepc-3.25
make && make install

# Run a parallel job (8 MPI processes)
mpiexec -n 8 ./my_slepc_program -eps_nev 10
```

--------------------------------

### Compile SLEPc Example

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on3.md

Instructions for compiling the ex7.c example program using a makefile. Ensure SLEPC_EPS_LIB and CLINKER are correctly set.

```makefile
ex7: ex7.o
	-${CLINKER} -o ex7 ex7.o ${SLEPC_EPS_LIB}
	${RM} ex7.o
```

--------------------------------

### Command-line Example: Parallel Solves with MUMPS

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/st.md

Example of parallel spectrum slicing using the MUMPS direct solver. This configuration uses 4 partitions and 20 MPI processes in total, with 5 processes per partition.

```console
$ mpiexec -n 20 ./ex25 -eps_interval 0.4,0.8 -eps_krylovschur_partitions 4 -st_type sinvert -st_ksp_type preonly -st_pc_type cholesky -st_pc_factor_mat_solver_type mumps -st_mat_mumps_icntl_13 1
```

--------------------------------

### PEP Solver Command-Line Options Example

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on8.md

Example of how to modify the behavior of the PEP solver using command-line arguments to request more eigenvalues, increase the basis vector size, select smallest magnitude eigenvalues, and set a different tolerance.

```console
$ ./ex16 -pep_nev 4 -pep_ncv 24 -pep_smallest_magnitude -pep_tol 1e-5
```

--------------------------------

### Install SLEPc with zypper (openSUSE)

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Install SLEPc using the zypper package manager on openSUSE.

```bash
sudo zypper install slepc
```

--------------------------------

### Download Miniforge Installer

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/faq.md

Download the Miniforge installer script for Linux x86_64. This is the first step in setting up a conda environment for installing slepc4py with complex scalars.

```console
$ wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh
```

--------------------------------

### Example Output

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on1.md

Sample output from running the 1-D Laplacian Eigenproblem solver, showing iteration count, convergence, and computed eigenvalues.

```text
1-D Laplacian Eigenproblem, n=50

 Number of iterations of the method: 8
 Solution method: krylovschur

 Number of requested eigenvalues: 1
 Stopping condition: tol=1e-08, maxit=100
 Number of converged eigenpairs: 3

           k          ||Ax-kx||
   ----------------- ------------------
       3.996207        4.30363e-10
       3.984841        2.08631e-09
       3.965946        9.98404e-09
```

--------------------------------

### Install NumPy and petsc4py using pip

Source: https://gitlab.com/slepc/slepc/-/blob/main/src/binding/slepc4py/docs/source/install.rst

Ensure you have NumPy and petsc4py installed before proceeding with slepc4py installation.

```bash
$ python -m pip install numpy petsc petsc4py
```

--------------------------------

### Makefile for PEP Solver Example

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on8.md

This snippet shows the necessary lines to add to a Makefile for compiling the ex16.c example for PEP solvers.

```makefile
ex16: ex16.o
	-${CLINKER} -o ex16 ex16.o ${SLEPC_PEP_LIB}
	${RM} ex16.o
```

--------------------------------

### Configure SLEPc Installation

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/intro.md

Run the configure script from the SLEPc directory to set up the build environment. This step should be performed after setting environment variables.

```console
$ cd $SLEPC_DIR
$ ./configure
```

--------------------------------

### Compile Example 11

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on7.md

Add these lines to your makefile to compile the ex11 executable. Ensure SLEPC_EPS_LIB is correctly set.

```makefile
ex11: ex11.o
	-${CLINKER} -o ex11 ex11.o ${SLEPC_EPS_LIB}
	${RM} ex11.o
```

--------------------------------

### Install First PETSc Configuration

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/intro.md

Set PETSC_ARCH and configure PETSc for a real scalar type. This creates a subdirectory for this specific configuration.

```console
$ cd $PETSC_DIR
$ export PETSC_ARCH=arch-linux-gnu-c-debug-real
$ ./configure --with-scalar-type=real
$ make all
```

--------------------------------

### Compile Executable with Make

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on1.md

Use this makefile snippet to compile the C example. Ensure SLEPc libraries are correctly linked.

```makefile
ex1: ex1.o
	-${CLINKER} -o ex1 ex1.o ${SLEPC_EPS_LIB}
	${RM} ex1.o
```

--------------------------------

### Command Line Example for Harmonic Extraction

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/eps.md

This command-line example demonstrates how to compute eigenvalues closest to a target value (0.8) for a real non-symmetric matrix. It also shows how to increase the number of non-symmetric Krylov dimensions (ncv) for potentially better convergence of interior eigenvalues.

```console
$ ./ex5 -m 45 -eps_harmonic -eps_target 0.8 -eps_ncv 60
```

--------------------------------

### Install SLEPc and PETSc for Python (Development)

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Install SLEPc and PETSc from their GitLab archives for development purposes, including necessary build tools and Python packages.

```bash
python -m pip install Cython numpy mpi4py
```

```bash
python -m pip install --no-deps https://gitlab.com/petsc/petsc/-/archive/main/petsc-main.tar.gz
```

```bash
python -m pip install --no-deps https://gitlab.com/slepc/slepc/-/archive/main/slepc-main.tar.gz
```

--------------------------------

### Install SLEPc with apt (Debian/Ubuntu)

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Install the SLEPc development package using apt on Debian or Ubuntu systems.

```bash
sudo apt install slepc-dev
```

--------------------------------

### Install SLEPc and PETSc for Python (Release)

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Install SLEPc and its Python bindings (slepc4py) along with necessary dependencies like numpy, mpi4py, and PETSc.

```bash
python -m pip install numpy mpi4py
```

```bash
python -m pip install petsc petsc4py
```

```bash
python -m pip install slepc slepc4py
```

--------------------------------

### Install slepc4py from SLEPc source tree

Source: https://gitlab.com/slepc/slepc/-/blob/main/src/binding/slepc4py/docs/source/install.rst

Install slepc4py from the SLEPc source tree by navigating to the top of the SLEPc source directory and running pip.

```bash
$ python -m pip install src/binding/slepc4py
```

--------------------------------

### Fortran Example for Eigenvalue Problem

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/extra.md

This is the Fortran equivalent of a simple example for solving eigenvalue problems. It requires including SLEPc header files.

```fortran
#include <slepc/finclude/slepceps.h>
!
! This example is the Fortran equivalent of the C example ex1.c
!
program main
  implicit none

   PetscErrorCode ierr
  PetscInt       n, m, nmax, k
  PetscScalar    ar(3,3), ai(3,3), br(3,3), bi(3,3)
  PetscScalar    *ritz, *crritz
  PetscReal      tol
  EPS            eps
  EPSType        type
  char           filename(PETSC_MAX_PATH_LEN)
  PetscBool      flg

  call SlepcInitialize(PETSC_NULL_CHARACTER, PETSC_NULL_CHARACTER, PETSC_NULL_CHARACTER, PETSC_NULL_CHARACTER, ierr)

  ierr = PetscOptionsGetInt(PETSC_NULL_HANDLE, '-n', n, flg, ierr)
  if (.not. flg) n = 3
  nmax = n
  k = 1
  if (n .gt. 3) k = 2
  if (n .gt. 10) k = 3

  ierr = EPSCreate(PETSC_COMM_WORLD, eps, ierr)
  ierr = EPSSetType(eps, EPSKRYLOV, ierr)
  ierr = EPSKrylovSetDimensions(eps, nmax, k, ierr)
  ierr = EPSSetWhichEigenpairs(eps, EPS_SMALLEST_REAL, ierr)

  ierr = EPSGetDimensions(eps, nmax, k, ierr)
  ierr = EPSGetTolerances(eps, tol, PETSC_NULL_INTEGER, ierr)
  ierr = EPSGetKrylovSubspaceDimension(eps, nmax, ierr)

  ierr = EPSSetFromOptions(eps, ierr)

  ! Construct the matrices A and B
  call ex1f_matrices(n, ar, ai, br, bi, ierr)

  ierr = EPSSetOperators(eps, n, ar, ai, br, bi, ierr)
  ierr = EPSPSetFromOptions(eps, ierr)

  ierr = EPSSolve(eps, ierr)

  ierr = EPSGetType(eps, type, ierr)
  ierr = PetscPrintf(PETSC_COMM_WORLD, 'Solution method: %s\n', type, ierr)

  ierr = EPSGetNumberEigenvalues(eps, n, ierr)
  ierr = PetscPrintf(PETSC_COMM_WORLD, 'Number of eigenvalues found: %D\n', n, ierr)

  ierr = PetscMalloc(n*sizeof(PetscScalar), ritz, ierr)
  ierr = PetscMalloc(n*sizeof(PetscScalar), crritz, ierr)
  ierr = EPSGetEigenvalues(eps, ritz, crritz, ierr)

  ierr = EPSIsGeneralized(eps, flg, ierr)
  if (flg) then
    ierr = PetscPrintf(PETSC_COMM_WORLD, '\nGeneralized Eigenvalue Problem:\n', ierr)
  else
    ierr = PetscPrintf(PETSC_COMM_WORLD, '\nStandard Eigenvalue Problem:\n', ierr)
  endif

  do i = 1, n
    ierr = PetscScalarPrint(ritz(i), PETSC_PRINT_STYLE_DEFAULT, ierr)
    if (crritz(i) .ne. 0.0) then
      ierr = PetscScalarPrint(crritz(i), PETSC_PRINT_STYLE_DEFAULT, ierr)
    endif
    ierr = PetscPrintf(PETSC_COMM_WORLD, '\n', ierr)
  end do

  ierr = EPSDestroy(eps, ierr)
  ierr = SlepcFinalize(ierr)
  stop
end program main

subroutine ex1f_matrices(n, ar, ai, br, bi, ierr)
  implicit none

  use petscts, only: PetscScalar, PETSC_COMM_WORLD
  use slepc, only: EPS

  integer, intent(in) :: n
  PetscScalar, intent(out) :: ar(3,3), ai(3,3), br(3,3), bi(3,3)
  PetscErrorCode ierr

  integer :: i, j

  do i = 1, n
    do j = 1, n
      ar(i,j) = 0.0
      ai(i,j) = 0.0
      br(i,j) = 0.0
      bi(i,j) = 0.0
    end do
  end do

  do i = 1, n
    ar(i,i) = -2.0
    br(i,i) = 1.0
    if (i .gt. 1) then
      ar(i-1,i) = 1.0
      ar(i,i-1) = 1.0
      br(i-1,i) = -0.5
      br(i,i-1) = -0.5
    end if
  end do

end subroutine ex1f_matrices

```

--------------------------------

### Install mpi4py using pip

Source: https://gitlab.com/slepc/slepc/-/blob/main/src/binding/slepc4py/docs/source/install.rst

Install mpi4py first if you have a working MPI implementation and the 'mpicc' compiler wrapper is on your search path.

```bash
$ python -m pip install mpi4py
```

--------------------------------

### Configure SLEPc Installation

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/quickstart.md

Runs the configure script in the SLEPc directory. Use --help for available options, especially for enabling external packages.

```console
$ ./configure
```

--------------------------------

### Run with Debugger

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on0.md

Execute a program with debugging support enabled. This will start the program in a debugger, stopped at the SlepcInitialize() function.

```console
./hello -start_in_debugger
```

--------------------------------

### Compile SVD executable

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on4.md

Add these lines to your makefile to compile the SVD example program. Ensure SLEPC_SVD_LIB is correctly set.

```make
ex14: ex14.o
	-${CLINKER} -o ex14 ex14.o ${SLEPC_SVD_LIB}
	${RM} ex14.o
```

--------------------------------

### Makefile for Matrix-Free Example

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on5.md

This makefile snippet shows how to link the object file with SLEPc libraries to create an executable for a matrix-free problem.

```makefile
ex3: ex3.o
	-${CLINKER} -o ex3 ex3.o ${SLEPC_EPS_LIB}
	${RM} ex3.o
```

--------------------------------

### Visualize Eigenvalues with Plotting

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on3.md

Run the ex7 program to compute multiple eigenpairs and visualize them using the 'draw' option. Requires X11 display setup.

```console
./ex7 -f1 ${SLEPC_DIR}/share/slepc/datafiles/matrices/bfw62a.petsc -f2 ${SLEPC_DIR}/share/slepc/datafiles/matrices/bfw62b.petsc -eps_type subspace -eps_nev 6 -eps_view_values draw -draw_pause -1
```

--------------------------------

### Check Spack Installation Specification

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/faq.md

Check the exact specification for installing py-slepc4py with PETSc complex scalars using spack. This command shows what packages and variants will be installed without actually performing the installation.

```console
$ spack spec py-slepc4py ^petsc+complex
```

--------------------------------

### Running the Program and Sample Output

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on8.md

Demonstrates how to run the compiled program without arguments and displays a sample of the expected output, showing converged eigenvalues and their associated norms.

```console
Quadratic Eigenproblem, N=100 (10x10 grid)

 Number of requested eigenvalues: 1

           k          ||P(k)x||/||kx||
   ----------------- ------------------
 -1.164037+1.653625i    2.02021e-12
 -1.164037-1.653625i    2.02021e-12
```

--------------------------------

### Set environment variables for pip installation

Source: https://gitlab.com/slepc/slepc/-/blob/main/src/binding/slepc4py/docs/source/install.rst

If you have existing PETSc and SLEPc installations, set the SLEPC_DIR and PETSC_DIR environment variables (and PETSC_ARCH if necessary) before installing via pip.

```bash
$ export SLEPC_DIR=/path/to/slepc
$ export PETSC_DIR=/path/to/petsc
$ export PETSC_ARCH=arch-linux2-c-opt
$ python -m pip install petsc4py slepc4py
```

--------------------------------

### Install slepc4py using pip

Source: https://gitlab.com/slepc/slepc/-/blob/main/src/binding/slepc4py/docs/source/install.rst

Install slepc4py from PyPI after its dependencies are met.

```bash
$ python -m pip install slepc slepc4py
```

--------------------------------

### Install SLEPc with MacPorts

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Install SLEPc using the MacPorts package manager.

```bash
sudo port install slepc
```

--------------------------------

### Install SLEPc with Homebrew

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Install SLEPc using the Homebrew package manager on macOS.

```bash
brew install slepc
```

--------------------------------

### Basic SVD Solver Usage in C

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/svd.md

This example demonstrates the fundamental steps for computing a singular value decomposition using the SLEPc SVD package. It covers creating the solver context, setting the problem matrix and type, invoking the solver, retrieving converged solutions, and cleaning up resources.

```c
SVD       svd;       /*  SVD solver context  */
Mat       A;         /*  problem matrix      */
Vec       u, v;      /*  singular vectors    */
PetscReal sigma;     /*  singular value      */
PetscInt  j, nconv;
PetscReal error;

SVDCreate(PETSC_COMM_WORLD, &svd);
SVDSetOperators(svd, A, NULL);
SVDSetProblemType(svd, SVD_STANDARD);
SVDSetFromOptions(svd);
SVDSolve(svd);
SVDGetConverged(svd, &nconv);
for (j=0;j<nconv;j++) {
  SVDGetSingularTriplet(svd, j, &sigma, u, v);
  SVDComputeError(svd, j, SVD_ERROR_RELATIVE, &error);
}
SVDDestroy(&svd);
```

--------------------------------

### Configure RII Solver Options

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/nep.md

Example command-line arguments for configuring the Residual Inverse Iteration (RII) solver, including lagging the preconditioner, setting KSP type, PC type, and controlling the correction tolerance.

```console
$ ./ex22 -nep_type rii -nep_rii_lag_preconditioner 2 -nep_rii_ksp_type bcgs -nep_rii_pc_type ilu -nep_rii_const_correction_tol 1 -nep_rii_ksp_rtol 1e-3
```

--------------------------------

### Install SLEPc with pacman (MSYS2)

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Install the SLEPc package for MSYS2 on Windows using pacman.

```bash
pacman -S mingw-w64-x86_64-slepc
```

--------------------------------

### Install SLEPc with Conda

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Use this command to install SLEPc via Conda, typically from the conda-forge channel.

```bash
conda install conda-forge::slepc
```

--------------------------------

### EPSSolve Example

Source: https://context7.com/slepc/slepc/llms.txt

Example of solving a standard non-Hermitian eigenvalue problem Ax=kx and retrieving converged eigenpairs.

```APIDOC
## EPSSolve

### Description
Solves the linear eigenvalue problem configured in the EPS object.

### Method
`EPSSolve(EPS eps)`

### Parameters
- `eps` (EPS) - The EPS solver context.

### Request Example
```c
PetscCall(EPSSolve(eps));
```

### Response
- `PetscErrorCode` - Returns an error code if the solve fails.

### Runtime Options Examples
- `-eps_type krylovschur`
- `-eps_nev 10 -eps_ncv 24`
- `-eps_target 1.5 -eps_target_magnitude`
- `-eps_monitor`
- `-eps_converged_reason`
```

--------------------------------

### Install SLEPc with Spack (Debug)

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/installation/index.md

Install SLEPc with debug symbols enabled using the Spack package manager.

```bash
spack install slepc +debug
```

--------------------------------

### Basic NEP Solution with Callbacks

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/nep.md

This example demonstrates the fundamental steps for solving a nonlinear eigenvalue problem using NEP. It involves creating the solver context, defining matrices and callback functions, setting options, solving the problem, and retrieving the results. Ensure matrices F and J are properly allocated and callback functions FormFunction and FormJacobian are defined.

```c
NEP         nep;
Mat         F, J;
Vec         xr, xi;
PetscScalar kr, ki;
ApplCtx     ctx;
PetscInt    j, nconv;
PetscReal   error;

NEPCreate(PETSC_COMM_WORLD, &nep);
/* create and preallocate F and J matrices */
NEPSetFunction(nep, F, F, FormFunction, &ctx);
NEPSetJacobian(nep, J, FormJacobian, &ctx);
NEPSetFromOptions(nep);
NEPSolve(nep);
NEPGetConverged(nep, &nconv);
for (j=0;j<nconv;j++) {
  NEPGetEigenpair(nep, j, &kr, &ki, xr, xi);
  NEPComputeError(nep, j, NEP_ERROR_RELATIVE, &error);
}
NEPDestroy(&nep);
```

--------------------------------

### Command Line Example: Quadratic Eigenproblem via Explicit Linearization

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/pep.md

Solves a quadratic eigenproblem using explicit linearization with specific configurations for shift-and-invert, linear solver, and matrix solver.

```console
$ ./sleeper -pep_type linear -pep_target -10 -pep_linear_st_type sinvert -pep_linear_st_ksp_type preonly -pep_linear_st_pc_type lu -pep_linear_st_pc_factor_mat_solver_type mumps -pep_linear_st_mat_mumps_icntl_14 100 -pep_explicitmatrix
```

--------------------------------

### Install slepc4py with multiple PETSC_ARCH

Source: https://gitlab.com/slepc/slepc/-/blob/main/src/binding/slepc4py/docs/source/install.rst

When installing from source, slepc4py supports multiple PETSC_ARCH values specified as a colon-separated list.

```bash
$ PETSC_ARCH='arch-0:...:arch-N' python -m pip install src/binding/slepc4py
```

--------------------------------

### Build Executable

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on1.md

Command to build the executable after setting up the makefile.

```console
$ make ex1
```

--------------------------------

### Command Line Example: Q-Arnoldi with Shift-and-Invert and Transform

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/pep.md

Computes eigenpairs closest to the origin using the Q-Arnoldi solver with shift-and-invert. The -st_transform flag is set by default for this configuration.

```console
$ ./ex16 -pep_nev 12 -pep_type qarnoldi -pep_target 0 -st_type sinvert -st_transform
```

--------------------------------

### Basic PEP Solver Usage in C

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/pep.md

This example demonstrates the fundamental steps for solving a polynomial eigenvalue problem using the PEP package. It covers context creation, setting operators, problem type, options, solving, retrieving results, and cleanup. Ensure coefficient matrices are properly defined before use.

```c
#define NMAT 5
Pep         pep;       /*  eigensolver context  */
Mat         A[NMAT];   /*  coefficient matrices */
Vec         xr, xi;    /*  eigenvector, x       */
PetscScalar kr, ki;    /*  eigenvalue, k        */
PetscInt    j, nconv;
PetscReal   error;

PEPCreate(PETSC_COMM_WORLD, &pep);
PepSetOperators(pep, NMAT, A);
PepSetProblemType(pep, PEP_GENERAL);  /* optional */
PepSetFromOptions(pep);
PEPSolve(pep);
PepGetConverged(pep, &nconv);
for (j=0;j<nconv;j++) {
  PepGetEigenpair(pep, j, &kr, &ki, xr, xi);
  PepComputeError(pep, j, PEP_ERROR_BACKWARD, &error);
}
PepDestroy(&pep);

```

--------------------------------

### Select Eigensolver at Runtime

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on1.md

Use this command-line option to specify the eigensolver type and its parameters when running an example. For instance, to use the LOBPCG solver with 4 vectors.

```console
$ ./ex1 -eps_nev 4 -eps_type lobpcg
```

--------------------------------

### Install slepc4py with Complex Scalars using Spack

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/faq.md

Install py-slepc4py along with PETSc configured with complex scalars using the spack package manager. Ensure the `petsc+complex` variant is selected.

```console
$ spack install py-slepc4py ^petsc+complex
```

--------------------------------

### Runtime Options for EPS Solver

Source: https://context7.com/slepc/slepc/llms.txt

This list provides examples of runtime options that can be used to configure the EPS solver, such as selecting the solver type, specifying the number of eigenvalues to compute, setting targets for spectral extraction, and enabling monitoring or displaying convergence reasons.

```text
-eps_type krylovschur        (default solver)
-eps_type arpack             (use ARPACK wrapper)
-eps_nev 10 -eps_ncv 24      (10 eigenvalues, subspace size 24)
-eps_target 1.5 -eps_target_magnitude  (eigenvalues closest to 1.5)
-eps_harmonic -eps_target 0.8   (harmonic extraction for interior eigenvalues)
-eps_monitor                 (print convergence each iteration)
-eps_error_relative          (show relative errors at end)
-eps_converged_reason        (show converge reason and iteration count)

```

--------------------------------

### C and Fortran Makefile Example for SLEPc

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/intro.md

This makefile demonstrates how to build both C and Fortran programs using SLEPc. Ensure you replace 'EPS' with the highest level module your program uses.

```c
default: ex1

include ${SLEPC_DIR}/lib/slepc/conf/slepc_common

ex1: ex1.o
	-${CLINKER} -o ex1 ex1.o ${SLEPC_EPS_LIB}
	${RM} ex1.o

ex1f: ex1f.o
	-${FLINKER} -o ex1f ex1f.o ${SLEPC_EPS_LIB}
	${RM} ex1f.o
```

--------------------------------

### Download and Configure f2cblaslapack

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/intro.md

Configure PETSc with the option to download and build the f2cblaslapack library. This is useful if SLEPc complains about missing LAPACK subroutines.

```console
--download-f2cblaslapack
```

--------------------------------

### Build Executable

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on2.md

Build the executable using the make command. This command compiles the source code and links it with the necessary SLEPc libraries.

```console
$ make ex5
```

--------------------------------

### Get Error Estimate

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/eps.md

Retrieves the error estimates computed internally by the eigensolver for the eigenpairs.

```APIDOC
## EPSGetErrorEstimate

### Description
Retrieves the error estimates computed internally by the eigensolver for the eigenpairs. These may differ from the error bounds provided by `EPSComputeError()`.

### Signature
```c
EPSGetErrorEstimate(EPS eps,PetscInt k,PetscReal *error);
```

### Parameters
*   **eps** (EPS) - The eigensolver context.
*   **k** (PetscInt) - The index of the eigenpair for which to get the error estimate.
*   **error** (PetscReal *) - Pointer to store the error estimate.
```

--------------------------------

### Initialize SLEPc, PETSc, and MPI

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/intro.md

Call this function at the beginning of your SLEPc program. It initializes SLEPc, PETSc, and MPI. The arguments are similar to PetscInitialize().

```c
SlepcInitialize(int *argc,char ***args,const char file[],const char help[]);
```

--------------------------------

### Get Left Eigenvector

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/eps.md

Retrieves the left eigenvector corresponding to the j-th computed eigenpair, if available.

```APIDOC
## EPSGetLeftEigenvector

### Description
Retrieves the left eigenvector associated with the j-th computed eigenpair.

### Method
```c
EPSGetLeftEigenvector(EPS eps, PetscInt j, Vec yr, Vec yi);
```

### Parameters
*   **eps** (EPS) - The EPS context.
*   **j** (PetscInt) - The index of the left eigenvector to retrieve.
*   **yr** (Vec) - Vector to store the real part of the left eigenvector.
*   **yi** (Vec) - Vector to store the imaginary part of the left eigenvector.

### Notes
This function is only applicable if left eigenvectors are computed and available.
```

--------------------------------

### Makefile Integration for SLEPc Applications

Source: https://context7.com/slepc/slepc/llms.txt

Example Makefile for building application programs against SLEPc. It shows the required environment variables and how to include the SLEPc common makefile to automatically set compiler and linker flags.

```makefile
# Makefile for a SLEPc application

# Required environment variables:
#   SLEPC_DIR, PETSC_DIR, PETSC_ARCH

default: myapp

include ${SLEPC_DIR}/lib/slepc/conf/slepc_common
```

--------------------------------

### Spectrum Slicing Command Line Example

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/pep.md

Use this command to perform spectrum slicing for a Hermitian PEP, specifying the interval and solver type. Ensure the problem type is set correctly for hyperbolic problems if eigenvalues from both groups are included.

```console
$ ./spring -n 300 -pep_hermitian -pep_interval -10.1,-9.5 -pep_type stoar -st_type sinvert -st_ksp_type preonly -st_pc_type cholesky
```

--------------------------------

### Get Number of Converged Eigenpairs

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/hands-on/hands-on1.md

Retrieves the count of eigenpairs that have successfully converged during the solution process.

```c
EPSGetConverged(EPS eps, PetscInt *nconv);
```

--------------------------------

### KSP Convergence Failure Example

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/st.md

Illustrates a PETSc error message indicating that the KSP solver did not converge.

```c
[0]PETSC ERROR: KSP did not converge (reason=DIVERGED_ITS)!
```

--------------------------------

### Command-line Equivalents for EPS Configuration

Source: https://context7.com/slepc/slepc/llms.txt

This section lists command-line options that correspond to the programmatic settings shown in the previous C code snippet for configuring the EPS solver, including setting the number of eigenvalues, target value, spectral transformation type, and interval.

```text
-eps_nev 6 -eps_target 2.0 -eps_target_magnitude
-st_type sinvert -st_shift 2.0
-eps_interval 1.0,3.0
-eps_two_sided

```

--------------------------------

### Get Iteration Number from MFN

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/mfn.md

Retrieves the number of (outer) iterations performed by the MFN solver after it has finished.

```c
MFNGetIterationNumber(MFN mfn,PetscInt *its);
```

--------------------------------

### Build and Run SLEPc Application

Source: https://context7.com/slepc/slepc/llms.txt

Build an application using make and run it with MPI, specifying SLEPc solver options.

```bash
# Build and run
make myapp
mpiexec -n 4 ./myapp -eps_nev 10 -eps_type krylovschur -eps_monitor
```

--------------------------------

### Retrieve KSP Object in C

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/documentation/manual/st.md

Gets the KSP object associated with an ST object in C for programmatic configuration.

```c
STGetKSP(ST st,KSP *ksp);
```

--------------------------------

### Command-line Options for PEP Solvers

Source: https://gitlab.com/slepc/slepc/-/blob/main/doc/source/about/index.md

Provides examples of command-line usage for Polynomial Eigenvalue Problem (PEP) solvers in SLEPc, illustrating options for setting the number of eigenvalues, tolerance, solver type, and linearization methods.

```console
$ ./expep -pep_nev 6 -pep_tol 1e-5
```

```console
$ ./expep -pep_type linear -pep_linear_linearization 1,0 -pep_linear_explicitmatrix
```

```console
$ ./expep -pep_type toar
```