Actual source code: slepcpep.h

slepc-3.23.2 2025-06-30
Report Typos and Errors
  1: /*
  2:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  3:    SLEPc - Scalable Library for Eigenvalue Problem Computations
  4:    Copyright (c) 2002-, Universitat Politecnica de Valencia, Spain

  6:    This file is part of SLEPc.
  7:    SLEPc is distributed under a 2-clause BSD license (see LICENSE).
  8:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  9: */
 10: /*
 11:    User interface for SLEPc's polynomial eigenvalue solvers
 12: */

 14: #pragma once

 16: #include <slepceps.h>

 18: /* SUBMANSEC = PEP */

 20: SLEPC_EXTERN PetscErrorCode PEPInitializePackage(void);
 21: SLEPC_EXTERN PetscErrorCode PEPFinalizePackage(void);

 23: /*S
 24:      PEP - Abstract SLEPc object that manages all the polynomial eigenvalue
 25:      problem solvers.

 27:    Level: beginner

 29: .seealso:  PEPCreate()
 30: S*/
 31: typedef struct _p_PEP* PEP;

 33: /*J
 34:     PEPType - String with the name of a polynomial eigensolver

 36:    Level: beginner

 38: .seealso: PEPSetType(), PEP
 39: J*/
 40: typedef const char *PEPType;
 41: #define PEPLINEAR    "linear"
 42: #define PEPQARNOLDI  "qarnoldi"
 43: #define PEPTOAR      "toar"
 44: #define PEPSTOAR     "stoar"
 45: #define PEPJD        "jd"
 46: #define PEPCISS      "ciss"

 48: /* Logging support */
 49: SLEPC_EXTERN PetscClassId PEP_CLASSID;

 51: /*E
 52:     PEPProblemType - Determines the type of the polynomial eigenproblem

 54:     PEP_HERMITIAN is used when all A_i are Hermitian,
 55:     PEP_HYPERBOLIC is reserved for a QEP with Hermitian matrices, M>0, (x'Cx)^2 > 4(x'Mx)(x'Kx),
 56:     PEP_GYROSCOPIC is for aQEP with M, K  Hermitian, M>0, C skew-Hermitian.

 58:     Level: intermediate

 60: .seealso: PEPSetProblemType(), PEPGetProblemType()
 61: E*/
 62: typedef enum { PEP_GENERAL    = 1,
 63:                PEP_HERMITIAN  = 2,
 64:                PEP_HYPERBOLIC = 3,
 65:                PEP_GYROSCOPIC = 4
 66:              } PEPProblemType;

 68: /*E
 69:     PEPWhich - Determines which part of the spectrum is requested

 71:     Level: intermediate

 73: .seealso: PEPSetWhichEigenpairs(), PEPGetWhichEigenpairs()
 74: E*/
 75: typedef enum { PEP_LARGEST_MAGNITUDE  = 1,
 76:                PEP_SMALLEST_MAGNITUDE = 2,
 77:                PEP_LARGEST_REAL       = 3,
 78:                PEP_SMALLEST_REAL      = 4,
 79:                PEP_LARGEST_IMAGINARY  = 5,
 80:                PEP_SMALLEST_IMAGINARY = 6,
 81:                PEP_TARGET_MAGNITUDE   = 7,
 82:                PEP_TARGET_REAL        = 8,
 83:                PEP_TARGET_IMAGINARY   = 9,
 84:                PEP_ALL                = 10,
 85:                PEP_WHICH_USER         = 11 } PEPWhich;

 87: /*E
 88:     PEPBasis - The type of polynomial basis used to represent the polynomial
 89:     eigenproblem

 91:     Level: intermediate

 93: .seealso: PEPSetBasis()
 94: E*/
 95: typedef enum { PEP_BASIS_MONOMIAL,
 96:                PEP_BASIS_CHEBYSHEV1,
 97:                PEP_BASIS_CHEBYSHEV2,
 98:                PEP_BASIS_LEGENDRE,
 99:                PEP_BASIS_LAGUERRE,
100:                PEP_BASIS_HERMITE } PEPBasis;
101: SLEPC_EXTERN const char *PEPBasisTypes[];

