• Standard eigenvalue problem, Ax = \lambda x, either for Hermitian or non-Hermitian matrices.
• Generalized eigenvalue problem, Ax = \lambda Bx, either Hermitian positive-definite or not.
• Partial singular value decomposition of a rectangular matrix, Au = \sigma v.
• Generalized singular values of a matrix pair, Ax = cu, Bx = sv.
• Polynomial eigenvalue problem, P(\lambda)=0.
• Nonlinear eigenvalue problem, T(\lambda)=0.
• Computing the action of a matrix function on a vector, w=f(\alpha A)v.

• Krylov eigensolvers, particularly Krylov-Schur, Arnoldi, and Lanczos.
• Davidson-type eigensolvers, including Generalized Davidson and Jacobi-Davidson.
• Subspace iteration and single vector iterations (inverse iteration, RQI).
• Conjugate gradient methods such as LOBPCG.
• A contour integral solver using high-order moments.

• Use an eigensolver via the cross-product matrix A^*A or the cyclic matrix \left[\begin{smallmatrix}0&A\\A^*&0\end{smallmatrix}\right].
• Explicitly restarted Lanczos bidiagonalization.
• Implicitly restarted Lanczos bidiagonalization (thick-restart Lanczos).
• A basic randomized solver.

• Use an eigensolver to solve the generalized eigenvalue problem obtained after linearization.
• TOAR and Q-Arnoldi, memory efficient variants of Arnoldi for polynomial eigenproblems.
• Jacobi-Davidson for polynomial eigenproblems.
• A contour integral solver using high-order moments.

• Solve a polynomial eigenproblem obtained via polynomial interpolation.
• Rational interpolation and linearization (NLEIGS).
• Newton-type methods such as SLP or RII.
• A subspace projection method (nonlinear Arnoldi).
• A contour integral solver using high-order moments.

• Spectral transformations, such as shift-and-invert. This technique implicitly uses the inverse of the shifted matrix A-\sigma I in order to compute eigenvalues closest to a given target value, \sigma.
• Harmonic extraction, a cheap alternative to shift-and-invert that also tries to approximate eigenvalues closest to a target, \sigma, but without requiring a matrix inversion.

• High computational efficiency, by using NumPy and SLEPc under the hood.
• Data-structure neutral implementation, by using efficient sparse matrix storage provided by PETSc. Implicit matrix representation is also available by providing basic operations such as matrix-vector products as user-defined Python functions.
• Run-time flexibility, by specifying numerous setting at the command line.
• Ability to do the computation in parallel and/or using GPUs.

EPS

The Eigenvalue Problem Solver is the component that provides all the functionality necessary to define and solve an eigenproblem. It provides mechanisms for completely specifying the problem: the problem type (e.g. standard symmetric), number of eigenvalues to compute, part of the spectrum of interest. Once the problem has been defined, a collection of solvers can be used to compute the required solutions. The behavior of the solvers can be tuned by means of a few parameters, such as the maximum dimension of the subspace to be used during the computation.

SVD

This component is the analog of EPS for the case of Singular Value Decompositions. The user provides a rectangular matrix and specifies how many singular values and vectors are to be computed, whether the largest or smallest ones, as well as some other parameters for fine tuning the computation. Different solvers are available, as in the case of EPS.

PEP

This component is the analog of EPS for the case of Polynomial Eigenvalue Problems. The user provides the coefficient matrices of the polynomial. Several parameters can be specified, as in the case of EPS. It is also possible to indicate whether the problem belongs to a special type, e.g., symmetric or gyroscopic.

NEP

This component covers the case of general nonlinear eigenproblems, T(\lambda)=0. The user provides the parameter-dependent matrix T via the split form or by means of callback functions.

MFN

This component provides the functionality for computing the action of a matrix function on a vector. Given a matrix A and a vector b, the call MFNSolve(mfn,b,x) computes x=f(A)b, where f is a function such as the exponential.

LME

This component provides the functionality for solving linear matrix equations such as Lyapunov or Sylvester where the solution has low rank.

ST

The Spectral Transformation is a component that provides convenient implementations of common spectral transformations. These are simple transformations that map eigenvalues to different positions, in such a way that convergence to wanted eigenvalues is enhanced. The most common spectral transformation is shift-and-invert, that allows for the computation of eigenvalues closest to a given target value.

BV

This component encapsulates the concept of a set of Basis Vectors spanning a vector space. This component provides convenient access to common operations such as orthogonalization of vectors. The BV component is usually not required by end-users.

DS

The Dense System (or Direct Solver) component, used internally to solve dense eigenproblems of small size that appear in the course of iterative eigensolvers.

FN

A component used to define mathematical functions. This is required by the end-user for instance to define function T(\cdot) when solving nonlinear eigenproblems with NEP in split form.

RG

A component used to define a region of the complex plane such as an ellipse or a rectangle. This is required by end-users in some cases such as contour-integral eigensolvers.

• slepc4py Reference <#reference> (manual pages for all slepc4py classes and methods).
• SLEPc documentation <https://slepc.upv.es/release/documentation>.
• petsc4py documentation <https://petsc.org/release/petsc4py>.

•

To get started, we recommend having a look at the source code of example demo/ex1.py, that has comments inserted inline. It is also available online here <../slepc4py/demo/ex1.html>. This example solves a standard symmetric eigenvalue problem.

•

Demo examples for other problems, including linear and nonlinear eigenvalue problems and singular value problems, are available in the section slepc4py demos <#demos>.

