Class EPS

Returns:

a new object with type S, a subtype of T

Overrides: object.__new__

Appends to the prefix used for searching for all EPS options
in the database.

Parameters
----------
prefix: string
        The prefix string to prepend to all EPS option requests.

Computes the error (based on the residual norm) associated with the i-th
computed eigenpair.

Parameters
----------
i: int
   Index of the solution to be considered.
etype: `EPS.ErrorType` enumerate
   The error type to compute.

Returns
-------
e: real
   The error bound, computed in various ways from the residual norm
   ``||Ax-kBx||_2`` where ``k`` is the eigenvalue and
   ``x`` is the eigenvector.

Notes
-----
The index ``i`` should be a value between ``0`` and
``nconv-1`` (see `getConverged()`).

Creates the EPS object.

Parameters
----------
comm: MPI_Comm, optional
      MPI communicator; if not provided, it defaults to all
      processes.

Destroys the EPS object.

Overrides: petsc4py.PETSc.Object.destroy

Displays the errors associated with the computed solution
(as well as the eigenvalues).

Parameters
----------
etype: `EPS.ErrorType` enumerate, optional
   The error type to compute.
viewer: Viewer, optional.
        Visualization context; if not provided, the standard
        output is used.

Notes
-----
By default, this function checks the error of all eigenpairs and prints
the eigenvalues if all of them are below the requested tolerance.
If the viewer has format ``ASCII_INFO_DETAIL`` then a table with
eigenvalues and corresponding errors is printed.

Gets the type of reorthogonalization used during the Arnoldi
iteration.

Returns
-------
delayed: bool
         True if delayed reorthogonalization is to be used.

Obtain the basis vector objects associated to the eigensolver.

Returns
-------
bv: BV
    The basis vectors context.

Gets the balancing type used by the EPS object,
and the associated parameters.

Returns
-------
balance: `EPS.Balance` enumerate
         The balancing method
iterations: int
            Number of iterations of the balancing algorithm
cutoff: real
        Cutoff value

Gets the extraction technique used in the CISS solver.

Returns
-------
extraction: `EPS.CISSExtraction` enumerate
       The extraction technique.

Retrieve the array of linear solver objects associated with
the CISS solver.

Returns
-------
ksp: list of `KSP`
     The linear solver objects.

Notes
-----
The number of `KSP` solvers is equal to the number of integration
points divided by the number of partitions. This value is halved in
the case of real matrices with a region centered at the real axis.

Gets the quadrature rule used in the CISS solver.

Returns
-------
quad: `EPS.CISSQuadRule` enumerate
       The quadrature rule.

Gets the values of various refinement parameters in the CISS solver.

Returns
-------
inner: int
     Number of iterative refinement iterations (inner loop).
blsize: int
     Number of iterative refinement iterations (blocksize loop).

Gets the values of various size parameters in the CISS solver.

Returns
-------
ip: int
     Number of integration points.
bs: int
     Block size.
ms: int
     Moment size.
npart: int
     Number of partitions when splitting the communicator.
bsmax: int
     Maximum block size.
realmats: bool
     True if A and B are real.

Gets the values of various threshold parameters in the CISS solver.

Returns
-------
delta: float
        Threshold for numerical rank.