103: /*E
104:     PEPScale - The scaling strategy

106:     Level: intermediate

108: .seealso: PEPSetScale()
109: E*/
110: typedef enum { PEP_SCALE_NONE,
111:                PEP_SCALE_SCALAR,
112:                PEP_SCALE_DIAGONAL,
113:                PEP_SCALE_BOTH } PEPScale;
114: SLEPC_EXTERN const char *PEPScaleTypes[];

116: /*E
117:     PEPRefine - The refinement type

119:     Level: intermediate

121: .seealso: PEPSetRefine()
122: E*/
123: typedef enum { PEP_REFINE_NONE,
124:                PEP_REFINE_SIMPLE,
125:                PEP_REFINE_MULTIPLE } PEPRefine;
126: SLEPC_EXTERN const char *PEPRefineTypes[];

128: /*E
129:     PEPRefineScheme - The scheme used for solving linear systems during iterative refinement

131:     Level: intermediate

133: .seealso: PEPSetRefine()
134: E*/
135: typedef enum { PEP_REFINE_SCHEME_SCHUR    = 1,
136:                PEP_REFINE_SCHEME_MBE      = 2,
137:                PEP_REFINE_SCHEME_EXPLICIT = 3 } PEPRefineScheme;
138: SLEPC_EXTERN const char *PEPRefineSchemes[];

140: /*E
141:     PEPExtract - The extraction type

143:     Level: intermediate

145: .seealso: PEPSetExtract()
146: E*/
147: typedef enum { PEP_EXTRACT_NONE       = 1,
148:                PEP_EXTRACT_NORM       = 2,
149:                PEP_EXTRACT_RESIDUAL   = 3,
150:                PEP_EXTRACT_STRUCTURED = 4 } PEPExtract;
151: SLEPC_EXTERN const char *PEPExtractTypes[];

153: /*E
154:     PEPErrorType - The error type used to assess accuracy of computed solutions

156:     Level: intermediate

158: .seealso: PEPComputeError()
159: E*/
160: typedef enum { PEP_ERROR_ABSOLUTE,
161:                PEP_ERROR_RELATIVE,
162:                PEP_ERROR_BACKWARD } PEPErrorType;
163: SLEPC_EXTERN const char *PEPErrorTypes[];

165: /*E
166:     PEPConv - Determines the convergence test

168:     Level: intermediate

170: .seealso: PEPSetConvergenceTest(), PEPSetConvergenceTestFunction()
171: E*/
172: typedef enum { PEP_CONV_ABS,
173:                PEP_CONV_REL,
174:                PEP_CONV_NORM,
175:                PEP_CONV_USER } PEPConv;

177: /*E
178:     PEPStop - Determines the stopping test

180:     Level: advanced

182: .seealso: PEPSetStoppingTest(), PEPSetStoppingTestFunction()
183: E*/
184: typedef enum { PEP_STOP_BASIC,
185:                PEP_STOP_USER } PEPStop;

187: /*E
188:     PEPConvergedReason - Reason an eigensolver was said to
189:          have converged or diverged

191:     Level: intermediate

193: .seealso: PEPSolve(), PEPGetConvergedReason(), PEPSetTolerances()
194: E*/
195: typedef enum {/* converged */
196:               PEP_CONVERGED_TOL                =  1,
197:               PEP_CONVERGED_USER               =  2,
198:               /* diverged */
199:               PEP_DIVERGED_ITS                 = -1,
200:               PEP_DIVERGED_BREAKDOWN           = -2,
201:               PEP_DIVERGED_SYMMETRY_LOST       = -3,
202:               PEP_CONVERGED_ITERATING          =  0} PEPConvergedReason;
203: SLEPC_EXTERN const char *const*PEPConvergedReasons;