• L. Dalcin, P. Kler, R. Paz, and A. Cosimo, Parallel Distributed Computing using Python, Advances in Water Resources, 34(9):1124-1139, 2011. <https://doi.org/10.1016/j.advwatres.2011.04.013>
• V. Hernandez, J.E. Roman, and V. Vidal, SLEPc: A scalable and flexible toolkit for the solution of eigenvalue problems, ACM Transactions on Mathematical Software, 31(3):351-362, 2005. <https://doi.org/10.1145/1089014.1089019>

• Update to SLEPc 3.24.
• Support (opt-in via setting the environment variable SLEPC4PY_BUILD_PYSABI=1) for building with Py_LIMITED_API (Python Stable ABI) under Python 3.10+ (requires Cython 3.1+).
• Add support for standard Python operators for BV <#slepc4py.SLEPc.BV> and FN <#slepc4py.SLEPc.FN> classes.
• Add new LME <#slepc4py.SLEPc.LME> class.

•

Update to SLEPc 3.23.

• Update to SLEPc 3.22.
• In slepc4py now EPS.getEigenpair() <#slepc4py.SLEPc.EPS.getEigenpair> and EPS.getEigenvalue() <#slepc4py.SLEPc.EPS.getEigenvalue> will return a real value instead of a complex, if the problem is of Hermitian or generalized Hermitian type.

•

Update to SLEPc 3.21.

•

Update to SLEPc 3.20.

•

Update to SLEPc 3.19.

•

Update to SLEPc 3.18.

•

Update to SLEPc 3.17.

•

Update to SLEPc 3.16.

• Update to SLEPc 3.15.
• Updates in installation scripts.

•

Update to SLEPc 3.14.

•

Update to SLEPc 3.13.

•

Update to SLEPc 3.12.

•

Update to SLEPc 3.11.

•

Update to SLEPc 3.10.

•

Update to SLEPc 3.9.

•

Update to SLEPc 3.8.

•

Update to SLEPc 3.7.

•

Update to SLEPc 3.6.

• Update to SLEPc 3.5.
• Add RG class introduced in SLEPc 3.5 release.
• Add PySlepcXXX_New/Get C API functions.
• Fix compilation problem with complex scalars on OS X.
• Fix outdated SWIG interface file.

•

Update to SLEPc 3.4.

• Update to SLEPc 3.3.
• Regenerate the wrappers using Cython 0.18 and fix binary compatibility issues with petsc4py 3.3.1.

•

Update to SLEPc 3.2.

• Support for new QEP quadratic eigenproblem solver in SLEPc.
• Support for pip install slepc4py to download and install SLEPc.
• Support for PETSc/SLEPc static library builds (Linux-only).
• Preliminary support for Python 3.

•

This is the fist release of the all-new, Cython-based, implementation of SLEPc for Python.

slepc4py.get_config()

Return a dictionary with information about SLEPc.

slepc4py.get_include()

Return the directory in the package that contains header files.

Extension modules that need to compile against slepc4py should use this function to locate the appropriate include directory.

Example

Using Python distutils or NumPy distutils:

import petscc4py, slepc4py
Extension('extension_name', ...


          include_dirs=[...,


                        petsc4py.get_include(),


                        slepc4py.get_include(),])

slepc4py.init(args=None, arch=None, comm=None)

Initialize SLEPc.

Notes

This function should be called only once, typically at the very beginning of the bootstrap script of an application.

slepc4py.typing.Scalar = float | complex

Scalar type.

Scalars can be either float <https://docs.python.org/3/library/functions.html#float> or complex <https://docs.python.org/3/library/functions.html#complex> (but not both) depending on how PETSc was configured (./configure --with-scalar-type=real|complex).

slepc4py.typing.ArrayInt

Array of int <https://docs.python.org/3/library/functions.html#int>.

alias of ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[int <https://docs.python.org/3/library/functions.html#int>]]

slepc4py.typing.ArrayReal

Array of float <https://docs.python.org/3/library/functions.html#float>.

alias of ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float>]]

slepc4py.typing.ArrayComplex

Array of complex <https://docs.python.org/3/library/functions.html#complex>.

alias of ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[complex <https://docs.python.org/3/library/functions.html#complex>]]

slepc4py.typing.ArrayScalar

Array of Scalar <#slepc4py.typing.Scalar> numbers.

alias of ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>]]

slepc4py.typing.LayoutSizeSpec = int | tuple[int, int]

int <https://docs.python.org/3/library/functions.html#int> or 2-tuple <https://docs.python.org/3/library/stdtypes.html#tuple> of int <https://docs.python.org/3/library/functions.html#int> describing the layout sizes.

A single int <https://docs.python.org/3/library/functions.html#int> indicates global size. A tuple <https://docs.python.org/3/library/stdtypes.html#tuple> of int <https://docs.python.org/3/library/functions.html#int> indicates (local_size, global_size).

slepc4py.typing.EPSStoppingFunction

EPS <#slepc4py.SLEPc.EPS> stopping test callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[EPS <#slepc4py.SLEPc.EPS>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>], ConvergedReason <#slepc4py.SLEPc.EPS.ConvergedReason>]

slepc4py.typing.EPSArbitraryFunction

EPS <#slepc4py.SLEPc.EPS> arbitrary selection callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, Vec <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Vec.html#petsc4py.PETSc.Vec>, Vec <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Vec.html#petsc4py.PETSc.Vec>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>], [float | complex, float | complex]]

slepc4py.typing.EPSEigenvalueComparison

EPS <#slepc4py.SLEPc.EPS> eigenvalue comparison callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>], int <https://docs.python.org/3/library/functions.html#int>]

slepc4py.typing.EPSMonitorFunction

