Actual source code: petsctao.h

  1: #ifndef PETSCTAO_H
  2: #define PETSCTAO_H

  4: #include <petscsnes.h>

  6: /* SUBMANSEC = Tao */

  8: PETSC_EXTERN PetscErrorCode VecFischer(Vec, Vec, Vec, Vec, Vec);
  9: PETSC_EXTERN PetscErrorCode VecSFischer(Vec, Vec, Vec, Vec, PetscReal, Vec);
 10: PETSC_EXTERN PetscErrorCode MatDFischer(Mat, Vec, Vec, Vec, Vec, Vec, Vec, Vec, Vec);
 11: PETSC_EXTERN PetscErrorCode MatDSFischer(Mat, Vec, Vec, Vec, Vec, PetscReal, Vec, Vec, Vec, Vec, Vec);
 12: PETSC_EXTERN PetscErrorCode TaoSoftThreshold(Vec, PetscReal, PetscReal, Vec);

 14: /*E
 15:   TaoSubsetType - Type representing the way Tao handles active sets

 17: + `TAO_SUBSET_SUBVEC` - Tao uses `MatCreateSubMatrix()` and `VecGetSubVector()`
 18: . `TAO_SUBSET_MASK` - Matrices are zeroed out corresponding to active set entries
 19: - `TAO_SUBSET_MATRIXFREE` - Same as `TAO_SUBSET_MASK` but it can be applied to matrix-free operators

 21:   Options database keys:
 22: . -different_hessian - Tao will use a copy of the hessian operator for masking.  By default
 23:                        Tao will directly alter the hessian operator.
 24:   Level: intermediate

 26: E*/
 27: typedef enum {
 28:   TAO_SUBSET_SUBVEC,
 29:   TAO_SUBSET_MASK,
 30:   TAO_SUBSET_MATRIXFREE
 31: } TaoSubsetType;
 32: PETSC_EXTERN const char *const TaoSubsetTypes[];

 34: /*S
 35:      Tao - Abstract PETSc object that manages nonlinear optimization solves

 37:    Level: advanced

 39: .seealso `TaoCreate()`, `TaoDestroy()`, `TaoSetType()`, `TaoType`
 40: S*/
 41: typedef struct _p_Tao *Tao;

 43: /*E
 44:      TaoADMMUpdateType - Determine spectral penalty update routine for Lagrange augmented term for `TAOADMM`.

 46:   Level: advanced

 48: .seealso `TaoADMMSetUpdateType()`
 49: E*/
 50: typedef enum {
 51:   TAO_ADMM_UPDATE_BASIC,
 52:   TAO_ADMM_UPDATE_ADAPTIVE,
 53:   TAO_ADMM_UPDATE_ADAPTIVE_RELAXED
 54: } TaoADMMUpdateType;
 55: PETSC_EXTERN const char *const TaoADMMUpdateTypes[];

 57: /*MC
 58:      TAO_ADMM_UPDATE_BASIC - Use same spectral penalty set at the beginning. No update

 60:   Level: advanced

 62:   Note:
 63:   Most basic implementation. Generally slower than adaptive or adaptive relaxed version.

 65: .seealso: `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_ADAPTIVE`, `TAO_ADMM_UPDATE_ADAPTIVE_RELAXED`
 66: M*/

 68: /*MC
 69:      TAO_ADMM_UPDATE_ADAPTIVE - Adaptively update spectral penalty

 71:   Level: advanced

 73:   Note:
 74:   Adaptively updates spectral penalty by using both steepest descent and minimum gradient.

 76: .seealso: `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_BASIC`, `TAO_ADMM_UPDATE_ADAPTIVE_RELAXED`
 77: M*/

 79: /*MC
 80:      ADMM_UPDATE_ADAPTIVE_RELAXED - Adaptively update spectral penalty, and relaxes parameter update

 82:   Level: advanced

 84:   Note:
 85:   With adaptive spectral penalty update, it also relaxes x vector update by a factor.

 87: .seealso: `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_BASIC`, `TAO_ADMM_UPDATE_ADAPTIVE`
 88: M*/

 90: /*E
 91:      TaoADMMRegularizerType - Determine regularizer routine - either user provided or soft threshold

 93:   Level: advanced

 95: .seealso `TaoADMMSetRegularizerType()`
 96: E*/
 97: typedef enum {
 98:   TAO_ADMM_REGULARIZER_USER,
 99:   TAO_ADMM_REGULARIZER_SOFT_THRESH
100: } TaoADMMRegularizerType;
101: PETSC_EXTERN const char *const TaoADMMRegularizerTypes[];