205: SLEPC_EXTERN PetscErrorCode PEPCreate(MPI_Comm,PEP*);
206: SLEPC_EXTERN PetscErrorCode PEPDestroy(PEP*);
207: SLEPC_EXTERN PetscErrorCode PEPReset(PEP);
208: SLEPC_EXTERN PetscErrorCode PEPSetType(PEP,PEPType);
209: SLEPC_EXTERN PetscErrorCode PEPGetType(PEP,PEPType*);
210: SLEPC_EXTERN PetscErrorCode PEPSetProblemType(PEP,PEPProblemType);
211: SLEPC_EXTERN PetscErrorCode PEPGetProblemType(PEP,PEPProblemType*);
212: SLEPC_EXTERN PetscErrorCode PEPSetOperators(PEP,PetscInt,Mat[]);
213: SLEPC_EXTERN PetscErrorCode PEPGetOperators(PEP,PetscInt,Mat*);
214: SLEPC_EXTERN PetscErrorCode PEPGetNumMatrices(PEP,PetscInt*);
215: SLEPC_EXTERN PetscErrorCode PEPSetTarget(PEP,PetscScalar);
216: SLEPC_EXTERN PetscErrorCode PEPGetTarget(PEP,PetscScalar*);
217: SLEPC_EXTERN PetscErrorCode PEPSetInterval(PEP,PetscReal,PetscReal);
218: SLEPC_EXTERN PetscErrorCode PEPGetInterval(PEP,PetscReal*,PetscReal*);
219: SLEPC_EXTERN PetscErrorCode PEPSetFromOptions(PEP);
220: SLEPC_EXTERN PetscErrorCode PEPSetDSType(PEP);
221: SLEPC_EXTERN PetscErrorCode PEPSetUp(PEP);
222: SLEPC_EXTERN PetscErrorCode PEPSolve(PEP);
223: SLEPC_EXTERN PetscErrorCode PEPView(PEP,PetscViewer);
224: SLEPC_EXTERN PetscErrorCode PEPViewFromOptions(PEP,PetscObject,const char[]);
225: SLEPC_EXTERN PetscErrorCode PEPErrorView(PEP,PEPErrorType,PetscViewer);
226: PETSC_DEPRECATED_FUNCTION(3, 6, 0, "PEPErrorView()", ) static inline PetscErrorCode PEPPrintSolution(PEP pep,PetscViewer v) {return PEPErrorView(pep,PEP_ERROR_BACKWARD,v);}
227: SLEPC_EXTERN PetscErrorCode PEPErrorViewFromOptions(PEP);
228: SLEPC_EXTERN PetscErrorCode PEPConvergedReasonView(PEP,PetscViewer);
229: SLEPC_EXTERN PetscErrorCode PEPConvergedReasonViewFromOptions(PEP);
230: PETSC_DEPRECATED_FUNCTION(3, 14, 0, "PEPConvergedReasonView()", ) static inline PetscErrorCode PEPReasonView(PEP pep,PetscViewer v) {return PEPConvergedReasonView(pep,v);}
231: PETSC_DEPRECATED_FUNCTION(3, 14, 0, "PEPConvergedReasonViewFromOptions()", ) static inline PetscErrorCode PEPReasonViewFromOptions(PEP pep) {return PEPConvergedReasonViewFromOptions(pep);}
232: SLEPC_EXTERN PetscErrorCode PEPValuesView(PEP,PetscViewer);
233: SLEPC_EXTERN PetscErrorCode PEPValuesViewFromOptions(PEP);
234: SLEPC_EXTERN PetscErrorCode PEPVectorsView(PEP,PetscViewer);
235: SLEPC_EXTERN PetscErrorCode PEPVectorsViewFromOptions(PEP);
236: SLEPC_EXTERN PetscErrorCode PEPSetBV(PEP,BV);
237: SLEPC_EXTERN PetscErrorCode PEPGetBV(PEP,BV*);
238: SLEPC_EXTERN PetscErrorCode PEPSetRG(PEP,RG);
239: SLEPC_EXTERN PetscErrorCode PEPGetRG(PEP,RG*);
240: SLEPC_EXTERN PetscErrorCode PEPSetDS(PEP,DS);
241: SLEPC_EXTERN PetscErrorCode PEPGetDS(PEP,DS*);
242: SLEPC_EXTERN PetscErrorCode PEPSetST(PEP,ST);
243: SLEPC_EXTERN PetscErrorCode PEPGetST(PEP,ST*);
244: SLEPC_EXTERN PetscErrorCode PEPRefineGetKSP(PEP,KSP*);