EPS <#slepc4py.SLEPc.EPS> monitor callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[EPS <#slepc4py.SLEPc.EPS>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>]], ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>]], ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float>]], int <https://docs.python.org/3/library/functions.html#int>], None <https://docs.python.org/3/library/constants.html#None>]

slepc4py.typing.PEPStoppingFunction

PEP <#slepc4py.SLEPc.PEP> stopping test callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[PEP <#slepc4py.SLEPc.PEP>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>], ConvergedReason <#slepc4py.SLEPc.PEP.ConvergedReason>]

slepc4py.typing.PEPEigenvalueComparison

PEP <#slepc4py.SLEPc.NEP> eigenvalue comparison callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>], int <https://docs.python.org/3/library/functions.html#int>]

slepc4py.typing.PEPMonitorFunction

PEP <#slepc4py.SLEPc.PEP> monitor callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[PEP <#slepc4py.SLEPc.PEP>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>]], ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>]], ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float>]], int <https://docs.python.org/3/library/functions.html#int>], None <https://docs.python.org/3/library/constants.html#None>]

slepc4py.typing.NEPStoppingFunction

NEP <#slepc4py.SLEPc.NEP> stopping test callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[NEP <#slepc4py.SLEPc.NEP>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>], ConvergedReason <#slepc4py.SLEPc.NEP.ConvergedReason>]

slepc4py.typing.NEPEigenvalueComparison

NEP <#slepc4py.SLEPc.NEP> eigenvalue comparison callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>], int <https://docs.python.org/3/library/functions.html#int>]

slepc4py.typing.NEPMonitorFunction

NEP <#slepc4py.SLEPc.NEP> monitor callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[NEP <#slepc4py.SLEPc.NEP>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>]], ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>]], ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float>]], int <https://docs.python.org/3/library/functions.html#int>], None <https://docs.python.org/3/library/constants.html#None>]

slepc4py.typing.NEPFunction

NEP <#slepc4py.SLEPc.NEP> Function callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[NEP <#slepc4py.SLEPc.NEP>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, Mat <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Mat.html#petsc4py.PETSc.Mat>, Mat <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Mat.html#petsc4py.PETSc.Mat>], None <https://docs.python.org/3/library/constants.html#None>]

slepc4py.typing.NEPJacobian

NEP <#slepc4py.SLEPc.NEP> Jacobian callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[NEP <#slepc4py.SLEPc.NEP>, float <https://docs.python.org/3/library/functions.html#float> | complex <https://docs.python.org/3/library/functions.html#complex>, Mat <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Mat.html#petsc4py.PETSc.Mat>], None <https://docs.python.org/3/library/constants.html#None>]

slepc4py.typing.SVDStoppingFunction

SVD <#slepc4py.SLEPc.SVD> stopping test callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[SVD <#slepc4py.SLEPc.SVD>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>], ConvergedReason <#slepc4py.SLEPc.SVD.ConvergedReason>]

slepc4py.typing.SVDMonitorFunction

SVD <#slepc4py.SLEPc.SVD> monitor callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[SVD <#slepc4py.SLEPc.SVD>, int <https://docs.python.org/3/library/functions.html#int>, int <https://docs.python.org/3/library/functions.html#int>, ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float>]], ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray>[tuple <https://docs.python.org/3/library/stdtypes.html#tuple>[Any <https://docs.python.org/3/library/typing.html#typing.Any>, …], dtype <https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype>[float <https://docs.python.org/3/library/functions.html#float>]], int <https://docs.python.org/3/library/functions.html#int>], None <https://docs.python.org/3/library/constants.html#None>]

slepc4py.typing.MFNMonitorFunction

MFN <#slepc4py.SLEPc.MFN> monitor callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[MFN <#slepc4py.SLEPc.MFN>, int <https://docs.python.org/3/library/functions.html#int>, float <https://docs.python.org/3/library/functions.html#float>], None <https://docs.python.org/3/library/constants.html#None>]

slepc4py.typing.LMEMonitorFunction

LME <#slepc4py.SLEPc.LME> monitor callback.

alias of Callable <https://docs.python.org/3/library/typing.html#typing.Callable>[[LME <#slepc4py.SLEPc.LME>, int <https://docs.python.org/3/library/functions.html#int>, float <https://docs.python.org/3/library/functions.html#float>], None <https://docs.python.org/3/library/constants.html#None>]

class slepc4py.SLEPc.BV

Bases: Object <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Object.html#petsc4py.PETSc.Object>

Basis Vectors.

The BV package provides the concept of a block of vectors that represent the basis of a subspace. It is a convenient way of handling a collection of vectors that often operate together, rather than working with an array of petsc4py.PETSc.Vec <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Vec.html#petsc4py.PETSc.Vec>.

Enumerations

MatMultType <#slepc4py.SLEPc.BV.MatMultType>	BV mat-mult types.
OrthogBlockType <#slepc4py.SLEPc.BV.OrthogBlockType>	BV block-orthogonalization types.
OrthogRefineType <#slepc4py.SLEPc.BV.OrthogRefineType>	BV orthogonalization refinement types.
OrthogType <#slepc4py.SLEPc.BV.OrthogType>	BV orthogonalization types.
SVDMethod <#slepc4py.SLEPc.BV.SVDMethod>	BV methods for computing the SVD.
Type <#slepc4py.SLEPc.BV.Type>	BV type.

class slepc4py.SLEPc.BV.MatMultType

Bases: object <https://docs.python.org/3/library/functions.html#object>

BV mat-mult types.

See also:

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.OrthogBlockType

Bases: object <https://docs.python.org/3/library/functions.html#object>

BV block-orthogonalization types.

See also:

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.OrthogRefineType