103: /*MC
104:   TAO_ADMM_REGULARIZER_USER - User provided routines for regularizer part of `TAOADMM`

106:   Level: advanced

108:   Note:
109:   User needs to provided appropriate routines and type for regularizer solver

111: .seealso: `TaoADMMSetRegularizerType()`, `TAO_ADMM_REGULARIZER_SOFT_THRESH`
112: M*/

114: /*MC
115:   TAO_ADMM_REGULARIZER_SOFT_THRESH - Soft threshold to solve regularizer part of `TAOADMM`

117:   Level: advanced

119:   Note:
120:   Utilizes built-in SoftThreshold routines

122: .seealso: `TaoSoftThreshold()`, `TaoADMMSetRegularizerObjectiveAndGradientRoutine()`,
123:           `TaoADMMSetRegularizerHessianRoutine()`, `TaoADMMSetRegularizerType()`, `TAO_ADMM_REGULARIZER_USER`
124: M*/

126: /*E
127:      TaoALMMType - Determine the augmented Lagrangian formulation used in the `TAOALMM` subproblem.

129: $  `TAO_ALMM_CLASSIC` - classic augmented Lagrangian definition including slack variables for inequality constraints
130: $  `TAO_ALMM_PHR`     - Powell-Hestenes-Rockafellar formulation without slack variables, uses pointwise min() for inequalities

132:   Level: advanced

134: .seealso `TAOALMM`, `TaoALMMSetType()`, `TaoALMMGetType()`
135: E*/
136: typedef enum {
137:   TAO_ALMM_CLASSIC,
138:   TAO_ALMM_PHR
139: } TaoALMMType;
140: PETSC_EXTERN const char *const TaoALMMTypes[];

142: /*J
143:         TaoType - String with the name of a `Tao` method

145:        Level: beginner

147: .seealso `Tao`, `TaoCreate()`, `TaoSetType()`
148: J*/
149: typedef const char *TaoType;
150: #define TAOLMVM     "lmvm"
151: #define TAONLS      "nls"
152: #define TAONTR      "ntr"
153: #define TAONTL      "ntl"
154: #define TAOCG       "cg"
155: #define TAOTRON     "tron"
156: #define TAOOWLQN    "owlqn"
157: #define TAOBMRM     "bmrm"
158: #define TAOBLMVM    "blmvm"
159: #define TAOBQNLS    "bqnls"
160: #define TAOBNCG     "bncg"
161: #define TAOBNLS     "bnls"
162: #define TAOBNTR     "bntr"
163: #define TAOBNTL     "bntl"
164: #define TAOBQNKLS   "bqnkls"
165: #define TAOBQNKTR   "bqnktr"
166: #define TAOBQNKTL   "bqnktl"
167: #define TAOBQPIP    "bqpip"
168: #define TAOGPCG     "gpcg"
169: #define TAONM       "nm"
170: #define TAOPOUNDERS "pounders"
171: #define TAOBRGN     "brgn"
172: #define TAOLCL      "lcl"
173: #define TAOSSILS    "ssils"
174: #define TAOSSFLS    "ssfls"
175: #define TAOASILS    "asils"
176: #define TAOASFLS    "asfls"
177: #define TAOIPM      "ipm"
178: #define TAOPDIPM    "pdipm"
179: #define TAOSHELL    "shell"
180: #define TAOADMM     "admm"
181: #define TAOALMM     "almm"
182: #define TAOPYTHON   "python"

184: PETSC_EXTERN PetscClassId      TAO_CLASSID;
185: PETSC_EXTERN PetscFunctionList TaoList;