246: SLEPC_EXTERN PetscErrorCode PEPSetTolerances(PEP,PetscReal,PetscInt);
247: SLEPC_EXTERN PetscErrorCode PEPGetTolerances(PEP,PetscReal*,PetscInt*);
248: SLEPC_EXTERN PetscErrorCode PEPSetConvergenceTest(PEP,PEPConv);
249: SLEPC_EXTERN PetscErrorCode PEPGetConvergenceTest(PEP,PEPConv*);
250: SLEPC_EXTERN PetscErrorCode PEPConvergedAbsolute(PEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);
251: SLEPC_EXTERN PetscErrorCode PEPConvergedRelative(PEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);
252: SLEPC_EXTERN PetscErrorCode PEPConvergedNorm(PEP,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*);
253: SLEPC_EXTERN PetscErrorCode PEPSetStoppingTest(PEP,PEPStop);
254: SLEPC_EXTERN PetscErrorCode PEPGetStoppingTest(PEP,PEPStop*);
255: SLEPC_EXTERN PetscErrorCode PEPStoppingBasic(PEP,PetscInt,PetscInt,PetscInt,PetscInt,PEPConvergedReason*,void*);
256: SLEPC_EXTERN PetscErrorCode PEPGetConvergedReason(PEP,PEPConvergedReason*);

258: SLEPC_EXTERN PetscErrorCode PEPSetDimensions(PEP,PetscInt,PetscInt,PetscInt);
259: SLEPC_EXTERN PetscErrorCode PEPGetDimensions(PEP,PetscInt*,PetscInt*,PetscInt*);
260: SLEPC_EXTERN PetscErrorCode PEPSetScale(PEP,PEPScale,PetscReal,Vec,Vec,PetscInt,PetscReal);
261: SLEPC_EXTERN PetscErrorCode PEPGetScale(PEP,PEPScale*,PetscReal*,Vec*,Vec*,PetscInt*,PetscReal*);
262: SLEPC_EXTERN PetscErrorCode PEPSetRefine(PEP,PEPRefine,PetscInt,PetscReal,PetscInt,PEPRefineScheme);
263: SLEPC_EXTERN PetscErrorCode PEPGetRefine(PEP,PEPRefine*,PetscInt*,PetscReal*,PetscInt*,PEPRefineScheme*);
264: SLEPC_EXTERN PetscErrorCode PEPSetExtract(PEP,PEPExtract);
265: SLEPC_EXTERN PetscErrorCode PEPGetExtract(PEP,PEPExtract*);
266: SLEPC_EXTERN PetscErrorCode PEPSetBasis(PEP,PEPBasis);
267: SLEPC_EXTERN PetscErrorCode PEPGetBasis(PEP,PEPBasis*);

269: SLEPC_EXTERN PetscErrorCode PEPGetConverged(PEP,PetscInt*);
270: SLEPC_EXTERN PetscErrorCode PEPGetEigenpair(PEP,PetscInt,PetscScalar*,PetscScalar*,Vec,Vec);
271: SLEPC_EXTERN PetscErrorCode PEPComputeError(PEP,PetscInt,PEPErrorType,PetscReal*);
272: PETSC_DEPRECATED_FUNCTION(3, 6, 0, "PEPComputeError()", ) static inline PetscErrorCode PEPComputeRelativeError(PEP pep,PetscInt i,PetscReal *r) {return PEPComputeError(pep,i,PEP_ERROR_BACKWARD,r);}
273: PETSC_DEPRECATED_FUNCTION(3, 6, 0, "PEPComputeError() with PEP_ERROR_ABSOLUTE", ) static inline PetscErrorCode PEPComputeResidualNorm(PEP pep,PetscInt i,PetscReal *r) {return PEPComputeError(pep,i,PEP_ERROR_ABSOLUTE,r);}
274: SLEPC_EXTERN PetscErrorCode PEPGetErrorEstimate(PEP,PetscInt,PetscReal*);
275: SLEPC_EXTERN PetscErrorCode PEPGetIterationNumber(PEP,PetscInt*);

