• Standard eigenvalue problem, Ax=kx, either for Hermitian or non-Hermitian matrices.
• Generalized eigenvalue problem, Ax=kBx, either Hermitian positive-definite or not.
• Partial singular value decomposition of a rectangular matrix, Au=sv.
• Polynomial eigenvalue problem, P(k)x=0.
• Nonlinear eigenvalue problem, T(k)x=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 for the minimization of the Rayleigh quotient.
• A contour integral solver.

• Use an eigensolver via the cross-product matrix A’A or the cyclic matrix [0 A; A’ 0].
• Explicitly restarted Lanczos bidiagonalization.
• Implicitly restarted Lanczos bidiagonalization (thick-restart Lanczos).

• Use an eigensolver to solve the generalized eigenvalue problem obtained after linearization.
• TOAR and Q-Arnoldi, memory efficient variants of Arnoldi for polynomial eigenproblems.

• Solve a polynomial eigenproblem obtained via polynomial interpolation.
• Rational interpolation and linearization (NLEIGS).
• Newton-type methods such as SLP or RII.

• Spectral transformations, such as shift-and-invert. This technique implicitly uses the inverse of the shifted matrix (A-tI) in order to compute eigenvalues closest to a given target value, t.
• Harmonic extraction, a cheap alternative to shift-and-invert that also tries to approximate eigenvalues closest to a target, t, 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.

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)x=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(.) 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.

• Any MPI <https://www.mpi-forum.org> implementation [1] (e.g., MPICH <https://www.mpich.org> or Open MPI <https://www.open-mpi.org>), built with shared libraries.
• A matching version of PETSc <https://petsc.org> built with shared libraries.
• A matching version of SLEPc <https://slepc.upv.es> built with shared libraries.
• NumPy <https://www.numpy.org> package.
• petsc4py <https://gitlab.com/petsc/petsc> package.

•

Using curl:

$ curl -LO https://pypi.io/packages/source/s/slepc4py/slepc4py-X.Y.Z.tar.gz

•

Using wget:

$ wget https://pypi.io/packages/source/s/slepc4py/slepc4py-X.Y.Z.tar.gz

• L. Dalcin, P. Kler, R. Paz, and A. Cosimo, Parallel Distributed Computing using Python, Advances in Water Resources, 34(9):1124-1139, 2011. <http://dx.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. <http://dx.doi.org/10.1145/1089014.1089019>

slepc4py.get_config()

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. Using Python distutils (or perhaps NumPy distutils):

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


          include_dirs=[...,


                        petsc4py.get_include(),


                        slepc4py.get_include(),])

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

Initialize SLEPc.

Note:

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.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.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>

BV.

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.
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.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.OrthogBlockType

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

BV block-orthogonalization types.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.OrthogRefineType

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

BV orthogonalization refinement types.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.OrthogType

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

BV orthogonalization types.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.BV.Type

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

BV type.

Attributes Summary

CONTIGUOUS	Object CONTIGUOUS of type str <https://docs.python.org/3/library/stdtypes.html#str>
MAT	Object MAT of type str <https://docs.python.org/3/library/stdtypes.html#str>
SVEC	Object SVEC of type str <https://docs.python.org/3/library/stdtypes.html#str>
TENSOR	Object TENSOR of type str <https://docs.python.org/3/library/stdtypes.html#str>
VECS	Object VECS of type str <https://docs.python.org/3/library/stdtypes.html#str>

Attributes Documentation

appendOptionsPrefix(prefix=None)

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

Logically collective.

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

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:605 <slepc4py/SLEPc/BV.pyx#L605>`

copy(result=None)

Copy a basis vector object into another one.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:255 <slepc4py/SLEPc/BV.pyx#L255>`

copyColumn(j, i)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:866 <slepc4py/SLEPc/BV.pyx#L866>`

copyVec(j, v)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:850 <slepc4py/SLEPc/BV.pyx#L850>`

create(comm=None)

Create the BV object.

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:175 <slepc4py/SLEPc/BV.pyx#L175>`

createFromMat(A)

Create a basis vectors object from a dense Mat object.

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:193 <slepc4py/SLEPc/BV.pyx#L193>`

createMat()

Create a new Mat object of dense type and copy the contents of the BV.

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:209 <slepc4py/SLEPc/BV.pyx#L209>`