187: /*E
188:     TaoConvergedReason - reason a Tao method was said to have converged or diverged

190:    Level: beginner

192:    The two most common reasons for divergence are
193: $   1) an incorrectly coded or computed gradient or Hessian
194: $   2) failure or lack of convergence in the linear system (in this case we recommend
195: $      testing with -pc_type lu to eliminate the linear solver as the cause of the problem).

197:    Developer Notes:
198:     This must match petsc/finclude/petsctao.h

200:        The string versions of these are in `TAOConvergedReasons`, if you change any value here you must
201:      also adjust that array.

203: .seealso: `Tao`, `TaoSolve()`, `TaoGetConvergedReason()`, `KSPConvergedReason`, `SNESConvergedReason`, `TSConvergedReason`
204: E*/
205: typedef enum {               /* converged */
206:   TAO_CONVERGED_GATOL   = 3, /* ||g(X)|| < gatol */
207:   TAO_CONVERGED_GRTOL   = 4, /* ||g(X)|| / f(X)  < grtol */
208:   TAO_CONVERGED_GTTOL   = 5, /* ||g(X)|| / ||g(X0)|| < gttol */
209:   TAO_CONVERGED_STEPTOL = 6, /* step size small */
210:   TAO_CONVERGED_MINF    = 7, /* F < F_min */
211:   TAO_CONVERGED_USER    = 8, /* User defined */
212:   /* diverged */
213:   TAO_DIVERGED_MAXITS       = -2,
214:   TAO_DIVERGED_NAN          = -4,
215:   TAO_DIVERGED_MAXFCN       = -5,
216:   TAO_DIVERGED_LS_FAILURE   = -6,
217:   TAO_DIVERGED_TR_REDUCTION = -7,
218:   TAO_DIVERGED_USER         = -8, /* User defined */
219:   /* keep going */
220:   TAO_CONTINUE_ITERATING = 0
221: } TaoConvergedReason;

223: PETSC_EXTERN const char **TaoConvergedReasons;

225: PETSC_EXTERN PetscErrorCode TaoInitializePackage(void);
226: PETSC_EXTERN PetscErrorCode TaoFinalizePackage(void);
227: PETSC_EXTERN PetscErrorCode TaoCreate(MPI_Comm, Tao *);
228: PETSC_EXTERN PetscErrorCode TaoSetFromOptions(Tao);
229: PETSC_EXTERN PetscErrorCode TaoSetUp(Tao);
230: PETSC_EXTERN PetscErrorCode TaoSetType(Tao, TaoType);
231: PETSC_EXTERN PetscErrorCode TaoGetType(Tao, TaoType *);
232: PETSC_EXTERN PetscErrorCode TaoSetApplicationContext(Tao, void *);
233: PETSC_EXTERN PetscErrorCode TaoGetApplicationContext(Tao, void *);
234: PETSC_EXTERN PetscErrorCode TaoDestroy(Tao *);

236: PETSC_EXTERN PetscErrorCode TaoSetOptionsPrefix(Tao, const char[]);
237: PETSC_EXTERN PetscErrorCode TaoView(Tao, PetscViewer);
238: PETSC_EXTERN PetscErrorCode TaoViewFromOptions(Tao, PetscObject, const char[]);

240: PETSC_EXTERN PetscErrorCode TaoSolve(Tao);

242: PETSC_EXTERN PetscErrorCode TaoRegister(const char[], PetscErrorCode (*)(Tao));
243: PETSC_EXTERN PetscErrorCode TaoRegisterDestroy(void);

245: PETSC_EXTERN PetscErrorCode TaoGetConvergedReason(Tao, TaoConvergedReason *);
246: PETSC_EXTERN PetscErrorCode TaoGetSolutionStatus(Tao, PetscInt *, PetscReal *, PetscReal *, PetscReal *, PetscReal *, TaoConvergedReason *);
247: PETSC_EXTERN PetscErrorCode TaoSetConvergedReason(Tao, TaoConvergedReason);
248: PETSC_EXTERN PetscErrorCode TaoSetSolution(Tao, Vec);
249: PETSC_EXTERN PetscErrorCode TaoGetSolution(Tao, Vec *);
250: PETSC_DEPRECATED_FUNCTION("Use TaoSetSolution() (since version 3.17)") static inline PetscErrorCode TaoSetInitialVector(Tao t, Vec v)
251: {
252:   return TaoSetSolution(t, v);
253: }
254: PETSC_DEPRECATED_FUNCTION("Use TaoGetSolution() (since version 3.17)") static inline PetscErrorCode TaoGetInitialVector(Tao t, Vec *v)
255: {
256:   return TaoGetSolution(t, v);
257: }