277: SLEPC_EXTERN PetscErrorCode PEPSetInitialSpace(PEP,PetscInt,Vec[]);
278: SLEPC_EXTERN PetscErrorCode PEPSetWhichEigenpairs(PEP,PEPWhich);
279: SLEPC_EXTERN PetscErrorCode PEPGetWhichEigenpairs(PEP,PEPWhich*);

281: SLEPC_EXTERN PetscErrorCode PEPSetTrackAll(PEP,PetscBool);
282: SLEPC_EXTERN PetscErrorCode PEPGetTrackAll(PEP,PetscBool*);

284: SLEPC_EXTERN PetscErrorCode PEPMonitor(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt);
285: SLEPC_EXTERN PetscErrorCode PEPMonitorSet(PEP,PetscErrorCode (*)(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,void*),void*,PetscCtxDestroyFn*);
286: SLEPC_EXTERN PetscErrorCode PEPMonitorCancel(PEP);
287: SLEPC_EXTERN PetscErrorCode PEPGetMonitorContext(PEP,void*);

289: SLEPC_EXTERN PetscErrorCode PEPMonitorSetFromOptions(PEP,const char[],const char[],void*,PetscBool);
290: SLEPC_EXTERN PetscErrorCode PEPMonitorFirst(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*);
291: SLEPC_EXTERN PetscErrorCode PEPMonitorFirstDrawLG(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*);
292: SLEPC_EXTERN PetscErrorCode PEPMonitorFirstDrawLGCreate(PetscViewer,PetscViewerFormat,void*,PetscViewerAndFormat**);
293: SLEPC_EXTERN PetscErrorCode PEPMonitorAll(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*);
294: SLEPC_EXTERN PetscErrorCode PEPMonitorAllDrawLG(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*);
295: SLEPC_EXTERN PetscErrorCode PEPMonitorAllDrawLGCreate(PetscViewer,PetscViewerFormat,void*,PetscViewerAndFormat**);
296: SLEPC_EXTERN PetscErrorCode PEPMonitorConverged(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*);
297: SLEPC_EXTERN PetscErrorCode PEPMonitorConvergedCreate(PetscViewer,PetscViewerFormat,void*,PetscViewerAndFormat**);
298: SLEPC_EXTERN PetscErrorCode PEPMonitorConvergedDrawLG(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*);
299: SLEPC_EXTERN PetscErrorCode PEPMonitorConvergedDrawLGCreate(PetscViewer,PetscViewerFormat,void*,PetscViewerAndFormat**);
300: SLEPC_EXTERN PetscErrorCode PEPMonitorConvergedDestroy(PetscViewerAndFormat**);

302: SLEPC_EXTERN PetscErrorCode PEPSetOptionsPrefix(PEP,const char*);
303: SLEPC_EXTERN PetscErrorCode PEPAppendOptionsPrefix(PEP,const char*);
304: SLEPC_EXTERN PetscErrorCode PEPGetOptionsPrefix(PEP,const char*[]);

306: SLEPC_EXTERN PetscFunctionList PEPList;
307: SLEPC_EXTERN PetscFunctionList PEPMonitorList;
308: SLEPC_EXTERN PetscFunctionList PEPMonitorCreateList;
309: SLEPC_EXTERN PetscFunctionList PEPMonitorDestroyList;
310: SLEPC_EXTERN PetscErrorCode PEPRegister(const char[],PetscErrorCode(*)(PEP));
311: SLEPC_EXTERN PetscErrorCode PEPMonitorRegister(const char[],PetscViewerType,PetscViewerFormat,PetscErrorCode(*)(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*),PetscErrorCode(*)(PetscViewer,PetscViewerFormat,void*,PetscViewerAndFormat**),PetscErrorCode(*)(PetscViewerAndFormat**));

313: SLEPC_EXTERN PetscErrorCode PEPSetWorkVecs(PEP,PetscInt);
314: SLEPC_EXTERN PetscErrorCode PEPAllocateSolution(PEP,PetscInt);