Bases: object <https://docs.python.org/3/library/functions.html#object>

BV orthogonalization refinement types.

See also:

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.OrthogType

Bases: object <https://docs.python.org/3/library/functions.html#object>

BV orthogonalization types.

See also:

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.SVDMethod

Bases: object <https://docs.python.org/3/library/functions.html#object>

BV methods for computing the SVD.

See also:

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.Type

Bases: object <https://docs.python.org/3/library/functions.html#object>

BV type.

See also:

Attributes Summary

Attributes Documentation

appendOptionsPrefix(prefix=None)

Append to the prefix used for searching for all BV options in the database.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:618 <slepc4py/SLEPc/BV.pyx#L618>`

applyMatrix(x, y)

Multiply a vector with the matrix associated to the bilinear form.

Neighbor-wise collective.

Notes

If the bilinear form has no associated matrix this function copies the vector.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:863 <slepc4py/SLEPc/BV.pyx#L863>`

copy(result=None)

Copy a basis vector object into another one.

Logically collective.

Notes

Both objects must be distributed in the same manner; local copies are done. Only active columns (excluding the leading ones) are copied. In the destination BV, columns are overwritten starting from the leading ones. Constraints are not copied.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:354 <slepc4py/SLEPc/BV.pyx#L354>`

copyColumn(j, i)

Copy the values from one of the columns to another one.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1235 <slepc4py/SLEPc/BV.pyx#L1235>`

copyVec(j, v)

Copy one of the columns of a basis vectors object into a vector.

Logically collective.

Notes

The BV and v must be distributed in the same manner; local copies are done.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1210 <slepc4py/SLEPc/BV.pyx#L1210>`

create(comm=None)

Create the BV object.

Collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:225 <slepc4py/SLEPc/BV.pyx#L225>`

createFromMat(A)

Create a basis vectors object from a dense matrix.

Collective.

Notes

The matrix values are copied to the BV data storage, memory is not shared.

The communicator of the BV object will be the same as A <#slepc4py.SLEPc.DS.MatType.A>, and so will be the dimensions.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:247 <slepc4py/SLEPc/BV.pyx#L247>`

createMat()

Create a new dense matrix and copy the contents of the BV.

Collective.

Notes

The matrix contains all columns of the BV, not just the active columns.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:275 <slepc4py/SLEPc/BV.pyx#L275>`

createVec()

Create a vector with the type and dimensions of the columns of the BV.

Collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1147 <slepc4py/SLEPc/BV.pyx#L1147>`

destroy()

Destroy the BV object.

Collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:211 <slepc4py/SLEPc/BV.pyx#L211>`

dot(Y)

Compute the ‘block-dot’ product of two basis vectors objects.

Collective.

M = Y^* X (m_{ij} = y_i^* x_j) or M = Y^* B X

Notes

This is the generalization of Vec.dot() for a collection of vectors, M = Y^* X. The result is a matrix M whose entry m_{ij} is equal to y_i^* x_j (where y_i^* denotes the conjugate transpose of y_i).

X and Y can be the same object.

If a non-standard inner product has been specified with setMatrix(), then the result is M = Y^* B X. In this case, both X and Y must have the same associated matrix.

Only rows (resp. columns) of M starting from l_y (resp. l_x) are computed, where l_y (resp. l_x) is the number of leading columns of Y (resp. X).

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1500 <slepc4py/SLEPc/BV.pyx#L1500>`

dotColumn(j)

Dot products of a column against all the column vectors of a BV.

Collective.

Notes

This operation is equivalent to dotVec() but it uses column j of the BV rather than taking a vector as an argument. The number of active columns of the BV is set to j before the computation, and restored afterwards. If the BV has leading columns specified, then these columns do not participate in the computation. Therefore, the length of the returned array will be j minus the number of leading columns.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1344 <slepc4py/SLEPc/BV.pyx#L1344>`

dotVec(v)

Dot products of a vector against all the column vectors of the BV.

Collective.

Notes

This is analogue to Vec.mDot(), but using BV to represent a collection of vectors X. The result is m = X^* v, so m_i is equal to x_j^* v. Note that here X is transposed as opposed to dot().

If a non-standard inner product has been specified with setMatrix(), then the result is m = X^* B v.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1304 <slepc4py/SLEPc/BV.pyx#L1304>`

duplicate()

Duplicate the BV object with the same type and dimensions.

Collective.

Notes

This function does not copy the entries, it just allocates the storage for the new BV. Use copy() to copy the content.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:299 <slepc4py/SLEPc/BV.pyx#L299>`

duplicateResize(m)

Create a BV object of the same type and dimensions as an existing one.

Collective.

Notes

This is equivalent to a call to duplicate() followed by resize() with possibly different number of columns. The contents of this BV are not copied to the new one.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:323 <slepc4py/SLEPc/BV.pyx#L323>`

getActiveColumns()

Get the current active dimensions.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:924 <slepc4py/SLEPc/BV.pyx#L924>`

getArray(readonly=False)

Return the array where the data is stored.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:546 <slepc4py/SLEPc/BV.pyx#L546>`

getColumn(j)

Get a vector with the entries of the column of the BV object.

Logically collective.

Notes

Modifying the returned vector will change the BV entries as well.

The returned vector must not be destroyed, restoreColumn() must be called when it is no longer needed. At most, two columns can be fetched, that is, this function can only be called twice before the corresponding restoreColumn() is invoked.

A negative index j selects the i-th constraint, where i=-j. Constraints should not be modified.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1384 <slepc4py/SLEPc/BV.pyx#L1384>`

getDefiniteTolerance()