259: PETSC_EXTERN PetscErrorCode TaoSetObjective(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, void *), void *);
260: PETSC_EXTERN PetscErrorCode TaoGetObjective(Tao, PetscErrorCode (**)(Tao, Vec, PetscReal *, void *), void **);
261: PETSC_EXTERN PetscErrorCode TaoSetGradient(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
262: PETSC_EXTERN PetscErrorCode TaoGetGradient(Tao, Vec *, PetscErrorCode (**)(Tao, Vec, Vec, void *), void **);
263: PETSC_EXTERN PetscErrorCode TaoSetObjectiveAndGradient(Tao, Vec, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, void *), void *);
264: PETSC_EXTERN PetscErrorCode TaoGetObjectiveAndGradient(Tao, Vec *, PetscErrorCode (**)(Tao, Vec, PetscReal *, Vec, void *), void **);
265: PETSC_EXTERN PetscErrorCode TaoSetHessian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
266: PETSC_EXTERN PetscErrorCode TaoGetHessian(Tao, Mat *, Mat *, PetscErrorCode (**)(Tao, Vec, Mat, Mat, void *), void **);
267: PETSC_DEPRECATED_FUNCTION("Use TaoSetObjective() (since version 3.17)") static inline PetscErrorCode TaoSetObjectiveRoutine(Tao t, PetscErrorCode (*f)(Tao, Vec, PetscReal *, void *), void *c)
268: {
269:   return TaoSetObjective(t, f, c);
270: }
271: PETSC_DEPRECATED_FUNCTION("Use TaoGetGradient() (since version 3.17)") static inline PetscErrorCode TaoGetGradientVector(Tao t, Vec *v)
272: {
273:   return TaoGetGradient(t, v, NULL, NULL);
274: }
275: PETSC_DEPRECATED_FUNCTION("Use TaoSetGradient() (since version 3.17)") static inline PetscErrorCode TaoSetGradientRoutine(Tao t, PetscErrorCode (*f)(Tao, Vec, Vec, void *), void *c)
276: {
277:   return TaoSetGradient(t, NULL, f, c);
278: }
279: PETSC_DEPRECATED_FUNCTION("Use TaoSetObjectiveAndGradient() (since version 3.17)") static inline PetscErrorCode TaoSetObjectiveAndGradientRoutine(Tao t, PetscErrorCode (*f)(Tao, Vec, PetscReal *, Vec, void *), void *c)
280: {
281:   return TaoSetObjectiveAndGradient(t, NULL, f, c);
282: }
283: PETSC_DEPRECATED_FUNCTION("Use TaoSetHessian() (since version 3.17)") static inline PetscErrorCode TaoSetHessianRoutine(Tao t, Mat H, Mat P, PetscErrorCode (*f)(Tao, Vec, Mat, Mat, void *), void *c)
284: {
285:   return TaoSetHessian(t, H, P, f, c);
286: }