316: /*S
317:   PEPConvergenceTestFn - A prototype of a PEP convergence test function that would be passed to PEPSetConvergenceTestFunction()

319:   Calling Sequence:
320: +   pep    - eigensolver context obtained from PEPCreate()
321: .   eigr   - real part of the eigenvalue
322: .   eigi   - imaginary part of the eigenvalue
323: .   res    - residual norm associated to the eigenpair
324: .   errest - [output] computed error estimate
325: -   ctx    - [optional] user-defined context for private data for the
326:              convergence test routine (may be NULL)

328:   Level: advanced

330: .seealso: PEPSetConvergenceTestFunction()
331: S*/
332: PETSC_EXTERN_TYPEDEF typedef PetscErrorCode(PEPConvergenceTestFn)(PEP pep,PetscScalar eigr,PetscScalar eigi,PetscReal res,PetscReal *errest,void *ctx);

334: /*S
335:   PEPStoppingTestFn - A prototype of a PEP stopping test function that would be passed to PEPSetStoppingTestFunction()

337:   Calling Sequence:
338: +   pep    - eigensolver context obtained from PEPCreate()
339: .   its    - current number of iterations
340: .   max_it - maximum number of iterations
341: .   nconv  - number of currently converged eigenpairs
342: .   nev    - number of requested eigenpairs
343: .   reason - [output] result of the stopping test
344: -   ctx    - [optional] user-defined context for private data for the
345:              stopping test routine (may be NULL)

347:   Level: advanced

349: .seealso: PEPSetStoppingTestFunction()
350: S*/
351: PETSC_EXTERN_TYPEDEF typedef PetscErrorCode(PEPStoppingTestFn)(PEP pep,PetscInt its,PetscInt max_it,PetscInt nconv,PetscInt nev,PEPConvergedReason *reason,void *ctx);

353: SLEPC_EXTERN PetscErrorCode PEPSetConvergenceTestFunction(PEP,PEPConvergenceTestFn*,void*,PetscCtxDestroyFn*);
354: SLEPC_EXTERN PetscErrorCode PEPSetStoppingTestFunction(PEP,PEPStoppingTestFn*,void*,PetscCtxDestroyFn*);
355: SLEPC_EXTERN PetscErrorCode PEPSetEigenvalueComparison(PEP,SlepcEigenvalueComparisonFn*,void*);

357: /* --------- options specific to particular eigensolvers -------- */

359: SLEPC_EXTERN PetscErrorCode PEPLinearSetLinearization(PEP,PetscReal,PetscReal);
360: SLEPC_EXTERN PetscErrorCode PEPLinearGetLinearization(PEP,PetscReal*,PetscReal*);
361: SLEPC_EXTERN PetscErrorCode PEPLinearSetExplicitMatrix(PEP,PetscBool);
362: SLEPC_EXTERN PetscErrorCode PEPLinearGetExplicitMatrix(PEP,PetscBool*);
363: SLEPC_EXTERN PetscErrorCode PEPLinearSetEPS(PEP,EPS);
364: SLEPC_EXTERN PetscErrorCode PEPLinearGetEPS(PEP,EPS*);
365: PETSC_DEPRECATED_FUNCTION(3, 10, 0, "PEPLinearSetLinearization()", ) static inline PetscErrorCode PEPLinearSetCompanionForm(PEP pep,PetscInt cform) {return (cform==1)?PEPLinearSetLinearization(pep,1.0,0.0):PEPLinearSetLinearization(pep,0.0,1.0);}
366: PETSC_DEPRECATED_FUNCTION(3, 10, 0, "PEPLinearGetLinearization()", ) static inline PetscErrorCode PEPLinearGetCompanionForm(PEP pep,PetscInt *cform) {(void)pep; if (cform) *cform=1; return PETSC_SUCCESS;}

368: SLEPC_EXTERN PetscErrorCode PEPQArnoldiSetRestart(PEP,PetscReal);
369: SLEPC_EXTERN PetscErrorCode PEPQArnoldiGetRestart(PEP,PetscReal*);
370: SLEPC_EXTERN PetscErrorCode PEPQArnoldiSetLocking(PEP,PetscBool);
371: SLEPC_EXTERN PetscErrorCode PEPQArnoldiGetLocking(PEP,PetscBool*);