spur: float
        Spurious threshold (to discard spurious eigenpairs.

Gets the flag for using the `ST` object in the CISS solver.

Returns
-------
usest: bool
    Whether to use the `ST` object or not.

Gets the number of converged eigenpairs.

Returns
-------
nconv: int
       Number of converged eigenpairs.

Notes
-----
This function should be called after `solve()` has finished.

Gets the reason why the `solve()` iteration was stopped.

Returns
-------
reason: `EPS.ConvergedReason` enumerate
        Negative value indicates diverged, positive value
        converged.

Return the method used to compute the error estimate
used in the convergence test.

Returns
-------
conv: EPS.Conv
    The method used to compute the error estimate
    used in the convergence test.

Obtain the direct solver associated to the eigensolver.

Returns
-------
ds: DS
    The direct solver context.

Gets the number of eigenvalues to compute and the dimension of
the subspace.

Returns
-------
nev: int
     Number of eigenvalues to compute.
ncv: int
     Maximum dimension of the subspace to be used by the
     solver.
mpd: int
     Maximum dimension allowed for the projected problem.

Gets the i-th solution of the eigenproblem as computed by
`solve()`.  The solution consists of both the eigenvalue and
the eigenvector.

Parameters
----------
i: int
   Index of the solution to be obtained.
Vr: Vec
    Placeholder for the returned eigenvector (real part).
Vi: Vec
    Placeholder for the returned eigenvector (imaginary part).

Returns
-------
e: scalar (possibly complex)
   The computed eigenvalue.

Notes
-----
The index ``i`` should be a value between ``0`` and
``nconv-1`` (see `getConverged()`). Eigenpairs are indexed
according to the ordering criterion established with
`setWhichEigenpairs()`.

Gets the i-th eigenvalue as computed by `solve()`.

Parameters
----------
i: int
   Index of the solution to be obtained.

Returns
-------
e: scalar (possibly complex)
   The computed eigenvalue.

Notes
-----
The index ``i`` should be a value between ``0`` and
``nconv-1`` (see `getConverged()`). Eigenpairs are indexed
according to the ordering criterion established with
`setWhichEigenpairs()`.

Gets the i-th eigenvector as computed by `solve()`.

Parameters
----------
i: int
   Index of the solution to be obtained.
Vr: Vec
    Placeholder for the returned eigenvector (real part).
Vi: Vec, optional
    Placeholder for the returned eigenvector (imaginary part).

Notes
-----
The index ``i`` should be a value between ``0`` and
``nconv-1`` (see `getConverged()`). Eigenpairs are indexed
according to the ordering criterion established with
`setWhichEigenpairs()`.

Returns the error estimate associated to the i-th computed
eigenpair.

Parameters
----------
i: int
   Index of the solution to be considered.

Returns
-------
e: real
   Error estimate.

Notes
-----
This is the error estimate used internally by the
eigensolver. The actual error bound can be computed with
`computeError()`.

Gets the extraction type used by the EPS object.

Returns
-------
extraction: `EPS.Extraction` enumerate
            The method of extraction.

Returns the orthogonalization used in the search subspace in
case of generalized Hermitian problems.

Returns
-------
borth: bool
      Whether to B-orthogonalize the search subspace.

Gets the number of vectors to be added to the searching space
in every iteration.

Returns
-------
bs: int
    The number of vectors added to the search space in every iteration.

Gets a flag indicating whether the double expansion variant
has been activated or not.

Returns
-------
doubleexp: bool
      True if using double expansion.

Gets the initial size of the searching space.

Returns
-------
initialsize: int
    The number of vectors of the initial searching subspace.

Gets a flag indicating if the search subspace is started with a
Krylov basis.

Returns
-------
krylovstart: bool
      True if starting the search subspace with a Krylov basis.

Gets the number of vectors of the search space after restart and
the number of vectors saved from the previous iteration.

Returns
-------
minv: int
      The number of vectors of the search subspace after restart.
plusk: int
      The number of vectors saved from the previous iteration.

Gets the computational interval for spectrum slicing.

Returns
-------
inta: float
        The left end of the interval.
intb: float
        The right end of the interval.

Notes
-----
If the interval was not set by the user, then zeros are returned.

Gets an orthonormal basis of the computed invariant subspace.

Returns
-------
subspace: list of Vec
   Basis of the invariant subspace.

Notes
-----
This function should be called after `solve()` has finished.

The returned vectors span an invariant subspace associated
with the computed eigenvalues. An invariant subspace ``X`` of
``A` satisfies ``A x`` in ``X`` for all ``x`` in ``X`` (a
similar definition applies for generalized eigenproblems).

Gets the current iteration number. If the call to `solve()` is
complete, then it returns the number of iterations carried out
by the solution method.

Returns
-------
its: int
     Iteration number.

Returns the orthogonalization used in the search subspace in
case of generalized Hermitian problems.

Returns
-------
borth: bool
      Whether to B-orthogonalize the search subspace.

Gets the number of vectors to be added to the searching space
in every iteration.

Returns
-------
bs: int
    The number of vectors added to the search space in every iteration.

Returns the flag indicating if the dynamic stopping is being used for
solving the correction equation.

Returns
-------
constant: bool
      Flag indicating if the dynamic stopping criterion is not being used.

Gets the threshold for changing the target in the correction equation.

Returns
-------
fix: float
     The threshold for changing the target.

Gets the initial size of the searching space.

Returns
-------
initialsize: int
    The number of vectors of the initial searching subspace.

Gets a flag indicating if the search subspace is started with a
Krylov basis.

Returns
-------
krylovstart: bool
      True if starting the search subspace with a Krylov basis.

Gets the number of vectors of the search space after restart and
the number of vectors saved from the previous iteration.

Returns
-------
minv: int
      The number of vectors of the search subspace after restart.
plusk: int
      The number of vectors saved from the previous iteration.

Gets the flag that enforces zero detection in spectrum slicing.

Returns
-------
detect: bool
      The zero detection flag.

Gets the dimensions used for each subsolve step in case of doing
spectrum slicing for a computational interval.

Returns
-------
nev: int
     Number of eigenvalues to compute.
ncv: int
     Maximum dimension of the subspace to be used by the solver.
mpd: int
     Maximum dimension allowed for the projected problem.

Gets the values of the shifts and their corresponding inertias
in case of doing spectrum slicing for a computational interval.

Returns
-------
shifts: list of float
     The values of the shifts used internally in the solver.
inertias: list of int
     The values of the inertia in each shift.

Retrieve the linear solver object associated with the internal `EPS`
object in case of doing spectrum slicing for a computational interval.

Returns
-------
ksp: `KSP`
     The linear solver object.

Gets the locking flag used in the Krylov-Schur method.

Returns
-------
lock: bool
      The locking flag.

Gets the number of partitions of the communicator in case of
spectrum slicing.

Returns
-------
npart: int
      The number of partitions.

Gets the restart parameter used in the Krylov-Schur method.

Returns
-------
keep: float
      The number of vectors to be kept at restart.

Gets information related to the case of doing spectrum slicing
for a computational interval with multiple communicators.

Returns
-------
k: int
     Number of the subinterval for the calling process.
n: int
     Number of eigenvalues found in the k-th subinterval.
v: Vec
     A vector owned by processes in the subcommunicator with dimensions
     compatible for locally computed eigenvectors.

Notes
-----
This function is only available for spectrum slicing runs.

The returned Vec should be destroyed by the user.

Gets the eigenproblem matrices stored internally in the subcommunicator
to which the calling process belongs.

Returns
-------
A: Mat
   The matrix associated with the eigensystem.
B: Mat
   The second matrix in the case of generalized eigenproblems.

Notes
-----
This is the analog of `getOperators()`, but returns the matrices distributed
differently (in the subcommunicator rather than in the parent communicator).

These matrices should not be modified by the user.

Gets the i-th eigenpair stored internally in the multi-communicator
to which the calling process belongs.

Parameters
----------
i: int
   Index of the solution to be obtained.
V: Vec
   Placeholder for the returned eigenvector.

Returns
-------
e: scalar
   The computed eigenvalue.

Notes
-----
The index ``i`` should be a value between ``0`` and ``n-1``,
where ``n`` is the number of vectors in the local subinterval,
see `getKrylovSchurSubcommInfo()`.

Returns the points that delimit the subintervals used
in spectrum slicing with several partitions.

Returns
-------
subint: list of float
    Real values specifying subintervals

Gets the block size used in the LOBPCG method.

Returns
-------
bs: int
    The block size.

Gets the locking flag used in the LOBPCG method.

Returns
-------
lock: bool
      The locking flag.

Gets the restart parameter used in the LOBPCG method.

Returns
-------
restart: float
      The restart parameter.

Gets the type of reorthogonalization used during the Lanczos
iteration.

Returns
-------
reorthog: `EPS.LanczosReorthogType` enumerate
          The type of reorthogonalization.

Gets the i-th left eigenvector as computed by `solve()`.

Parameters
----------
i: int
   Index of the solution to be obtained.
Wr: Vec
    Placeholder for the returned eigenvector (real part).
Wi: Vec, optional
    Placeholder for the returned eigenvector (imaginary part).

Notes
-----
The index ``i`` should be a value between ``0`` and
``nconv-1`` (see `getConverged()`). Eigensolutions are indexed
according to the ordering criterion established with
`setWhichEigenpairs()`.

Left eigenvectors are available only if the twosided flag was set
with `setTwoSided()`.

Return the rank values used for the Lyapunov step.

Returns
-------
rkc: int
     The compressed rank.
rkl: int
     The Lyapunov rank.

Gets the matrices associated with the eigenvalue problem.

Returns
-------
A: Mat
   The matrix associated with the eigensystem.
B: Mat
   The second matrix in the case of generalized eigenproblems.

Gets the prefix used for searching for all EPS options in the
database.

Returns
-------
prefix: string
        The prefix string set for this EPS object.

Overrides: petsc4py.PETSc.Object.getOptionsPrefix

Gets the type of shifts used during the power iteration.

Returns
-------
shift: `EPS.PowerShiftType` enumerate
       The type of shift.

Gets the problem type from the EPS object.

Returns
-------
problem_type: `EPS.ProblemType` enumerate
              The problem type that was previously set.

Returns the flag indicating whether purification is activated
or not.

Returns
-------
purify: bool
    Whether purification is activated or not.

Obtain the region object associated to the eigensolver.

Returns
-------
rg: RG
    The region context.

Gets the reset parameter used in the RQCG method.

Returns
-------
nrest: int
       The number of iterations between resets.

Obtain the spectral transformation (`ST`) object associated to
the eigensolver object.

Returns
-------
st: ST
    The spectral transformation.

Gets the value of the target.

Returns
-------
target: float (real or complex)
        The value of the target.

Notes
-----
If the target was not set by the user, then zero is returned.

Gets the tolerance and maximum iteration count used by the
default EPS convergence tests.

Returns
-------
tol: float
     The convergence tolerance.
max_it: int
     The maximum number of iterations

Returns the flag indicating whether all residual norms must be
computed or not.

Returns
-------
trackall: bool
    Whether the solver compute all residuals or not.

Returns the flag indicating whether true residual must be
computed explicitly or not.

Returns
-------
trueres: bool
    Whether the solver compute all residuals or not.

Returns the flag indicating whether a two-sided variant
of the algorithm is being used or not.

Returns
-------
twosided: bool
    Whether the two-sided variant is to be used or not.

Gets the EPS type of this object.

Returns
-------
type: `EPS.Type` enumerate
      The solver currently being used.

Overrides: petsc4py.PETSc.Object.getType

Returns which portion of the spectrum is to be sought.

Returns
-------
which: `EPS.Which` enumerate
       The portion of the spectrum to be sought by the solver.

Tells whether the EPS object corresponds to a generalized
eigenvalue problem.

Returns
-------
flag: bool
      True if two matrices were set with `setOperators()`.

Tells whether the EPS object corresponds to a Hermitian
eigenvalue problem.

Returns
-------
flag: bool
      True if the problem type set with `setProblemType()` was
      Hermitian.

Tells whether the EPS object corresponds to an eigenvalue problem
type that requires a positive (semi-) definite matrix B.

Returns
-------
flag: bool
      True if the problem type set with `setProblemType()` was
      positive.

Activates or deactivates delayed reorthogonalization in the
Arnoldi iteration.

Parameters
----------
delayed: bool
         True if delayed reorthogonalization is to be used.

Notes
-----
This call is only relevant if the type was set to
`EPS.Type.ARNOLDI` with `setType()`.

Delayed reorthogonalization is an aggressive optimization for
the Arnoldi eigensolver than may provide better scalability,
but sometimes makes the solver converge less than the default
algorithm.

Associates a basis vectors object to the eigensolver.

Parameters
----------
bv: BV
    The basis vectors context.

Specifies the balancing technique to be employed by the
eigensolver, and some parameters associated to it.

Parameters
----------
balance: `EPS.Balance` enumerate
         The balancing method
iterations: int
            Number of iterations of the balancing algorithm
cutoff: real
        Cutoff value

Sets the extraction technique used in the CISS solver.

Parameters
----------
extraction: `EPS.CISSExtraction` enumerate
       The extraction technique.

Sets the quadrature rule used in the CISS solver.

Parameters
----------
quad: `EPS.CISSQuadRule` enumerate
       The quadrature rule.

Sets the values of various refinement parameters in the CISS solver.

Parameters
----------
inner: int, optional
     Number of iterative refinement iterations (inner loop).
blsize: int, optional
     Number of iterative refinement iterations (blocksize loop).

Sets the values of various size parameters in the CISS solver.

Parameters
----------
ip: int, optional
     Number of integration points.
bs: int, optional
     Block size.
ms: int, optional
     Moment size.
npart: int, optional
     Number of partitions when splitting the communicator.
bsmax: int, optional
     Maximum block size.
realmats: bool, optional
     True if A and B are real.

Notes
-----
The default number of partitions is 1. This means the internal `KSP` object
is shared among all processes of the `EPS` communicator. Otherwise, the
communicator is split into npart communicators, so that `npart` `KSP` solves
proceed simultaneously.

Sets the values of various threshold parameters in the CISS solver.

Parameters
----------
delta: float
        Threshold for numerical rank.
spur: float
        Spurious threshold (to discard spurious eigenpairs).

Sets a flag indicating that the CISS solver will use the `ST`
object for the linear solves.

Parameters
----------
usest: bool
    Whether to use the `ST` object or not.

Specifies how to compute the error estimate
used in the convergence test.

Parameters
----------
conv: EPS.Conv
    The method used to compute the error estimate
    used in the convergence test.

Associates a direct solver object to the eigensolver.

Parameters
----------
ds: DS
    The direct solver context.

Add vectors to the basis of the deflation space.

Parameters
----------
space: a Vec or an array of Vec
       Set of basis vectors to be added to the deflation
       space.

Notes
-----
When a deflation space is given, the eigensolver seeks the
eigensolution in the restriction of the problem to the
orthogonal complement of this space. This can be used for
instance in the case that an invariant subspace is known
beforehand (such as the nullspace of the matrix).

The vectors do not need to be mutually orthonormal, since they
are explicitly orthonormalized internally.

These vectors do not persist from one `solve()` call to the other,
so the deflation space should be set every time.

Sets the number of eigenvalues to compute and the dimension of
the subspace.

Parameters
----------
nev: int, optional
     Number of eigenvalues to compute.
ncv: int, optional
     Maximum dimension of the subspace to be used by the
     solver.
mpd: int, optional
     Maximum dimension allowed for the projected problem.

Notes
-----
Use `DECIDE` for `ncv` and `mpd` to assign a reasonably good
value, which is dependent on the solution method.

The parameters `ncv` and `mpd` are intimately related, so that
the user is advised to set one of them at most. Normal usage
is the following:

+ In cases where `nev` is small, the user sets `ncv`
  (a reasonable default is 2 * `nev`).

+ In cases where `nev` is large, the user sets `mpd`.

The value of `ncv` should always be between `nev` and (`nev` +
`mpd`), typically `ncv` = `nev` + `mpd`. If `nev` is not too
large, `mpd` = `nev` is a reasonable choice, otherwise a
smaller value should be used.

Sets the extraction type used by the EPS object.

Parameters
----------
extraction: `EPS.Extraction` enumerate
            The extraction method to be used by the solver.

Notes
-----
Not all eigensolvers support all types of extraction. See the
SLEPc documentation for details.

By default, a standard Rayleigh-Ritz extraction is used. Other
extractions may be useful when computing interior eigenvalues.

Harmonic-type extractions are used in combination with a
*target*. See `setTarget()`.

Sets EPS options from the options database. This routine must
be called before `setUp()` if the user is to be allowed to set
the solver type.

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

Overrides: petsc4py.PETSc.Object.setFromOptions

Selects the orthogonalization that will be used in the search
subspace in case of generalized Hermitian problems.

Parameters
----------
borth: bool
      Whether to B-orthogonalize the search subspace.

Sets the number of vectors to be added to the searching space
in every iteration.

Parameters
----------
bs: int
    The number of vectors added to the search space in every iteration.

Activate a variant where the search subspace is expanded  with
K*[A*x B*x] (double expansion) instead of the classic K*r, where
K is the preconditioner, x the selected approximate eigenvector
and r its associated residual vector.

Parameters
----------
doubleexp: bool
      True if using double expansion.

Sets the initial size of the searching space.

Parameters
----------
initialsize: int
    The number of vectors of the initial searching subspace.

Activates or deactivates starting the search subspace
with a Krylov basis.

Parameters
----------
krylovstart: bool
      True if starting the search subspace with a Krylov basis.

Sets the number of vectors of the search space after restart and
the number of vectors saved from the previous iteration.

Parameters
----------
minv: int, optional
      The number of vectors of the search subspace after restart.
plusk: int, optional
      The number of vectors saved from the previous iteration.

Sets the initial space from which the eigensolver starts to
iterate.

Parameters
----------
space: Vec or sequence of Vec
   The initial space

Notes
-----
Some solvers start to iterate on a single vector (initial vector).
In that case, the other vectors are ignored.

In contrast to `setDeflationSpace()`, these vectors do not persist
from one `solve()` call to the other, so the initial space should be
set every time.

The vectors do not need to be mutually orthonormal, since they are
explicitly orthonormalized internally.

Common usage of this function is when the user can provide a rough
approximation of the wanted eigenspace. Then, convergence may be faster.

Defines the computational interval for spectrum slicing.

Parameters
----------
inta: float
        The left end of the interval.
intb: float
        The right end of the interval.

Notes
-----
Spectrum slicing is a technique employed for computing all
eigenvalues of symmetric eigenproblems in a given interval.
This function provides the interval to be considered. It must
be used in combination with `EPS.Which.ALL`, see
`setWhichEigenpairs()`.

Selects the orthogonalization that will be used in the search
subspace in case of generalized Hermitian problems.

Parameters
----------
borth: bool
      Whether to B-orthogonalize the search subspace.

Sets the number of vectors to be added to the searching space
in every iteration.

Parameters
----------
bs: int
    The number of vectors added to the search space in every iteration.

Deactivates the dynamic stopping criterion that sets the
`KSP` relative tolerance to `0.5**i`, where `i` is the number
of `EPS` iterations from the last converged value.

Parameters
----------
constant: bool
      If False, the `KSP` relative tolerance is set to `0.5**i`.

Sets the threshold for changing the target in the correction equation.

Parameters
----------
fix: float
     The threshold for changing the target.

Notes
-----
The target in the correction equation is fixed at the first iterations.
When the norm of the residual vector is lower than the fix value,
the target is set to the corresponding eigenvalue.

Sets the initial size of the searching space.

Parameters
----------
initialsize: int
    The number of vectors of the initial searching subspace.

Activates or deactivates starting the search subspace
with a Krylov basis.

Parameters
----------
krylovstart: bool
      True if starting the search subspace with a Krylov basis.

Sets the number of vectors of the search space after restart and
the number of vectors saved from the previous iteration.

Parameters
----------
minv: int, optional
      The number of vectors of the search subspace after restart.
plusk: int, optional
      The number of vectors saved from the previous iteration.

Sets a flag to enforce detection of zeros during the factorizations
throughout the spectrum slicing computation.

Parameters
----------
detect: bool
      True if zeros must checked for.

Notes
-----
A zero in the factorization indicates that a shift coincides with
an eigenvalue.

This flag is turned off by default, and may be necessary in some cases,
especially when several partitions are being used. This feature currently
requires an external package for factorizations with support for zero
detection, e.g. MUMPS.

Sets the dimensions used for each subsolve step in case of doing
spectrum slicing for a computational interval. The meaning of the
parameters is the same as in `setDimensions()`.

Parameters
----------
nev: int, optional
     Number of eigenvalues to compute.
ncv: int, optional
     Maximum dimension of the subspace to be used by the solver.
mpd: int, optional
     Maximum dimension allowed for the projected problem.

Choose between locking and non-locking variants of the
Krylov-Schur method.

Parameters
----------
lock: bool
      True if the locking variant must be selected.

Notes
-----
The default is to lock converged eigenpairs when the method restarts.
This behaviour can be changed so that all directions are kept in the
working subspace even if already converged to working accuracy (the
non-locking variant).

Sets the number of partitions for the case of doing spectrum
slicing for a computational interval with the communicator split
in several sub-communicators.

Parameters
----------
npart: int
      The number of partitions.

Notes
-----
By default, npart=1 so all processes in the communicator participate in
the processing of the whole interval. If npart>1 then the interval is
divided into npart subintervals, each of them being processed by a
subset of processes.

Sets the restart parameter for the Krylov-Schur method, in
particular the proportion of basis vectors that must be kept
after restart.

Parameters
----------
keep: float
      The number of vectors to be kept at restart.

Notes
-----
Allowed values are in the range [0.1,0.9]. The default is 0.5.

Sets the subinterval boundaries for spectrum slicing with a computational interval.

Parameters
----------
subint: list of float
    Real values specifying subintervals

Notes
-----
Logically Collective on EPS
This function must be called after setKrylovSchurPartitions().
For npart partitions, the argument subint must contain npart+1
real values sorted in ascending order:
subint_0, subint_1, ..., subint_npart,
where the first and last values must coincide with the interval
endpoints set with EPSSetInterval().
The subintervals are then defined by two consecutive points:
[subint_0,subint_1], [subint_1,subint_2], and so on.

Sets the block size of the LOBPCG method.

Parameters
----------
bs: int
    The block size.

Choose between locking and non-locking variants of the
LOBPCG method.

Parameters
----------
lock: bool
      True if the locking variant must be selected.

Notes
-----
This flag refers to soft locking (converged vectors within the current
block iterate), since hard locking is always used (when nev is larger
than the block size).

Sets the restart parameter for the LOBPCG method. The meaning
of this parameter is the proportion of vectors within the
current block iterate that must have converged in order to force
a restart with hard locking.

Parameters
----------
restart: float
      The percentage of the block of vectors to force a restart.

Notes
-----
Allowed values are in the range [0.1,1.0]. The default is 0.9.

Sets the type of reorthogonalization used during the Lanczos
iteration.

Parameters
----------
reorthog: `EPS.LanczosReorthogType` enumerate
          The type of reorthogonalization.

Notes
-----
This call is only relevant if the type was set to
`EPS.Type.LANCZOS` with `setType()`.

Sets the left initial space from which the eigensolver starts to
iterate.

Parameters
----------
space: Vec or sequence of Vec
   The left initial space

Notes
-----
Left initial vectors are used to initiate the left search space
in two-sided eigensolvers. Users should pass here an approximation
of the left eigenspace, if available.

The same comments in `setInitialSpace()` are applicable here.

Set the ranks used in the solution of the Lyapunov equation.

Parameters
----------
rkc: int, optional
     The compressed rank.
rkl: int, optional
     The Lyapunov rank.

Sets the matrices associated with the eigenvalue problem.

Parameters
----------
A: Mat
   The matrix associated with the eigensystem.
B: Mat, optional
   The second matrix in the case of generalized eigenproblems;
   if not provided, a standard eigenproblem is assumed.

Sets the prefix used for searching for all EPS options in the
database.

Parameters
----------
prefix: string
        The prefix string to prepend to all EPS option
        requests.

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.

For example, to distinguish between the runtime options for
two different EPS contexts, one could call::

    E1.setOptionsPrefix("eig1_")
    E2.setOptionsPrefix("eig2_")

Overrides: petsc4py.PETSc.Object.setOptionsPrefix

Sets the type of shifts used during the power iteration. This
can be used to emulate the Rayleigh Quotient Iteration (RQI)
method.

Parameters
----------
shift: `EPS.PowerShiftType` enumerate
       The type of shift.

Notes
-----
This call is only relevant if the type was set to
`EPS.Type.POWER` with `setType()`.

By default, shifts are constant
(`EPS.PowerShiftType.CONSTANT`) and the iteration is the
simple power method (or inverse iteration if a
shift-and-invert transformation is being used).

A variable shift can be specified
(`EPS.PowerShiftType.RAYLEIGH` or
`EPS.PowerShiftType.WILKINSON`). In this case, the iteration
behaves rather like a cubic converging method as RQI.

Specifies the type of the eigenvalue problem.

Parameters
----------
problem_type: `EPS.ProblemType` enumerate
       The problem type to be set.

Notes
-----
Allowed values are: Hermitian (HEP), non-Hermitian (NHEP),
generalized Hermitian (GHEP), generalized non-Hermitian
(GNHEP), and generalized non-Hermitian with positive
semi-definite B (PGNHEP).

This function must be used to instruct SLEPc to exploit
symmetry. If no problem type is specified, by default a
non-Hermitian problem is assumed (either standard or
generalized). If the user knows that the problem is Hermitian
(i.e. ``A=A^H``) or generalized Hermitian (i.e. ``A=A^H``,
``B=B^H``, and ``B`` positive definite) then it is recommended
to set the problem type so that eigensolver can exploit these
properties.

Activate or deactivate eigenvector purification.

Parameters
----------
purify: bool, optional
    True to activate purification (default).

Associates a region object to the eigensolver.

Parameters
----------
rg: RG
    The region context.

Sets the reset parameter of the RQCG iteration. Every nrest iterations,
the solver performs a Rayleigh-Ritz projection step.

Parameters
----------
nrest: int
       The number of iterations between resets.

Associates a spectral transformation object to the
eigensolver.

Parameters
----------
st: ST
    The spectral transformation.

Sets the value of the target.

Parameters
----------
target: float (real or complex)
        The value of the target.

Notes
-----
The target is a scalar value used to determine the portion of
the spectrum of interest. It is used in combination with
`setWhichEigenpairs()`.

Sets the tolerance and maximum iteration count used by the
default EPS convergence tests.

Parameters
----------
tol: float, optional
     The convergence tolerance.
max_it: int, optional
     The maximum number of iterations

Notes
-----
Use `DECIDE` for maxits to assign a reasonably good value,
which is dependent on the solution method.

Specifies if the solver must compute the residual of all
approximate eigenpairs or not.

Parameters
----------
trackall: bool
    Whether compute all residuals or not.

Specifies if the solver must compute the true residual
explicitly or not.

Parameters
----------
trueres: bool
    Whether compute the true residual or not.

Sets the solver to use a two-sided variant so that left
eigenvectors are also computed.

Parameters
----------
twosided: bool
    Whether the two-sided variant is to be used or not.

Selects the particular solver to be used in the EPS object.

Parameters
----------
eps_type: `EPS.Type` enumerate
          The solver to be used.

Notes
-----
See `EPS.Type` for available methods. The default is
`EPS.Type.KRYLOVSCHUR`.  Normally, it is best to use
`setFromOptions()` and then set the EPS type from the options
database rather than by using this routine.  Using the options
database provides the user with maximum flexibility in
evaluating the different available methods.

Sets up all the internal data structures necessary for the
execution of the eigensolver.

Notes
-----
This function need not be called explicitly in most cases,
since `solve()` calls it. It can be useful when one wants to
measure the set-up time separately from the solve time.

Specifies which portion of the spectrum is to be sought.

Parameters
----------
which: `EPS.Which` enumerate
       The portion of the spectrum to be sought by the solver.

Notes
-----
Not all eigensolvers implemented in EPS account for all the
possible values. Also, some values make sense only for certain
types of problems. If SLEPc is compiled for real numbers
`EPS.Which.LARGEST_IMAGINARY` and
`EPS.Which.SMALLEST_IMAGINARY` use the absolute value of the
imaginary part for eigenvalue selection.

Update the eigenproblem matrices stored internally in the
subcommunicator to which the calling process belongs.

Parameters
----------
s: float (real or complex)
   Scalar that multiplies the existing A matrix.
a: float (real or complex)
   Scalar used in the axpy operation on A.
Au: Mat, optional
   The matrix used in the axpy operation on A.
t: float (real or complex)
   Scalar that multiplies the existing B matrix.
b: float (real or complex)
   Scalar used in the axpy operation on B.
Bu: Mat, optional
   The matrix used in the axpy operation on B.
structure: `PETSc.Mat.Structure` enumerate
   Either same, different, or a subset of the non-zero sparsity pattern.
globalup: bool
   Whether global matrices must be updated or not.

Notes
-----
This function modifies the eigenproblem matrices at
subcommunicator level, and optionally updates the global
matrices in the parent communicator.  The updates are
expressed as ``A <-- s*A + a*Au``, ``B <-- t*B + b*Bu``.

It is possible to update one of the matrices, or both.

The matrices `Au` and `Bu` must be equal in all subcommunicators.

The `structure` flag is passed to the `PETSc.Mat.axpy()` operations
to perform the updates.

If `globalup` is True, communication is carried out to
reconstruct the updated matrices in the parent communicator.

Displays the computed eigenvalues in a viewer.

Parameters
----------
viewer: Viewer, optional.
        Visualization context; if not provided, the standard
        output is used.

Outputs computed eigenvectors to a viewer.

Parameters
----------
viewer: Viewer, optional.
        Visualization context; if not provided, the standard
        output is used.

Prints the EPS data structure.

Parameters
----------
viewer: Viewer, optional.
        Visualization context; if not provided, the standard
        output is used.

Overrides: petsc4py.PETSc.Object.view