288: PETSC_EXTERN PetscErrorCode TaoSetGradientNorm(Tao, Mat);
289: PETSC_EXTERN PetscErrorCode TaoGetGradientNorm(Tao, Mat *);
290: PETSC_EXTERN PetscErrorCode TaoSetLMVMMatrix(Tao, Mat);
291: PETSC_EXTERN PetscErrorCode TaoGetLMVMMatrix(Tao, Mat *);
292: PETSC_EXTERN PetscErrorCode TaoSetRecycleHistory(Tao, PetscBool);
293: PETSC_EXTERN PetscErrorCode TaoGetRecycleHistory(Tao, PetscBool *);
294: PETSC_EXTERN PetscErrorCode TaoLMVMSetH0(Tao, Mat);
295: PETSC_EXTERN PetscErrorCode TaoLMVMGetH0(Tao, Mat *);
296: PETSC_EXTERN PetscErrorCode TaoLMVMGetH0KSP(Tao, KSP *);
297: PETSC_EXTERN PetscErrorCode TaoLMVMRecycle(Tao, PetscBool);
298: PETSC_EXTERN PetscErrorCode TaoSetResidualRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
299: PETSC_EXTERN PetscErrorCode TaoSetResidualWeights(Tao, Vec, PetscInt, PetscInt *, PetscInt *, PetscReal *);
300: PETSC_EXTERN PetscErrorCode TaoSetConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
301: PETSC_EXTERN PetscErrorCode TaoSetInequalityConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
302: PETSC_EXTERN PetscErrorCode TaoSetEqualityConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
303: PETSC_EXTERN PetscErrorCode TaoSetJacobianResidualRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
304: PETSC_EXTERN PetscErrorCode TaoSetJacobianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
305: PETSC_EXTERN PetscErrorCode TaoSetJacobianStateRoutine(Tao, Mat, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, Mat, void *), void *);
306: PETSC_EXTERN PetscErrorCode TaoSetJacobianDesignRoutine(Tao, Mat, PetscErrorCode (*)(Tao, Vec, Mat, void *), void *);
307: PETSC_EXTERN PetscErrorCode TaoSetJacobianInequalityRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
308: PETSC_EXTERN PetscErrorCode TaoSetJacobianEqualityRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);

310: PETSC_EXTERN PetscErrorCode TaoPythonSetType(Tao, const char[]);
311: PETSC_EXTERN PetscErrorCode TaoPythonGetType(Tao, const char *[]);

313: PETSC_EXTERN PetscErrorCode TaoShellSetSolve(Tao, PetscErrorCode (*)(Tao));
314: PETSC_EXTERN PetscErrorCode TaoShellSetContext(Tao, void *);
315: PETSC_EXTERN PetscErrorCode TaoShellGetContext(Tao, void *);

317: PETSC_DEPRECATED_FUNCTION("Use TaoSetResidualRoutine() (since version 3.11)") static inline PetscErrorCode TaoSetSeparableObjectiveRoutine(Tao tao, Vec res, PetscErrorCode (*func)(Tao, Vec, Vec, void *), void *ctx)
318: {
319:   return TaoSetResidualRoutine(tao, res, func, ctx);
320: }
321: PETSC_DEPRECATED_FUNCTION("Use TaoSetResidualWeights() (since version 3.11)") static inline PetscErrorCode TaoSetSeparableObjectiveWeights(Tao tao, Vec sigma_v, PetscInt n, PetscInt *rows, PetscInt *cols, PetscReal *vals)
322: {
323:   return TaoSetResidualWeights(tao, sigma_v, n, rows, cols, vals);
324: }

326: PETSC_EXTERN PetscErrorCode TaoSetStateDesignIS(Tao, IS, IS);

328: PETSC_EXTERN PetscErrorCode TaoComputeObjective(Tao, Vec, PetscReal *);
329: PETSC_EXTERN PetscErrorCode TaoComputeResidual(Tao, Vec, Vec);
330: PETSC_EXTERN PetscErrorCode TaoTestGradient(Tao, Vec, Vec);
331: PETSC_EXTERN PetscErrorCode TaoComputeGradient(Tao, Vec, Vec);
332: PETSC_EXTERN PetscErrorCode TaoComputeObjectiveAndGradient(Tao, Vec, PetscReal *, Vec);
333: PETSC_EXTERN PetscErrorCode TaoComputeConstraints(Tao, Vec, Vec);
334: PETSC_EXTERN PetscErrorCode TaoComputeInequalityConstraints(Tao, Vec, Vec);
335: PETSC_EXTERN PetscErrorCode TaoComputeEqualityConstraints(Tao, Vec, Vec);
336: PETSC_EXTERN PetscErrorCode TaoDefaultComputeGradient(Tao, Vec, Vec, void *);
337: PETSC_EXTERN PetscErrorCode TaoIsObjectiveDefined(Tao, PetscBool *);
338: PETSC_EXTERN PetscErrorCode TaoIsGradientDefined(Tao, PetscBool *);
339: PETSC_EXTERN PetscErrorCode TaoIsObjectiveAndGradientDefined(Tao, PetscBool *);