373: SLEPC_EXTERN PetscErrorCode PEPTOARSetRestart(PEP,PetscReal);
374: SLEPC_EXTERN PetscErrorCode PEPTOARGetRestart(PEP,PetscReal*);
375: SLEPC_EXTERN PetscErrorCode PEPTOARSetLocking(PEP,PetscBool);
376: SLEPC_EXTERN PetscErrorCode PEPTOARGetLocking(PEP,PetscBool*);

378: SLEPC_EXTERN PetscErrorCode PEPSTOARSetLinearization(PEP,PetscReal,PetscReal);
379: SLEPC_EXTERN PetscErrorCode PEPSTOARGetLinearization(PEP,PetscReal*,PetscReal*);
380: SLEPC_EXTERN PetscErrorCode PEPSTOARSetLocking(PEP,PetscBool);
381: SLEPC_EXTERN PetscErrorCode PEPSTOARGetLocking(PEP,PetscBool*);
382: SLEPC_EXTERN PetscErrorCode PEPSTOARSetDetectZeros(PEP,PetscBool);
383: SLEPC_EXTERN PetscErrorCode PEPSTOARGetDetectZeros(PEP,PetscBool*);
384: SLEPC_EXTERN PetscErrorCode PEPSTOARGetInertias(PEP,PetscInt*,PetscReal*[],PetscInt*[]);
385: SLEPC_EXTERN PetscErrorCode PEPSTOARSetDimensions(PEP,PetscInt,PetscInt,PetscInt);
386: SLEPC_EXTERN PetscErrorCode PEPSTOARGetDimensions(PEP,PetscInt*,PetscInt*,PetscInt*);
387: SLEPC_EXTERN PetscErrorCode PEPSTOARSetCheckEigenvalueType(PEP,PetscBool);
388: SLEPC_EXTERN PetscErrorCode PEPSTOARGetCheckEigenvalueType(PEP,PetscBool*);
389: SLEPC_EXTERN PetscErrorCode PEPCheckDefiniteQEP(PEP,PetscReal*,PetscReal*,PetscInt*,PetscInt*);

391: /*E
392:     PEPJDProjection - The type of projection to be used in the Jacobi-Davidson solver

394:     Level: intermediate

396: .seealso: PEPJDSetProjection()
397: E*/
398: typedef enum { PEP_JD_PROJECTION_HARMONIC,
399:                PEP_JD_PROJECTION_ORTHOGONAL } PEPJDProjection;
400: SLEPC_EXTERN const char *PEPJDProjectionTypes[];

402: SLEPC_EXTERN PetscErrorCode PEPJDSetRestart(PEP,PetscReal);
403: SLEPC_EXTERN PetscErrorCode PEPJDGetRestart(PEP,PetscReal*);
404: SLEPC_EXTERN PetscErrorCode PEPJDSetFix(PEP,PetscReal);
405: SLEPC_EXTERN PetscErrorCode PEPJDGetFix(PEP,PetscReal*);
406: SLEPC_EXTERN PetscErrorCode PEPJDSetReusePreconditioner(PEP,PetscBool);
407: SLEPC_EXTERN PetscErrorCode PEPJDGetReusePreconditioner(PEP,PetscBool*);
408: SLEPC_EXTERN PetscErrorCode PEPJDSetMinimalityIndex(PEP,PetscInt);
409: SLEPC_EXTERN PetscErrorCode PEPJDGetMinimalityIndex(PEP,PetscInt*);
410: SLEPC_EXTERN PetscErrorCode PEPJDSetProjection(PEP,PEPJDProjection);
411: SLEPC_EXTERN PetscErrorCode PEPJDGetProjection(PEP,PEPJDProjection*);

413: /*E
414:     PEPCISSExtraction - determines the extraction technique in the CISS solver

416:     Level: advanced

418: .seealso: PEPCISSSetExtraction(), PEPCISSGetExtraction()
419: E*/
420: typedef enum { PEP_CISS_EXTRACTION_RITZ,
421:                PEP_CISS_EXTRACTION_HANKEL,
422:                PEP_CISS_EXTRACTION_CAA    } PEPCISSExtraction;
423: SLEPC_EXTERN const char *PEPCISSExtractions[];