Get the tolerance to be used when checking a definite inner product.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1285 <slepc4py/SLEPc/BV.pyx#L1285>`

getLeadingDimension()

Get the leading dimension.

Not collective.

Notes

The returned value may be different in different processes.

The leading dimension must be used when accessing the internal array via getArray().

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:520 <slepc4py/SLEPc/BV.pyx#L520>`

getMat()

Get a matrix of dense type that shares the memory of the BV object.

Collective.

Notes

The returned matrix contains only the active columns. If the content of the matrix is modified, these changes are also done in the BV object. The user must call restoreMat() when no longer needed.

This operation implies a call to getArray(), which may result in data copies.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1447 <slepc4py/SLEPc/BV.pyx#L1447>`

getMatMultMethod()

Get the method used for the matMult() operation.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:760 <slepc4py/SLEPc/BV.pyx#L760>`

getMatrix()

Get the matrix representation of the inner product.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:799 <slepc4py/SLEPc/BV.pyx#L799>`

getNumConstraints()

Get the number of constraints.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1128 <slepc4py/SLEPc/BV.pyx#L1128>`

getOptionsPrefix()

Get the prefix used for searching for all BV options in the database.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:637 <slepc4py/SLEPc/BV.pyx#L637>`

getOrthogonalization()

Get the orthogonalization settings from the BV object.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:675 <slepc4py/SLEPc/BV.pyx#L675>`

getRandomContext()

Get the petsc4py.PETSc.Random <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Random.html#petsc4py.PETSc.Random> object associated with the BV.

Collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2133 <slepc4py/SLEPc/BV.pyx#L2133>`

getSizes()

Get the local and global sizes, and the number of columns.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:477 <slepc4py/SLEPc/BV.pyx#L477>`

getType()

Get the BV type of this object.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:407 <slepc4py/SLEPc/BV.pyx#L407>`

getVecType()

Get the vector type used when creating vectors via createVec().

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1191 <slepc4py/SLEPc/BV.pyx#L1191>`

insertConstraints(C)

Insert a set of vectors as constraints.

Collective.

Notes

The constraints are relevant only during orthogonalization. Constraint vectors span a subspace that is deflated in every orthogonalization operation, so they are intended for removing those directions from the orthogonal basis computed in regular BV columns.

Constraints are not stored in regular columns, but in a special part of the storage. They can be accessed with negative indices in getColumn().

This operation is DESTRUCTIVE, meaning that all data contained in the columns of the BV is lost. This is typically invoked just after creating the BV. Once a set of constraints has been set, it is not allowed to call this function again.

The vectors are copied one by one and then orthogonalized against the previous ones. If any of them is linearly dependent then it is discarded and not counted in the return value. The behavior is similar to insertVecs().

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1051 <slepc4py/SLEPc/BV.pyx#L1051>`

insertVec(j, w)

Insert a vector into the specified column.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:988 <slepc4py/SLEPc/BV.pyx#L988>`

insertVecs(s, W, orth=False)

Insert a set of vectors into the specified columns.

Collective.

Notes

Copies the contents of vectors W into the BV columns s:s+n, where n is the length of W. If orth is set, then the vectors are copied one by one and then orthogonalized against the previous one. If any of them is linearly dependent then it is discarded and the not counted in the return value.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1008 <slepc4py/SLEPc/BV.pyx#L1008>`

matMult(A, Y=None)

Compute the matrix-vector product for each column, Y = A V.

Neighbor-wise collective.

Notes

Only active columns (excluding the leading ones) are processed. If Y is None a new BV is created.

It is possible to choose whether the computation is done column by column or as a dense matrix-matrix product with setMatMultMethod().

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1598 <slepc4py/SLEPc/BV.pyx#L1598>`

matMultColumn(A, j)

Mat-vec product for a column, storing the result in the next column.

Neighbor-wise collective.

v_{j+1} = A v_j.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1743 <slepc4py/SLEPc/BV.pyx#L1743>`

matMultHermitianTranspose(A, Y=None)

Pre-multiplication with the conjugate transpose of a matrix.

Neighbor-wise collective.

Y = A^* V.

Notes

Only active columns (excluding the leading ones) are processed. If Y is None a new BV is created.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1695 <slepc4py/SLEPc/BV.pyx#L1695>`

matMultHermitianTransposeColumn(A, j)

Conjugate-transpose matrix-vector product for a specified column.

Neighbor-wise collective.

Store the result in the next column: v_{j+1} = A^* v_j.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1787 <slepc4py/SLEPc/BV.pyx#L1787>`

matMultTranspose(A, Y=None)

Pre-multiplication with the transpose of a matrix.

Neighbor-wise collective.

Y = A^T V.

Notes

Only active columns (excluding the leading ones) are processed. If Y is None a new BV is created.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1647 <slepc4py/SLEPc/BV.pyx#L1647>`

matMultTransposeColumn(A, j)

Transpose matrix-vector product for a specified column.

Neighbor-wise collective.

Store the result in the next column: v_{j+1} = A^T v_j.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1765 <slepc4py/SLEPc/BV.pyx#L1765>`

matProject(A, Y)

Compute the projection of a matrix onto a subspace.

Collective.

M = Y^* A X

Notes

If A is None, then it is assumed that the BV already contains AX.

This operation is similar to dot(), with important differences. The goal is to compute the matrix resulting from the orthogonal projection of A onto the subspace spanned by the columns of the BV, M = X^*AX, or the oblique projection onto the BV along the second one Y, M = Y^*AX.

A difference with respect to dot() is that the standard inner product is always used, regardless of a non-standard inner product being specified with setMatrix().

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1549 <slepc4py/SLEPc/BV.pyx#L1549>`