341: PETSC_DEPRECATED_FUNCTION("Use TaoComputeResidual() (since version 3.11)") static inline PetscErrorCode TaoComputeSeparableObjective(Tao tao, Vec X, Vec F)
342: {
343:   return TaoComputeResidual(tao, X, F);
344: }

346: PETSC_EXTERN PetscErrorCode TaoTestHessian(Tao);
347: PETSC_EXTERN PetscErrorCode TaoComputeHessian(Tao, Vec, Mat, Mat);
348: PETSC_EXTERN PetscErrorCode TaoComputeResidualJacobian(Tao, Vec, Mat, Mat);
349: PETSC_EXTERN PetscErrorCode TaoComputeJacobian(Tao, Vec, Mat, Mat);
350: PETSC_EXTERN PetscErrorCode TaoComputeJacobianState(Tao, Vec, Mat, Mat, Mat);
351: PETSC_EXTERN PetscErrorCode TaoComputeJacobianEquality(Tao, Vec, Mat, Mat);
352: PETSC_EXTERN PetscErrorCode TaoComputeJacobianInequality(Tao, Vec, Mat, Mat);
353: PETSC_EXTERN PetscErrorCode TaoComputeJacobianDesign(Tao, Vec, Mat);

355: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessian(Tao, Vec, Mat, Mat, void *);
356: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessianColor(Tao, Vec, Mat, Mat, void *);
357: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessianMFFD(Tao, Vec, Mat, Mat, void *);
358: PETSC_EXTERN PetscErrorCode TaoComputeDualVariables(Tao, Vec, Vec);
359: PETSC_EXTERN PetscErrorCode TaoSetVariableBounds(Tao, Vec, Vec);
360: PETSC_EXTERN PetscErrorCode TaoGetVariableBounds(Tao, Vec *, Vec *);
361: PETSC_EXTERN PetscErrorCode TaoGetDualVariables(Tao, Vec *, Vec *);
362: PETSC_EXTERN PetscErrorCode TaoSetInequalityBounds(Tao, Vec, Vec);
363: PETSC_EXTERN PetscErrorCode TaoGetInequalityBounds(Tao, Vec *, Vec *);
364: PETSC_EXTERN PetscErrorCode TaoSetVariableBoundsRoutine(Tao, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
365: PETSC_EXTERN PetscErrorCode TaoComputeVariableBounds(Tao);

367: PETSC_EXTERN PetscErrorCode TaoGetTolerances(Tao, PetscReal *, PetscReal *, PetscReal *);
368: PETSC_EXTERN PetscErrorCode TaoSetTolerances(Tao, PetscReal, PetscReal, PetscReal);
369: PETSC_EXTERN PetscErrorCode TaoGetConstraintTolerances(Tao, PetscReal *, PetscReal *);
370: PETSC_EXTERN PetscErrorCode TaoSetConstraintTolerances(Tao, PetscReal, PetscReal);
371: PETSC_EXTERN PetscErrorCode TaoSetFunctionLowerBound(Tao, PetscReal);
372: PETSC_EXTERN PetscErrorCode TaoSetInitialTrustRegionRadius(Tao, PetscReal);
373: PETSC_EXTERN PetscErrorCode TaoSetMaximumIterations(Tao, PetscInt);
374: PETSC_EXTERN PetscErrorCode TaoSetMaximumFunctionEvaluations(Tao, PetscInt);
375: PETSC_EXTERN PetscErrorCode TaoGetFunctionLowerBound(Tao, PetscReal *);
376: PETSC_EXTERN PetscErrorCode TaoGetInitialTrustRegionRadius(Tao, PetscReal *);
377: PETSC_EXTERN PetscErrorCode TaoGetCurrentTrustRegionRadius(Tao, PetscReal *);
378: PETSC_EXTERN PetscErrorCode TaoGetMaximumIterations(Tao, PetscInt *);
379: PETSC_EXTERN PetscErrorCode TaoGetCurrentFunctionEvaluations(Tao, PetscInt *);
380: PETSC_EXTERN PetscErrorCode TaoGetMaximumFunctionEvaluations(Tao, PetscInt *);
381: PETSC_EXTERN PetscErrorCode TaoGetIterationNumber(Tao, PetscInt *);
382: PETSC_EXTERN PetscErrorCode TaoSetIterationNumber(Tao, PetscInt);
383: PETSC_EXTERN PetscErrorCode TaoGetTotalIterationNumber(Tao, PetscInt *);
384: PETSC_EXTERN PetscErrorCode TaoSetTotalIterationNumber(Tao, PetscInt);
385: PETSC_EXTERN PetscErrorCode TaoGetResidualNorm(Tao, PetscReal *);

387: PETSC_EXTERN PetscErrorCode TaoAppendOptionsPrefix(Tao, const char[]);
388: PETSC_EXTERN PetscErrorCode TaoGetOptionsPrefix(Tao, const char *[]);
389: PETSC_EXTERN PetscErrorCode TaoResetStatistics(Tao);
390: PETSC_EXTERN PetscErrorCode TaoSetUpdate(Tao, PetscErrorCode (*)(Tao, PetscInt, void *), void *);

392: PETSC_EXTERN PetscErrorCode TaoGetKSP(Tao, KSP *);
393: PETSC_EXTERN PetscErrorCode TaoGetLinearSolveIterations(Tao, PetscInt *);
394: PETSC_EXTERN PetscErrorCode TaoKSPSetUseEW(Tao, PetscBool);

396: #include <petsctaolinesearch.h>

398: PETSC_EXTERN PetscErrorCode TaoGetLineSearch(Tao, TaoLineSearch *);

400: PETSC_EXTERN PetscErrorCode TaoSetConvergenceHistory(Tao, PetscReal *, PetscReal *, PetscReal *, PetscInt *, PetscInt, PetscBool);
401: PETSC_EXTERN PetscErrorCode TaoGetConvergenceHistory(Tao, PetscReal **, PetscReal **, PetscReal **, PetscInt **, PetscInt *);
402: PETSC_EXTERN PetscErrorCode TaoSetMonitor(Tao, PetscErrorCode (*)(Tao, void *), void *, PetscErrorCode (*)(void **));
403: PETSC_EXTERN PetscErrorCode TaoCancelMonitors(Tao);
404: PETSC_EXTERN PetscErrorCode TaoMonitorDefault(Tao, void *);
405: PETSC_DEPRECATED_FUNCTION("Use TaoMonitorDefault() (since version 3.9)") static inline PetscErrorCode TaoDefaultMonitor(Tao tao, void *ctx)
406: {
407:   return TaoMonitorDefault(tao, ctx);
408: }
409: PETSC_EXTERN PetscErrorCode TaoDefaultGMonitor(Tao, void *);
410: PETSC_EXTERN PetscErrorCode TaoDefaultSMonitor(Tao, void *);
411: PETSC_EXTERN PetscErrorCode TaoDefaultCMonitor(Tao, void *);
412: PETSC_EXTERN PetscErrorCode TaoSolutionMonitor(Tao, void *);
413: PETSC_EXTERN PetscErrorCode TaoResidualMonitor(Tao, void *);
414: PETSC_EXTERN PetscErrorCode TaoGradientMonitor(Tao, void *);
415: PETSC_EXTERN PetscErrorCode TaoStepDirectionMonitor(Tao, void *);
416: PETSC_EXTERN PetscErrorCode TaoDrawSolutionMonitor(Tao, void *);
417: PETSC_EXTERN PetscErrorCode TaoDrawStepMonitor(Tao, void *);
418: PETSC_EXTERN PetscErrorCode TaoDrawGradientMonitor(Tao, void *);
419: PETSC_EXTERN PetscErrorCode TaoAddLineSearchCounts(Tao);

421: PETSC_EXTERN PetscErrorCode TaoDefaultConvergenceTest(Tao, void *);
422: PETSC_EXTERN PetscErrorCode TaoSetConvergenceTest(Tao, PetscErrorCode (*)(Tao, void *), void *);

424: PETSC_EXTERN PetscErrorCode          TaoLCLSetStateDesignIS(Tao, IS, IS);
425: PETSC_EXTERN PetscErrorCode          TaoMonitor(Tao, PetscInt, PetscReal, PetscReal, PetscReal, PetscReal);
426: typedef struct _n_TaoMonitorDrawCtx *TaoMonitorDrawCtx;
427: PETSC_EXTERN PetscErrorCode          TaoMonitorDrawCtxCreate(MPI_Comm, const char[], const char[], int, int, int, int, PetscInt, TaoMonitorDrawCtx *);
428: PETSC_EXTERN PetscErrorCode          TaoMonitorDrawCtxDestroy(TaoMonitorDrawCtx *);

430: PETSC_EXTERN PetscErrorCode TaoBRGNGetSubsolver(Tao, Tao *);
431: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, void *), void *);
432: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerHessianRoutine(Tao, Mat, PetscErrorCode (*)(Tao, Vec, Mat, void *), void *);
433: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerWeight(Tao, PetscReal);
434: PETSC_EXTERN PetscErrorCode TaoBRGNSetL1SmoothEpsilon(Tao, PetscReal);
435: PETSC_EXTERN PetscErrorCode TaoBRGNSetDictionaryMatrix(Tao, Mat);
436: PETSC_EXTERN PetscErrorCode TaoBRGNGetDampingVector(Tao, Vec *);