425: #if defined(PETSC_USE_COMPLEX) || defined(PETSC_CLANG_STATIC_ANALYZER)
426: SLEPC_EXTERN PetscErrorCode PEPCISSSetExtraction(PEP,PEPCISSExtraction);
427: SLEPC_EXTERN PetscErrorCode PEPCISSGetExtraction(PEP,PEPCISSExtraction*);
428: SLEPC_EXTERN PetscErrorCode PEPCISSSetSizes(PEP,PetscInt,PetscInt,PetscInt,PetscInt,PetscInt,PetscBool);
429: SLEPC_EXTERN PetscErrorCode PEPCISSGetSizes(PEP,PetscInt*,PetscInt*,PetscInt*,PetscInt*,PetscInt*,PetscBool*);
430: SLEPC_EXTERN PetscErrorCode PEPCISSSetThreshold(PEP,PetscReal,PetscReal);
431: SLEPC_EXTERN PetscErrorCode PEPCISSGetThreshold(PEP,PetscReal*,PetscReal*);
432: SLEPC_EXTERN PetscErrorCode PEPCISSSetRefinement(PEP,PetscInt,PetscInt);
433: SLEPC_EXTERN PetscErrorCode PEPCISSGetRefinement(PEP,PetscInt*,PetscInt*);
434: SLEPC_EXTERN PetscErrorCode PEPCISSGetKSPs(PEP,PetscInt*,KSP*[]);
435: #else
436: #define SlepcPEPCISSUnavailable(pep) do { \
437:     PetscFunctionBegin; \
438:     SETERRQ(PetscObjectComm((PetscObject)pep),PETSC_ERR_SUP,"%s() not available with real scalars",PETSC_FUNCTION_NAME); \
439:     } while (0)
440: static inline PetscErrorCode PEPCISSSetExtraction(PEP pep,PETSC_UNUSED PEPCISSExtraction ex) {SlepcPEPCISSUnavailable(pep);}
441: static inline PetscErrorCode PEPCISSGetExtraction(PEP pep,PETSC_UNUSED PEPCISSExtraction *ex) {SlepcPEPCISSUnavailable(pep);}
442: static inline PetscErrorCode PEPCISSSetSizes(PEP pep,PETSC_UNUSED PetscInt ip,PETSC_UNUSED PetscInt bs,PETSC_UNUSED PetscInt ms,PETSC_UNUSED PetscInt npart,PETSC_UNUSED PetscInt bsmax,PETSC_UNUSED PetscBool realmats) {SlepcPEPCISSUnavailable(pep);}
443: static inline PetscErrorCode PEPCISSGetSizes(PEP pep,PETSC_UNUSED PetscInt *ip,PETSC_UNUSED PetscInt *bs,PETSC_UNUSED PetscInt *ms,PETSC_UNUSED PetscInt *npart,PETSC_UNUSED PetscInt *bsmak,PETSC_UNUSED PetscBool *realmats) {SlepcPEPCISSUnavailable(pep);}
444: static inline PetscErrorCode PEPCISSSetThreshold(PEP pep,PETSC_UNUSED PetscReal delta,PETSC_UNUSED PetscReal spur) {SlepcPEPCISSUnavailable(pep);}
445: static inline PetscErrorCode PEPCISSGetThreshold(PEP pep,PETSC_UNUSED PetscReal *delta,PETSC_UNUSED PetscReal *spur) {SlepcPEPCISSUnavailable(pep);}
446: static inline PetscErrorCode PEPCISSSetRefinement(PEP pep,PETSC_UNUSED PetscInt inner,PETSC_UNUSED PetscInt blsize) {SlepcPEPCISSUnavailable(pep);}
447: static inline PetscErrorCode PEPCISSGetRefinement(PEP pep,PETSC_UNUSED PetscInt *inner,PETSC_UNUSED PetscInt *blsize) {SlepcPEPCISSUnavailable(pep);}
448: static inline PetscErrorCode PEPCISSGetKSPs(PEP pep,PETSC_UNUSED PetscInt *nsolve,PETSC_UNUSED KSP *ksp[]) {SlepcPEPCISSUnavailable(pep);}
449: #undef SlepcPEPCISSUnavailable
450: #endif