mult(delta, gamma, X, Q)

Compute Y = \gamma Y + \delta X Q.

Logically collective.

Notes

X must be different from self (Y). The case X=Y can be addressed with multInPlace().

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1809 <slepc4py/SLEPc/BV.pyx#L1809>`

multColumn(delta, gamma, j, q)

Compute y = \gamma y + \delta X q.

Logically collective.

Compute y = \gamma y + \delta X q, where y is the j-th column.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1863 <slepc4py/SLEPc/BV.pyx#L1863>`

multInPlace(Q, s, e)

Update a set of vectors as V(:,s:e-1) = V Q(:,s:e-1).

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1840 <slepc4py/SLEPc/BV.pyx#L1840>`

multVec(delta, gamma, y, q)

Compute y = \gamma y + \delta X q.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1898 <slepc4py/SLEPc/BV.pyx#L1898>`

norm(norm_type=None)

Compute the matrix norm of the BV.

Collective.

Notes

All active columns (except the leading ones) are considered as a matrix. The allowed norms are NORM_1, NORM_FROBENIUS, and NORM_INFINITY.

This operation fails if a non-standard inner product has been specified with setMatrix().

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1967 <slepc4py/SLEPc/BV.pyx#L1967>`

normColumn(j, norm_type=None)

Compute the vector norm of a selected column.

Collective.

Notes

The norm of v_j is computed (NORM_1, NORM_2, or NORM_INFINITY).

If a non-standard inner product has been specified with setMatrix(), then the returned value is \sqrt{v_j^* B v_j}, where B is the inner product matrix (argument ‘norm_type’ is ignored).

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1929 <slepc4py/SLEPc/BV.pyx#L1929>`

orthogonalize(R=None, **kargs)

Orthogonalize all columns (except leading ones) (QR decomposition).

Collective.

Notes

The output satisfies V_0 = V R (where V_0 represent the input V) and V^* V = I (or V^*BV=I if an inner product matrix B has been specified with setMatrix()).

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2263 <slepc4py/SLEPc/BV.pyx#L2263>`

orthogonalizeColumn(j)

Orthogonalize a column vector with respect to the previous ones.

Collective.

Notes

This function applies an orthogonal projector to project vector v_j onto the orthogonal complement of the span of the columns V[0..j-1], where V[.] are the vectors of the BV. The columns V[0..j-1] are assumed to be mutually orthonormal.

This routine does not normalize the resulting vector.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2189 <slepc4py/SLEPc/BV.pyx#L2189>`

orthogonalizeVec(v)

Orthogonalize a vector with respect to all active columns.

Collective.

Notes

This function applies an orthogonal projector to project vector v onto the orthogonal complement of the span of the columns of the BV.

This routine does not normalize the resulting vector.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2153 <slepc4py/SLEPc/BV.pyx#L2153>`

orthonormalizeColumn(j, replace=False)

Orthonormalize a column vector with respect to the previous ones.

Collective.

This is equivalent to a call to orthogonalizeColumn() followed by a call to scaleColumn() with the reciprocal of the norm.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2227 <slepc4py/SLEPc/BV.pyx#L2227>`

resize(m, copy=True)

Change the number of columns.

Collective.

Notes

Internal storage is reallocated. If copy is True, then the contents are copied to the leading part of the new space.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2002 <slepc4py/SLEPc/BV.pyx#L2002>`

restoreColumn(j, v)

Restore a column obtained with getColumn().

Logically collective.

Notes

The arguments must match the corresponding call to getColumn().

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1422 <slepc4py/SLEPc/BV.pyx#L1422>`

restoreMat(A)

Restore the matrix obtained with getMat().

Logically collective.

Notes

A call to this function must match a previous call of getMat(). The effect is that the contents of the matrix are copied back to the BV internal data structures.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1476 <slepc4py/SLEPc/BV.pyx#L1476>`

scale(alpha)

Multiply the entries by a scalar value.

Logically collective.

Notes

All active columns (except the leading ones) are scaled.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:966 <slepc4py/SLEPc/BV.pyx#L966>`

scaleColumn(j, alpha)

Scale a column of a BV.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:945 <slepc4py/SLEPc/BV.pyx#L945>`

setActiveColumns(l, k)

Set the columns that will be involved in operations.

Logically collective.

Notes

In operations such as mult() or dot(), only the first k columns are considered. This is useful when the BV is filled from left to right, so the last m-k columns do not have relevant information.

Also in operations such as mult() or dot(), the first l columns are normally not included in the computation.

In orthogonalization operations, the first l columns are treated differently, they participate in the orthogonalization but the computed coefficients are not stored.

Use CURRENT <#slepc4py.SLEPc.CURRENT> to leave any of the values unchanged. Use DETERMINE <#slepc4py.SLEPc.DETERMINE> to set l to the minimum value (0) and k to the maximum (m).

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:887 <slepc4py/SLEPc/BV.pyx#L887>`

setDefiniteTolerance(deftol)

Set the tolerance to be used when checking a definite inner product.

Logically collective.

Notes

When using a non-standard inner product, see setMatrix(), the solver needs to compute \sqrt{z^*B z} for various vectors z. If the inner product has not been declared indefinite, the value z^*B z must be positive, but due to rounding error a tiny value may become negative. A tolerance is used to detect this situation. Likewise, in complex arithmetic z^*B z should be real, and we use the same tolerance to check whether a nonzero imaginary part can be considered negligible.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1256 <slepc4py/SLEPc/BV.pyx#L1256>`

setFromOptions()

Set BV options from the options database.

Collective.

Notes