438: PETSC_EXTERN PetscErrorCode TaoADMMGetMisfitSubsolver(Tao, Tao *);
439: PETSC_EXTERN PetscErrorCode TaoADMMGetRegularizationSubsolver(Tao, Tao *);
440: PETSC_EXTERN PetscErrorCode TaoADMMGetDualVector(Tao, Vec *);
441: PETSC_EXTERN PetscErrorCode TaoADMMGetSpectralPenalty(Tao, PetscReal *);
442: PETSC_EXTERN PetscErrorCode TaoADMMSetSpectralPenalty(Tao, PetscReal);
443: PETSC_EXTERN PetscErrorCode TaoGetADMMParentTao(Tao, Tao *);
444: PETSC_EXTERN PetscErrorCode TaoADMMSetConstraintVectorRHS(Tao, Vec);
445: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerCoefficient(Tao, PetscReal);
446: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitConstraintJacobian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
447: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerConstraintJacobian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
448: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerHessianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
449: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, void *), void *);
450: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitHessianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
451: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, void *), void *);
452: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitHessianChangeStatus(Tao, PetscBool);
453: PETSC_EXTERN PetscErrorCode TaoADMMSetRegHessianChangeStatus(Tao, PetscBool);
454: PETSC_EXTERN PetscErrorCode TaoADMMSetMinimumSpectralPenalty(Tao, PetscReal);
455: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerType(Tao, TaoADMMRegularizerType);
456: PETSC_EXTERN PetscErrorCode TaoADMMGetRegularizerType(Tao, TaoADMMRegularizerType *);
457: PETSC_EXTERN PetscErrorCode TaoADMMSetUpdateType(Tao, TaoADMMUpdateType);
458: PETSC_EXTERN PetscErrorCode TaoADMMGetUpdateType(Tao, TaoADMMUpdateType *);

460: PETSC_EXTERN PetscErrorCode TaoALMMGetType(Tao, TaoALMMType *);
461: PETSC_EXTERN PetscErrorCode TaoALMMSetType(Tao, TaoALMMType);
462: PETSC_EXTERN PetscErrorCode TaoALMMGetSubsolver(Tao, Tao *);
463: PETSC_EXTERN PetscErrorCode TaoALMMSetSubsolver(Tao, Tao);
464: PETSC_EXTERN PetscErrorCode TaoALMMGetMultipliers(Tao, Vec *);
465: PETSC_EXTERN PetscErrorCode TaoALMMSetMultipliers(Tao, Vec);
466: PETSC_EXTERN PetscErrorCode TaoALMMGetPrimalIS(Tao, IS *, IS *);
467: PETSC_EXTERN PetscErrorCode TaoALMMGetDualIS(Tao, IS *, IS *);
468: #endif