createVec()

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

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:810 <slepc4py/SLEPc/BV.pyx#L810>`

destroy()

Destroy the BV object.

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:165 <slepc4py/SLEPc/BV.pyx#L165>`

dot(Y)

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

Collective.

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

Notes

This is the generalization of VecDot() for a collection of vectors, M = Y^H X. The result is a matrix M whose entry m_{ij} is equal to y_i^H x_j (where y_i^H 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^H B X. In this case, both X and Y must have the same associated matrix.

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1064 <slepc4py/SLEPc/BV.pyx#L1064>`

dotColumn(j)

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

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:948 <slepc4py/SLEPc/BV.pyx#L948>`

dotVec(v)

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

Collective.

Notes

This is analogue to VecMDot(), but using BV to represent a collection of vectors. The result is m = X^H y, so m_i is equal to x_j^H y. Note that here X is transposed as opposed to BVDot().

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:912 <slepc4py/SLEPc/BV.pyx#L912>`

duplicate()

Duplicate the BV object with the same type and dimensions.

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:224 <slepc4py/SLEPc/BV.pyx#L224>`

duplicateResize(m)

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

Collective.

Notes

With possibly different number of columns.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:234 <slepc4py/SLEPc/BV.pyx#L234>`

getActiveColumns()

Get the current active dimensions.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:642 <slepc4py/SLEPc/BV.pyx#L642>`

getColumn(j)

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

Logically collective.

Notes

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:975 <slepc4py/SLEPc/BV.pyx#L975>`

getDefiniteTolerance()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:897 <slepc4py/SLEPc/BV.pyx#L897>`

getLeadingDimension()

Get the leading dimension.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:377 <slepc4py/SLEPc/BV.pyx#L377>`

getMat()

Get a Mat object 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 Mat is modified, these changes are also done in the BV object. The user must call restoreMat() when no longer needed.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1022 <slepc4py/SLEPc/BV.pyx#L1022>`

getMatMultMethod()

Get the method used for the matMult() operation.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:535 <slepc4py/SLEPc/BV.pyx#L535>`

getMatrix()

Get the matrix representation of the inner product.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:566 <slepc4py/SLEPc/BV.pyx#L566>`

getNumConstraints()

Get the number of constraints.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:795 <slepc4py/SLEPc/BV.pyx#L795>`

getOptionsPrefix()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:428 <slepc4py/SLEPc/BV.pyx#L428>`

getOrthogonalization()

Get the orthogonalization settings from the BV object.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:458 <slepc4py/SLEPc/BV.pyx#L458>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1554 <slepc4py/SLEPc/BV.pyx#L1554>`

getSizes()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:346 <slepc4py/SLEPc/BV.pyx#L346>`

getType()

Get the BV type of this object.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:288 <slepc4py/SLEPc/BV.pyx#L288>`

getVecType()

Get the vector type used by the basis vectors object.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:840 <slepc4py/SLEPc/BV.pyx#L840>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:749 <slepc4py/SLEPc/BV.pyx#L749>`

insertVec(j, w)

Insert a vector into the specified column.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:694 <slepc4py/SLEPc/BV.pyx#L694>`

insertVecs(s, W, orth=False)

Insert a set of vectors into specified columns.

Collective.

Notes

Copies the contents of vectors W into self(:,s:s+n), where n is the length of W. If orthogonalization flag is set then the vectors are copied one by one then orthogonalized against the previous one. If any are linearly dependent then it is discared and the value of m is decreased.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:710 <slepc4py/SLEPc/BV.pyx#L710>`

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.

It is possible to choose whether the computation is done column by column or using dense matrices using the options database keys:

The default is bv_matmult_mat.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1139 <slepc4py/SLEPc/BV.pyx#L1139>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1234 <slepc4py/SLEPc/BV.pyx#L1234>`

matMultHermitianTranspose(A, Y=None)

Pre-multiplication with the conjugate transpose of a matrix.

Neighbor-wise collective.

Y = A^H V.

Notes

Only active columns (excluding the leading ones) are processed.

As opoosed to matMult(), this operation is always done by column by column, with a sequence of calls to MatMultHermitianTranspose().

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1188 <slepc4py/SLEPc/BV.pyx#L1188>`

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^H v_j.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1270 <slepc4py/SLEPc/BV.pyx#L1270>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1252 <slepc4py/SLEPc/BV.pyx#L1252>`

matProject(A, Y)

Compute the projection of a matrix onto a subspace.

Collective.

M = Y^H A X

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1109 <slepc4py/SLEPc/BV.pyx#L1109>`

mult(alpha, beta, X, Q)

Compute Y = beta Y + alpha X Q.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1288 <slepc4py/SLEPc/BV.pyx#L1288>`

multColumn(alpha, beta, j, q)

Compute y = beta y + alpha X q.

Logically collective.

Compute y = beta y + alpha X q, where y is the j^{th} column.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1329 <slepc4py/SLEPc/BV.pyx#L1329>`

multInPlace(Q, s, e)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1310 <slepc4py/SLEPc/BV.pyx#L1310>`

multVec(alpha, beta, y, q)

Compute y = beta y + alpha X q.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1360 <slepc4py/SLEPc/BV.pyx#L1360>`

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 BVSetMatrix().

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1420 <slepc4py/SLEPc/BV.pyx#L1420>`

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 BVSetMatrix(), then the returned value is \sqrt{V_j^H B V_j}, where B is the inner product matrix (argument ‘type’ is ignored).

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1387 <slepc4py/SLEPc/BV.pyx#L1387>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1668 <slepc4py/SLEPc/BV.pyx#L1668>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1602 <slepc4py/SLEPc/BV.pyx#L1602>`

orthogonalizeVec(v)

Orthogonalize a vector with respect to a set of vectors.

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1570 <slepc4py/SLEPc/BV.pyx#L1570>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1636 <slepc4py/SLEPc/BV.pyx#L1636>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1451 <slepc4py/SLEPc/BV.pyx#L1451>`

restoreColumn(j, v)

Restore a column obtained with getColumn().

Logically collective.

Notes

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1001 <slepc4py/SLEPc/BV.pyx#L1001>`

restoreMat(A)

Restore the Mat 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 Mat are copied back to the BV internal data structures.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1044 <slepc4py/SLEPc/BV.pyx#L1044>`

scale(alpha)

Multiply the entries by a scalar value.

Logically collective.

Notes

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:676 <slepc4py/SLEPc/BV.pyx#L676>`

scaleColumn(j, alpha)

Scale column j by alpha.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:659 <slepc4py/SLEPc/BV.pyx#L659>`

setActiveColumns(l, k)

Set the columns that will be involved in operations.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:625 <slepc4py/SLEPc/BV.pyx#L625>`

setDefiniteTolerance(deftol)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:883 <slepc4py/SLEPc/BV.pyx#L883>`

setFromOptions()

Set BV options from the options database.

Collective.

Notes

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:443 <slepc4py/SLEPc/BV.pyx#L443>`

setLeadingDimension(ld)

Set the leading dimension.

Not collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:363 <slepc4py/SLEPc/BV.pyx#L363>`

setMatMultMethod(method)

Set the method used for the matMult() operation.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:550 <slepc4py/SLEPc/BV.pyx#L550>`

setMatrix(mat, indef=False)

Set the bilinear form to be used for inner products.

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:588 <slepc4py/SLEPc/BV.pyx#L588>`

setNumConstraints(nc)

Set the number of constraints.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:781 <slepc4py/SLEPc/BV.pyx#L781>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:392 <slepc4py/SLEPc/BV.pyx#L392>`

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 BV.OrthogRefineType.IFNEEDED <#slepc4py.SLEPc.BV.OrthogRefineType.IFNEEDED>.

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

If the method set for block orthogonalization is GS, then the computation is done column by column with the vector orthogonalization.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:483 <slepc4py/SLEPc/BV.pyx#L483>`

setRandom()

Set the active columns of the BV to random numbers.

Logically collective.

Notes

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1473 <slepc4py/SLEPc/BV.pyx#L1473>`

setRandomColumn(j)

Set one column of the BV to random numbers.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1509 <slepc4py/SLEPc/BV.pyx#L1509>`

setRandomCond(condn)

Set the columns of a BV to random numbers.

Logically collective.

The generated matrix has a prescribed condition number.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1523 <slepc4py/SLEPc/BV.pyx#L1523>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1539 <slepc4py/SLEPc/BV.pyx#L1539>`

setRandomNormal()

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

Logically collective.

Notes

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1485 <slepc4py/SLEPc/BV.pyx#L1485>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1497 <slepc4py/SLEPc/BV.pyx#L1497>`

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 PETSc.DECIDE or None to have it automatically set.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:303 <slepc4py/SLEPc/BV.pyx#L303>`

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.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:327 <slepc4py/SLEPc/BV.pyx#L327>`

setType(bv_type)

Set the type for the BV object.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:273 <slepc4py/SLEPc/BV.pyx#L273>`

setVecType(vec_type)

Set the vector type.

Collective.

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

view(viewer=None)

Print the BV data structure.

Collective.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:150 <slepc4py/SLEPc/BV.pyx#L150>`

column_size

Basis vectors column size.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1705 <slepc4py/SLEPc/BV.pyx#L1705>`

local_size

Basis vectors local size.

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1700 <slepc4py/SLEPc/BV.pyx#L1700>`

size

Basis vectors global size.

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

sizes

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

:sources:`Source code at slepc4py/SLEPc/BV.pyx:1690 <slepc4py/SLEPc/BV.pyx#L1690>`

class slepc4py.SLEPc.BVSVDMethod

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

BV methods for computing the SVD.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.DS

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

DS.

Enumerations

MatType <#slepc4py.SLEPc.DS.MatType>	To refer to one of the matrices stored internally in DS.
ParallelType <#slepc4py.SLEPc.DS.ParallelType>	DS parallel types.
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.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.DS.ParallelType

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

DS parallel types.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.DS.StateType

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

DS state types.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.DS.Type

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

DS type.

Attributes Summary

GHEP	Object GHEP of type str <https://docs.python.org/3/library/stdtypes.html#str>
GHIEP	Object GHIEP of type str <https://docs.python.org/3/library/stdtypes.html#str>
GNHEP	Object GNHEP of type str <https://docs.python.org/3/library/stdtypes.html#str>
GSVD	Object GSVD of type str <https://docs.python.org/3/library/stdtypes.html#str>
HEP	Object HEP of type str <https://docs.python.org/3/library/stdtypes.html#str>
HSVD	Object HSVD of type str <https://docs.python.org/3/library/stdtypes.html#str>
NEP	Object NEP of type str <https://docs.python.org/3/library/stdtypes.html#str>
NHEP	Object NHEP of type str <https://docs.python.org/3/library/stdtypes.html#str>
NHEPTS	Object NHEPTS of type str <https://docs.python.org/3/library/stdtypes.html#str>
PEP	Object PEP of type str <https://docs.python.org/3/library/stdtypes.html#str>
SVD	Object SVD of type str <https://docs.python.org/3/library/stdtypes.html#str>

Attributes Documentation

allocate(ld)

Allocate memory for internal storage or matrices in DS.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:245 <slepc4py/SLEPc/DS.pyx#L245>`

appendOptionsPrefix(prefix=None)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:190 <slepc4py/SLEPc/DS.pyx#L190>`

cond()

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:654 <slepc4py/SLEPc/DS.pyx#L654>`

create(comm=None)

Create the DS object.

Collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:122 <slepc4py/SLEPc/DS.pyx#L122>`

destroy()

Destroy the DS object.

Collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:104 <slepc4py/SLEPc/DS.pyx#L104>`

duplicate()

Duplicate the DS object with the same type and dimensions.

Collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:233 <slepc4py/SLEPc/DS.pyx#L233>`

getBlockSize()

Get the block size.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:409 <slepc4py/SLEPc/DS.pyx#L409>`

getCompact()

Get the compact storage flag.

Not collective.

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

getDimensions()

Get the current dimensions.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:371 <slepc4py/SLEPc/DS.pyx#L371>`

getExtraRow()

Get the extra row flag.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:516 <slepc4py/SLEPc/DS.pyx#L516>`

getGSVDDimensions()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:784 <slepc4py/SLEPc/DS.pyx#L784>`

getHSVDDimensions()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:752 <slepc4py/SLEPc/DS.pyx#L752>`

getLeadingDimension()

Get the leading dimension of the allocated matrices.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:260 <slepc4py/SLEPc/DS.pyx#L260>`

getMat(matname)

Get the requested matrix as a sequential dense Mat object.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:599 <slepc4py/SLEPc/DS.pyx#L599>`

getMethod()

Get the method currently used in the DS.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:438 <slepc4py/SLEPc/DS.pyx#L438>`

getOptionsPrefix()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:205 <slepc4py/SLEPc/DS.pyx#L205>`

getPEPCoefficients()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:847 <slepc4py/SLEPc/DS.pyx#L847>`

getPEPDegree()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:816 <slepc4py/SLEPc/DS.pyx#L816>`

getParallel()

Get the mode of operation in parallel runs.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:329 <slepc4py/SLEPc/DS.pyx#L329>`

getRefined()

Get the refined vectors flag.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:556 <slepc4py/SLEPc/DS.pyx#L556>`

getSVDDimensions()

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

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:723 <slepc4py/SLEPc/DS.pyx#L723>`

getState()

Get the current state.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:300 <slepc4py/SLEPc/DS.pyx#L300>`

getType()

Get the DS type of this object.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:154 <slepc4py/SLEPc/DS.pyx#L154>`

reset()

Reset the DS object.

Collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:114 <slepc4py/SLEPc/DS.pyx#L114>`

restoreMat(matname, mat)

Restore the previously seized matrix.

Not collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:621 <slepc4py/SLEPc/DS.pyx#L621>`

setBlockSize(bs)

Set the block size.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:395 <slepc4py/SLEPc/DS.pyx#L395>`

setCompact(comp)

Set the matrices’ compact storage flag.

Logically collective.

Notes

Compact storage is used in some DS types such as DS.Type.HEP <#slepc4py.SLEPc.DS.Type.HEP> when the matrix is tridiagonal. This flag can be used to indicate whether the user provides the matrix entries via the compact form (the tridiagonal DS.MatType.T <#slepc4py.SLEPc.DS.MatType.T>) or the non-compact one (DS.MatType.A <#slepc4py.SLEPc.DS.MatType.A>).

The default is False.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:453 <slepc4py/SLEPc/DS.pyx#L453>`

setDimensions(n=None, l=None, k=None)

Set the matrices sizes in the DS object.

Logically collective.

Notes

The internal arrays are not reallocated.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:344 <slepc4py/SLEPc/DS.pyx#L344>`

setExtraRow(ext)

Set a flag to indicate that the matrix has one extra row.

Logically collective.

Notes

In Krylov methods it is useful that the matrix representing the direct solver has one extra row, i.e., has dimension (n+1) n. If this flag is activated, all transformations applied to the right of the matrix also affect this additional row. In that case, (n+1) must be less or equal than the leading dimension.

The default is False.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:492 <slepc4py/SLEPc/DS.pyx#L492>`

setFromOptions()

Set DS options from the options database.

Collective.

Notes

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

:sources:`Source code at slepc4py/SLEPc/DS.pyx:220 <slepc4py/SLEPc/DS.pyx#L220>`

setGSVDDimensions(m, p)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:767 <slepc4py/SLEPc/DS.pyx#L767>`

setHSVDDimensions(m)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:738 <slepc4py/SLEPc/DS.pyx#L738>`

setIdentity(matname)

Set the identity on the active part of a matrix.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:638 <slepc4py/SLEPc/DS.pyx#L638>`

setMethod(meth)

Set the method to be used to solve the problem.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:424 <slepc4py/SLEPc/DS.pyx#L424>`

setOptionsPrefix(prefix=None)

Set the prefix used for searching for all DS 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.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:169 <slepc4py/SLEPc/DS.pyx#L169>`

setPEPCoefficients(pbc)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:831 <slepc4py/SLEPc/DS.pyx#L831>`

setPEPDegree(deg)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:802 <slepc4py/SLEPc/DS.pyx#L802>`

setParallel(pmode)

Set the mode of operation in parallel runs.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:315 <slepc4py/SLEPc/DS.pyx#L315>`

setRefined(ref)

Set a flag to indicate that refined vectors must be computed.

Logically collective.

Notes

Normally the vectors returned in DS.MatType.X <#slepc4py.SLEPc.DS.MatType.X> are eigenvectors of the projected matrix. With this flag activated, vectors() will return the right singular vector of the smallest singular value of matrix At - theta I, where At is the extended (n+1) times n matrix and theta is the Ritz value. This is used in the refined Ritz approximation.

The default is False.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:531 <slepc4py/SLEPc/DS.pyx#L531>`

setSVDDimensions(m)

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

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:709 <slepc4py/SLEPc/DS.pyx#L709>`

setState(state)

Set the state of the DS object.

Logically collective.

Notes

The state indicates that the dense system is in an initial state (raw), in an intermediate state (such as tridiagonal, Hessenberg or Hessenberg-triangular), in a condensed state (such as diagonal, Schur or generalized Schur), or in a truncated state.

This function is normally used to return to the raw state when the condensed structure is destroyed.

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

setType(ds_type)

Set the type for the DS object.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:139 <slepc4py/SLEPc/DS.pyx#L139>`

solve()

Solve the problem.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:669 <slepc4py/SLEPc/DS.pyx#L669>`

truncate(n, trim=False)

Truncate the system represented in the DS object.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:571 <slepc4py/SLEPc/DS.pyx#L571>`

updateExtraRow()

Ensure that the extra row gets up-to-date after a call to DS.solve().

Logically collective.

Perform all necessary operations so that the extra row gets up-to-date after a call to DS.solve().

:sources:`Source code at slepc4py/SLEPc/DS.pyx:588 <slepc4py/SLEPc/DS.pyx#L588>`

vectors(matname=X)

Compute vectors associated to the dense system such as eigenvectors.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:693 <slepc4py/SLEPc/DS.pyx#L693>`

view(viewer=None)

Print the DS data structure.

Collective.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:89 <slepc4py/SLEPc/DS.pyx#L89>`

block_size

The block size.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:885 <slepc4py/SLEPc/DS.pyx#L885>`

compact

Compact storage of matrices.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:899 <slepc4py/SLEPc/DS.pyx#L899>`

extra_row

If the matrix has one extra row.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:906 <slepc4py/SLEPc/DS.pyx#L906>`

method

The method to be used to solve the problem.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:892 <slepc4py/SLEPc/DS.pyx#L892>`

parallel

The mode of operation in parallel runs.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:878 <slepc4py/SLEPc/DS.pyx#L878>`

refined

If refined vectors must be computed.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:913 <slepc4py/SLEPc/DS.pyx#L913>`

state

The state of the DS object.

:sources:`Source code at slepc4py/SLEPc/DS.pyx:871 <slepc4py/SLEPc/DS.pyx#L871>`

class slepc4py.SLEPc.EPS

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

EPS.

Enumerations

Balance <#slepc4py.SLEPc.EPS.Balance>	EPS type of balancing used for non-Hermitian problems.
CISSExtraction <#slepc4py.SLEPc.EPS.CISSExtraction>	EPS CISS extraction technique.
CISSQuadRule <#slepc4py.SLEPc.EPS.CISSQuadRule>	EPS CISS quadrature rule.
Conv <#slepc4py.SLEPc.EPS.Conv>	EPS convergence test.
ConvergedReason <#slepc4py.SLEPc.EPS.ConvergedReason>	EPS convergence reasons.
ErrorType <#slepc4py.SLEPc.EPS.ErrorType>	EPS error type to assess accuracy of computed solutions.
Extraction <#slepc4py.SLEPc.EPS.Extraction>	EPS extraction technique.
KrylovSchurBSEType <#slepc4py.SLEPc.EPS.KrylovSchurBSEType>	EPS Krylov-Schur method for BSE problems.
LanczosReorthogType <#slepc4py.SLEPc.EPS.LanczosReorthogType>	EPS Lanczos reorthogonalization type.
PowerShiftType <#slepc4py.SLEPc.EPS.PowerShiftType>	EPS Power shift type.
ProblemType <#slepc4py.SLEPc.EPS.ProblemType>	EPS problem type.
Stop <#slepc4py.SLEPc.EPS.Stop>	EPS stopping test.
Type <#slepc4py.SLEPc.EPS.Type>	EPS type.
Which <#slepc4py.SLEPc.EPS.Which>	EPS desired part of spectrum.

class slepc4py.SLEPc.EPS.Balance

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

EPS type of balancing used for non-Hermitian problems.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.EPS.CISSExtraction

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

EPS CISS extraction technique.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.EPS.CISSQuadRule

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

EPS CISS quadrature rule.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.EPS.Conv

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

EPS convergence test.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.EPS.ConvergedReason

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

EPS convergence reasons.

Attributes Summary

Attributes Documentation

class slepc4py.SLEPc.EPS.ErrorType

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

EPS error type to assess accuracy of computed solutions.

Attributes Summary