To see all options, run your program with the -help option.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:656 <slepc4py/SLEPc/BV.pyx#L656>`

setLeadingDimension(ld)

Set the leading dimension.

Not collective.

Notes

This parameter is relevant for a BV of BV.Type.MAT <#slepc4py.SLEPc.BV.Type.MAT>.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:498 <slepc4py/SLEPc/BV.pyx#L498>`

setMatMultMethod(method)

Set the method used for the matMult() operation.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:779 <slepc4py/SLEPc/BV.pyx#L779>`

setMatrix(B, indef=False)

Set the bilinear form to be used for inner products.

Collective.

Notes

This is used to specify a non-standard inner product, whose matrix representation is given by B. Then, all inner products required during orthogonalization are computed as (x,y)_B=y^*Bx rather than the standard form (x,y)=y^*x.

Matrix B must be real symmetric (or complex Hermitian). A genuine inner product requires that B is also positive (semi-)definite. However, we also allow for an indefinite B (setting indef=True), in which case the orthogonalization uses an indefinite inner product.

This affects operations dot(), norm(), orthogonalize(), and variants.

Omitting B has the same effect as if the identity matrix was passed.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:825 <slepc4py/SLEPc/BV.pyx#L825>`

setNumConstraints(nc)

Set the number of constraints.

Logically collective.

Notes

This function sets the number of constraints to nc and marks all remaining columns as regular. Normal usage would be to call insertConstraints() instead.

If nc is smaller than the previously set value, then some of the constraints are discarded. In particular, using nc=0 removes all constraints preserving the content of regular columns.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1101 <slepc4py/SLEPc/BV.pyx#L1101>`

setOptionsPrefix(prefix=None)

Set the prefix used for searching for all BV options in the database.

Logically collective.

Notes

A hyphen (-) must NOT be given at the beginning of the prefix name. The first character of all runtime options is AUTOMATICALLY the hyphen.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:593 <slepc4py/SLEPc/BV.pyx#L593>`

setOrthogonalization(otype=None, refine=None, eta=None, block=None)

Set the method used for the (block-)orthogonalization of vectors.

Logically collective.

Ortogonalization of vectors (classical or modified Gram-Schmidt with or without refinement), and for the block-orthogonalization (simultaneous orthogonalization of a set of vectors).

Notes

The default settings work well for most problems.

The parameter eta should be a real value between 0 and 1 (or DETERMINE <#slepc4py.SLEPc.DETERMINE>). The value of eta is used only when the refinement type is IFNEEDED <#slepc4py.SLEPc.BV.OrthogRefineType.IFNEEDED>.

When using several processes, MGS <#slepc4py.SLEPc.BV.OrthogType.MGS> is likely to result in bad scalability.

If the method set for block orthogonalization is GS <#slepc4py.SLEPc.BV.OrthogBlockType.GS>, then the computation is done column by column with the vector orthogonalization.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:704 <slepc4py/SLEPc/BV.pyx#L704>`

setRandom()

Set the active columns of the BV to random numbers.

Logically collective.

Notes

All active columns (except the leading ones) are modified.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2028 <slepc4py/SLEPc/BV.pyx#L2028>`

setRandomColumn(j)

Set one column of the BV to random numbers.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2076 <slepc4py/SLEPc/BV.pyx#L2076>`

setRandomCond(condn)

Set the columns of a BV to random numbers.

Logically collective.

The generated matrix has a prescribed condition number.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2094 <slepc4py/SLEPc/BV.pyx#L2094>`

setRandomContext(rnd)

Set the petsc4py.PETSc.Random <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Random.html#petsc4py.PETSc.Random> object associated with the BV.

Collective.

To be used in operations that need random numbers.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2114 <slepc4py/SLEPc/BV.pyx#L2114>`

setRandomNormal()

Set the active columns of the BV to normal random numbers.

Logically collective.

Notes

All active columns (except the leading ones) are modified.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2044 <slepc4py/SLEPc/BV.pyx#L2044>`

setRandomSign()

Set the entries of a BV to values 1 or -1 with equal probability.

Logically collective.

Notes

All active columns (except the leading ones) are modified.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2060 <slepc4py/SLEPc/BV.pyx#L2060>`

setSizes(sizes, m)

Set the local and global sizes, and the number of columns.

Collective.

Notes

Either n or N (but not both) can be DETERMINE <#slepc4py.SLEPc.DETERMINE> or None to have it automatically set.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:426 <slepc4py/SLEPc/BV.pyx#L426>`

setSizesFromVec(w, m)

Set the local and global sizes, and the number of columns.

Collective.

Local and global sizes are specified indirectly by passing a template vector.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:454 <slepc4py/SLEPc/BV.pyx#L454>`

setType(bv_type)

Set the type for the BV object.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:388 <slepc4py/SLEPc/BV.pyx#L388>`

setVecType(vec_type)

Set the vector type to be used when creating vectors via createVec().

Collective.

Notes

This is not needed if the BV object is set up with setSizesFromVec(), but may be required in the case of setSizes() if one wants to work with non-standard vectors.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1166 <slepc4py/SLEPc/BV.pyx#L1166>`

view(viewer=None)

Print the BV data structure.

Collective.

See also:

:sources:`Source code at slepc4py/SLEPc/BV.pyx:192 <slepc4py/SLEPc/BV.pyx#L192>`

column_size

Basis vectors column size.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2305 <slepc4py/SLEPc/BV.pyx#L2305>`

local_size

Basis vectors local size.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2300 <slepc4py/SLEPc/BV.pyx#L2300>`

size

Basis vectors global size.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2295 <slepc4py/SLEPc/BV.pyx#L2295>`

sizes

Basis vectors local and global sizes, and the number of columns.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:2290 <slepc4py/SLEPc/BV.pyx#L2290>`

class slepc4py.SLEPc.DS

Bases: Object <https://petsc.org/release/petsc4py/reference/petsc4py.PETSc.Object.html#petsc4py.PETSc.Object>

Direct Solver (or Dense System).

The DS package provides auxiliary routines that are internally used by the different slepc4py solvers. It is used to represent low-dimensional eigenproblems that must be solved within iterative solvers with direct methods. It can be seen as a structured wrapper to LAPACK functionality.

Enumerations

MatType <#slepc4py.SLEPc.DS.MatType>	To refer to one of the matrices stored internally in DS.
ParallelType <#slepc4py.SLEPc.DS.ParallelType>	Indicates the parallel mode that the direct solver will use.
StateType <#slepc4py.SLEPc.DS.StateType>	DS state types.
Type <#slepc4py.SLEPc.DS.Type>	DS type.

class slepc4py.SLEPc.DS.MatType

Bases: object <https://docs.python.org/3/library/functions.html#object>

To refer to one of the matrices stored internally in DS.

See also:

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.DS.ParallelType

Bases: object <https://docs.python.org/3/library/functions.html#object>

Indicates the parallel mode that the direct solver will use.

See also:

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.DS.StateType

Bases: object <https://docs.python.org/3/library/functions.html#object>

DS state types.

See also:

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.DS.Type

Bases: object <https://docs.python.org/3/library/functions.html#object>

DS type.

See also:

Attributes Summary

Attributes Documentation

allocate(ld)

Allocate memory for internal storage or matrices in DS.

Logically collective.

Notes

If the leading dimension is different from a previously set value, then all matrices are destroyed with reset().

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:338 <slepc4py/SLEPc/DS.pyx#L338>`

appendOptionsPrefix(prefix=None)

Append to the prefix used for searching for all DS options in the database.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:256 <slepc4py/SLEPc/DS.pyx#L256>`

cond()

Compute the inf-norm condition number of the first matrix.

Logically collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:905 <slepc4py/SLEPc/DS.pyx#L905>`

create(comm=None)

Create the DS object.

Collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:172 <slepc4py/SLEPc/DS.pyx#L172>`

destroy()

Destroy the DS object.

Collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:146 <slepc4py/SLEPc/DS.pyx#L146>`

duplicate()

Duplicate the DS object with the same type and dimensions.

Collective.

Notes

This method does not copy the matrices, and the new object does not even have internal arrays allocated. Use allocate() to use the new DS.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:311 <slepc4py/SLEPc/DS.pyx#L311>`

getArray(matname)

Return the array where the data is stored.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:845 <slepc4py/SLEPc/DS.pyx#L845>`

getBlockSize()

Get the block size.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:555 <slepc4py/SLEPc/DS.pyx#L555>`

getCompact()

Get the compact storage flag.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:639 <slepc4py/SLEPc/DS.pyx#L639>`

getDimensions()

Get the current dimensions.

Not collective.

Notes

The t value makes sense only if truncate() has been called. Otherwise it is equal to n.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:504 <slepc4py/SLEPc/DS.pyx#L504>`

getExtraRow()

Get the extra row flag.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:686 <slepc4py/SLEPc/DS.pyx#L686>`

getGSVDDimensions()

Get the number of columns and rows of a DS of type GSVD <#slepc4py.SLEPc.DS.Type.GSVD>.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:1082 <slepc4py/SLEPc/DS.pyx#L1082>`

getHSVDDimensions()

Get the number of columns of a DS of type HSVD <#slepc4py.SLEPc.DS.Type.HSVD>.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:1037 <slepc4py/SLEPc/DS.pyx#L1037>`

getLeadingDimension()

Get the leading dimension of the allocated matrices.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:362 <slepc4py/SLEPc/DS.pyx#L362>`

getMat(matname)

Get the requested matrix as a sequential dense Mat object.

Not collective.

Notes

The returned matrix has sizes equal to the current DS dimensions (see setDimensions()), and contains the values that would be obtained with getArray(). If the DS was truncated, then the number of rows is equal to the dimension prior to truncation, see truncate().

When no longer needed the user must call restoreMat().

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:789 <slepc4py/SLEPc/DS.pyx#L789>`

getMethod()

Get the method currently used in the DS.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:592 <slepc4py/SLEPc/DS.pyx#L592>`

getOptionsPrefix()

Get the prefix used for searching for all DS options in the database.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:275 <slepc4py/SLEPc/DS.pyx#L275>`

getPEPCoefficients()

Get the polynomial basis coefficients of a DS of type PEP <#slepc4py.SLEPc.PEP>.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:1176 <slepc4py/SLEPc/DS.pyx#L1176>`

getPEPDegree()

Get the polynomial degree of a DS of type PEP <#slepc4py.SLEPc.PEP>.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:1122 <slepc4py/SLEPc/DS.pyx#L1122>`

getParallel()

Get the mode of operation in parallel runs.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:450 <slepc4py/SLEPc/DS.pyx#L450>`

getRefined()

Get the refined vectors flag.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:734 <slepc4py/SLEPc/DS.pyx#L734>`

getSVDDimensions()

Get the number of columns of a DS of type SVD <#slepc4py.SLEPc.SVD>.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:995 <slepc4py/SLEPc/DS.pyx#L995>`

getState()

Get the current state.

Not collective.

See also:

:sources:`Source code at slepc4py/SLEPc/DS.pyx:413 <slepc4py/SLEPc/DS.pyx#L413>`