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:   Values:
 18: + `TAO_SUBSET_SUBVEC` - Tao uses `MatCreateSubMatrix()` and `VecGetSubVector()`
 19: . `TAO_SUBSET_MASK` - Matrices are zeroed out corresponding to active set entries
 20: - `TAO_SUBSET_MATRIXFREE` - Same as `TAO_SUBSET_MASK` but it can be applied to matrix-free operators

 22:   Options database Key:
 23: . -different_hessian - Tao will use a copy of the Hessian operator for masking.  By default TAO will directly alter the Hessian operator.

 25:   Level: intermediate

 27: .seealso: [](ch_tao), `TaoVecGetSubVec()`, `TaoMatGetSubMat()`, `Tao`, `TaoCreate()`, `TaoDestroy()`, `TaoSetType()`, `TaoType`
 28: E*/
 29: typedef enum {
 30:   TAO_SUBSET_SUBVEC,
 31:   TAO_SUBSET_MASK,
 32:   TAO_SUBSET_MATRIXFREE
 33: } TaoSubsetType;
 34: PETSC_EXTERN const char *const TaoSubsetTypes[];

 36: /*S
 37:      Tao - Abstract PETSc object that manages nonlinear optimization solves

 39:    Level: advanced

 41: .seealso: [](doc_taosolve), [](ch_tao), `TaoCreate()`, `TaoDestroy()`, `TaoSetType()`, `TaoType`
 42: S*/
 43: typedef struct _p_Tao *Tao;

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

 48:   Level: advanced

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

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

 62:   Level: advanced

 64:   Note:
 65:   Most basic implementation of `TAOADMM`. Generally slower than adaptive or adaptive relaxed version.

 67: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_ADAPTIVE`, `TAO_ADMM_UPDATE_ADAPTIVE_RELAXED`
 68: M*/

 70: /*MC
 71:      TAO_ADMM_UPDATE_ADAPTIVE - Adaptively update spectral penalty

 73:   Level: advanced

 75:   Note:
 76:   Adaptively updates spectral penalty of `TAOADMM` by using both steepest descent and minimum gradient.

 78: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_BASIC`, `TAO_ADMM_UPDATE_ADAPTIVE_RELAXED`
 79: M*/

 81: /*MC
 82:      ADMM_UPDATE_ADAPTIVE_RELAXED - Adaptively update spectral penalty, and relaxes parameter update

 84:   Level: advanced

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

 89: .seealso: [](ch_tao), `Tao`, `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_BASIC`, `TAO_ADMM_UPDATE_ADAPTIVE`
 90: M*/

 92: /*E
 93:      TaoADMMRegularizerType - Determine regularizer routine - either user provided or soft threshold for `TAOADMM`

 95:   Level: advanced

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

105: /*MC
106:   TAO_ADMM_REGULARIZER_USER - User provided routines for regularizer part of `TAOADMM`

108:   Level: advanced

110:   Note:
111:   User needs to provided appropriate routines and type for regularizer solver

113: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoADMMSetRegularizerType()`, `TAO_ADMM_REGULARIZER_SOFT_THRESH`
114: M*/

116: /*MC
117:   TAO_ADMM_REGULARIZER_SOFT_THRESH - Soft threshold to solve regularizer part of `TAOADMM`

119:   Level: advanced

121:   Note:
122:   Utilizes built-in SoftThreshold routines

124: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoSoftThreshold()`, `TaoADMMSetRegularizerObjectiveAndGradientRoutine()`,
125:           `TaoADMMSetRegularizerHessianRoutine()`, `TaoADMMSetRegularizerType()`, `TAO_ADMM_REGULARIZER_USER`
126: M*/

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

131:    Values:
132: +  `TAO_ALMM_CLASSIC` - classic augmented Lagrangian definition including slack variables for inequality constraints
133: -  `TAO_ALMM_PHR`     - Powell-Hestenes-Rockafellar formulation without slack variables, uses pointwise min() for inequalities

135:   Level: advanced

137: .seealso: [](ch_tao), `Tao`, `TAOALMM`, `TaoALMMSetType()`, `TaoALMMGetType()`
138: E*/
139: typedef enum {
140:   TAO_ALMM_CLASSIC,
141:   TAO_ALMM_PHR
142: } TaoALMMType;
143: PETSC_EXTERN const char *const TaoALMMTypes[];

145: /*J
146:         TaoType - String with the name of a `Tao` method

148:   Values:
149: +    `TAONLS` - nls Newton's method with line search for unconstrained minimization
150: .    `TAONTR` - ntr Newton's method with trust region for unconstrained minimization
151: .    `TAONTL` - ntl Newton's method with trust region, line search for unconstrained minimization
152: .    `TAOLMVM` - lmvm Limited memory variable metric method for unconstrained minimization
153: .    `TAOCG` - cg Nonlinear conjugate gradient method for unconstrained minimization
154: .    `TAONM` - nm Nelder-Mead algorithm for derivate-free unconstrained minimization
155: .    `TAOTRON` - tron Newton Trust Region method for bound constrained minimization
156: .    `TAOGPCG` - gpcg Newton Trust Region method for quadratic bound constrained minimization
157: .    `TAOBLMVM` - blmvm Limited memory variable metric method for bound constrained minimization
158: .    `TAOLCL` - lcl Linearly constrained Lagrangian method for pde-constrained minimization
159: -    `TAOPOUNDERS` - Pounders Model-based algorithm for nonlinear least squares

161:        Level: beginner

163: .seealso: [](doc_taosolve), [](ch_tao), `Tao`, `TaoCreate()`, `TaoSetType()`
164: J*/
165: typedef const char *TaoType;
166: #define TAOLMVM     "lmvm"
167: #define TAONLS      "nls"
168: #define TAONTR      "ntr"
169: #define TAONTL      "ntl"
170: #define TAOCG       "cg"
171: #define TAOTRON     "tron"
172: #define TAOOWLQN    "owlqn"
173: #define TAOBMRM     "bmrm"
174: #define TAOBLMVM    "blmvm"
175: #define TAOBQNLS    "bqnls"
176: #define TAOBNCG     "bncg"
177: #define TAOBNLS     "bnls"
178: #define TAOBNTR     "bntr"
179: #define TAOBNTL     "bntl"
180: #define TAOBQNKLS   "bqnkls"
181: #define TAOBQNKTR   "bqnktr"
182: #define TAOBQNKTL   "bqnktl"
183: #define TAOBQPIP    "bqpip"
184: #define TAOGPCG     "gpcg"
185: #define TAONM       "nm"
186: #define TAOPOUNDERS "pounders"
187: #define TAOBRGN     "brgn"
188: #define TAOLCL      "lcl"
189: #define TAOSSILS    "ssils"
190: #define TAOSSFLS    "ssfls"
191: #define TAOASILS    "asils"
192: #define TAOASFLS    "asfls"
193: #define TAOIPM      "ipm"
194: #define TAOPDIPM    "pdipm"
195: #define TAOSHELL    "shell"
196: #define TAOADMM     "admm"
197: #define TAOALMM     "almm"
198: #define TAOPYTHON   "python"
199: #define TAOSNES     "snes"

201: PETSC_EXTERN PetscClassId      TAO_CLASSID;
202: PETSC_EXTERN PetscFunctionList TaoList;

204: /*E
205:     TaoConvergedReason - reason a `Tao` optimizer was said to have converged or diverged

207:    Values:
208: +  `TAO_CONVERGED_GATOL` - ||g(X)|| < gatol
209: .  `TAO_CONVERGED_GRTOL` - ||g(X)|| / f(X)  < grtol
210: .  `TAO_CONVERGED_GTTOL` - ||g(X)|| / ||g(X0)|| < gttol
211: .  `TAO_CONVERGED_STEPTOL` - step size smaller than tolerance
212: .  `TAO_CONVERGED_MINF` - F < F_min
213: .  `TAO_CONVERGED_USER` - the user indicates the optimization has succeeded
214: .  `TAO_DIVERGED_MAXITS` - the maximum number of iterations allowed has been achieved
215: .  `TAO_DIVERGED_NAN` - not a number appeared in the computations
216: .  `TAO_DIVERGED_MAXFCN` - the maximum number of function evaluations has been computed
217: .  `TAO_DIVERGED_LS_FAILURE` - a linesearch failed
218: .  `TAO_DIVERGED_TR_REDUCTION` - trust region failure
219: .  `TAO_DIVERGED_USER` - the user has indicated the optimization has failed
220: -  `TAO_CONTINUE_ITERATING` - the optimization is still running, `TaoSolve()`

222:    where
223: +  X - current solution
224: .  X0 - initial guess
225: .  f(X) - current function value
226: .  f(X*) - true solution (estimated)
227: .  g(X) - current gradient
228: .  its - current iterate number
229: .  maxits - maximum number of iterates
230: .  fevals - number of function evaluations
231: -  max_funcsals - maximum number of function evaluations

233:    Level: beginner

235:    Note:
236:    The two most common reasons for divergence are  an incorrectly coded or computed gradient or Hessian failure or lack of convergence
237:    in the linear system solve (in this case we recommend testing with `-pc_type lu` to eliminate the linear solver as the cause of the problem).

239:    Developer Note:
240:    The names in `KSPConvergedReason`, `SNESConvergedReason`, and `TaoConvergedReason` should be uniformized

242: .seealso: [](ch_tao), `Tao`, `TaoSolve()`, `TaoGetConvergedReason()`, `KSPConvergedReason`, `SNESConvergedReason`
243: E*/
244: typedef enum {               /* converged */
245:   TAO_CONVERGED_GATOL   = 3, /* ||g(X)|| < gatol */
246:   TAO_CONVERGED_GRTOL   = 4, /* ||g(X)|| / f(X)  < grtol */
247:   TAO_CONVERGED_GTTOL   = 5, /* ||g(X)|| / ||g(X0)|| < gttol */
248:   TAO_CONVERGED_STEPTOL = 6, /* step size small */
249:   TAO_CONVERGED_MINF    = 7, /* F < F_min */
250:   TAO_CONVERGED_USER    = 8, /* User defined */
251:   /* diverged */
252:   TAO_DIVERGED_MAXITS       = -2,
253:   TAO_DIVERGED_NAN          = -4,
254:   TAO_DIVERGED_MAXFCN       = -5,
255:   TAO_DIVERGED_LS_FAILURE   = -6,
256:   TAO_DIVERGED_TR_REDUCTION = -7,
257:   TAO_DIVERGED_USER         = -8, /* User defined */
258:   /* keep going */
259:   TAO_CONTINUE_ITERATING = 0
260: } TaoConvergedReason;

262: PETSC_EXTERN const char **TaoConvergedReasons;

264: PETSC_EXTERN PetscErrorCode TaoInitializePackage(void);
265: PETSC_EXTERN PetscErrorCode TaoFinalizePackage(void);
266: PETSC_EXTERN PetscErrorCode TaoCreate(MPI_Comm, Tao *);
267: PETSC_EXTERN PetscErrorCode TaoSetFromOptions(Tao);
268: PETSC_EXTERN PetscErrorCode TaoSetUp(Tao);
269: PETSC_EXTERN PetscErrorCode TaoSetType(Tao, TaoType);
270: PETSC_EXTERN PetscErrorCode TaoGetType(Tao, TaoType *);
271: PETSC_EXTERN PetscErrorCode TaoSetApplicationContext(Tao, void *);
272: PETSC_EXTERN PetscErrorCode TaoGetApplicationContext(Tao, void *);
273: PETSC_EXTERN PetscErrorCode TaoDestroy(Tao *);

275: PETSC_EXTERN PetscErrorCode TaoSetOptionsPrefix(Tao, const char[]);
276: PETSC_EXTERN PetscErrorCode TaoView(Tao, PetscViewer);
277: PETSC_EXTERN PetscErrorCode TaoViewFromOptions(Tao, PetscObject, const char[]);

279: PETSC_EXTERN PetscErrorCode TaoSolve(Tao);

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

284: PETSC_EXTERN PetscErrorCode TaoGetConvergedReason(Tao, TaoConvergedReason *);
285: PETSC_EXTERN PetscErrorCode TaoGetSolutionStatus(Tao, PetscInt *, PetscReal *, PetscReal *, PetscReal *, PetscReal *, TaoConvergedReason *);
286: PETSC_EXTERN PetscErrorCode TaoSetConvergedReason(Tao, TaoConvergedReason);
287: PETSC_EXTERN PetscErrorCode TaoSetSolution(Tao, Vec);
288: PETSC_EXTERN PetscErrorCode TaoGetSolution(Tao, Vec *);
289: PETSC_DEPRECATED_FUNCTION("Use TaoSetSolution() (since version 3.17)") static inline PetscErrorCode TaoSetInitialVector(Tao t, Vec v)
290: {
291:   return TaoSetSolution(t, v);
292: }
293: PETSC_DEPRECATED_FUNCTION("Use TaoGetSolution() (since version 3.17)") static inline PetscErrorCode TaoGetInitialVector(Tao t, Vec *v)
294: {
295:   return TaoGetSolution(t, v);
296: }

298: PETSC_EXTERN PetscErrorCode TaoSetObjective(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, void *), void *);
299: PETSC_EXTERN PetscErrorCode TaoGetObjective(Tao, PetscErrorCode (**)(Tao, Vec, PetscReal *, void *), void **);
300: PETSC_EXTERN PetscErrorCode TaoSetGradient(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
301: PETSC_EXTERN PetscErrorCode TaoGetGradient(Tao, Vec *, PetscErrorCode (**)(Tao, Vec, Vec, void *), void **);
302: PETSC_EXTERN PetscErrorCode TaoSetObjectiveAndGradient(Tao, Vec, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, void *), void *);
303: PETSC_EXTERN PetscErrorCode TaoGetObjectiveAndGradient(Tao, Vec *, PetscErrorCode (**)(Tao, Vec, PetscReal *, Vec, void *), void **);
304: PETSC_EXTERN PetscErrorCode TaoSetHessian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
305: PETSC_EXTERN PetscErrorCode TaoGetHessian(Tao, Mat *, Mat *, PetscErrorCode (**)(Tao, Vec, Mat, Mat, void *), void **);
306: PETSC_DEPRECATED_FUNCTION("Use TaoSetObjective() (since version 3.17)") static inline PetscErrorCode TaoSetObjectiveRoutine(Tao t, PetscErrorCode (*f)(Tao, Vec, PetscReal *, void *), void *c)
307: {
308:   return TaoSetObjective(t, f, c);
309: }
310: PETSC_DEPRECATED_FUNCTION("Use TaoGetGradient() (since version 3.17)") static inline PetscErrorCode TaoGetGradientVector(Tao t, Vec *v)
311: {
312:   return TaoGetGradient(t, v, PETSC_NULLPTR, PETSC_NULLPTR);
313: }
314: PETSC_DEPRECATED_FUNCTION("Use TaoSetGradient() (since version 3.17)") static inline PetscErrorCode TaoSetGradientRoutine(Tao t, PetscErrorCode (*f)(Tao, Vec, Vec, void *), void *c)
315: {
316:   return TaoSetGradient(t, PETSC_NULLPTR, f, c);
317: }
318: PETSC_DEPRECATED_FUNCTION("Use TaoSetObjectiveAndGradient() (since version 3.17)") static inline PetscErrorCode TaoSetObjectiveAndGradientRoutine(Tao t, PetscErrorCode (*f)(Tao, Vec, PetscReal *, Vec, void *), void *c)
319: {
320:   return TaoSetObjectiveAndGradient(t, PETSC_NULLPTR, f, c);
321: }
322: 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)
323: {
324:   return TaoSetHessian(t, H, P, f, c);
325: }

327: PETSC_EXTERN PetscErrorCode TaoSetGradientNorm(Tao, Mat);
328: PETSC_EXTERN PetscErrorCode TaoGetGradientNorm(Tao, Mat *);
329: PETSC_EXTERN PetscErrorCode TaoSetLMVMMatrix(Tao, Mat);
330: PETSC_EXTERN PetscErrorCode TaoGetLMVMMatrix(Tao, Mat *);
331: PETSC_EXTERN PetscErrorCode TaoSetRecycleHistory(Tao, PetscBool);
332: PETSC_EXTERN PetscErrorCode TaoGetRecycleHistory(Tao, PetscBool *);
333: PETSC_EXTERN PetscErrorCode TaoLMVMSetH0(Tao, Mat);
334: PETSC_EXTERN PetscErrorCode TaoLMVMGetH0(Tao, Mat *);
335: PETSC_EXTERN PetscErrorCode TaoLMVMGetH0KSP(Tao, KSP *);
336: PETSC_EXTERN PetscErrorCode TaoLMVMRecycle(Tao, PetscBool);
337: PETSC_EXTERN PetscErrorCode TaoSetResidualRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
338: PETSC_EXTERN PetscErrorCode TaoSetResidualWeights(Tao, Vec, PetscInt, PetscInt *, PetscInt *, PetscReal *);
339: PETSC_EXTERN PetscErrorCode TaoSetConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
340: PETSC_EXTERN PetscErrorCode TaoSetInequalityConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
341: PETSC_EXTERN PetscErrorCode TaoSetEqualityConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
342: PETSC_EXTERN PetscErrorCode TaoSetJacobianResidualRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
343: PETSC_EXTERN PetscErrorCode TaoSetJacobianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
344: PETSC_EXTERN PetscErrorCode TaoSetJacobianStateRoutine(Tao, Mat, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, Mat, void *), void *);
345: PETSC_EXTERN PetscErrorCode TaoSetJacobianDesignRoutine(Tao, Mat, PetscErrorCode (*)(Tao, Vec, Mat, void *), void *);
346: PETSC_EXTERN PetscErrorCode TaoSetJacobianInequalityRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
347: PETSC_EXTERN PetscErrorCode TaoSetJacobianEqualityRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);

349: PETSC_EXTERN PetscErrorCode TaoPythonSetType(Tao, const char[]);
350: PETSC_EXTERN PetscErrorCode TaoPythonGetType(Tao, const char *[]);

352: PETSC_EXTERN PetscErrorCode TaoShellSetSolve(Tao, PetscErrorCode (*)(Tao));
353: PETSC_EXTERN PetscErrorCode TaoShellSetContext(Tao, void *);
354: PETSC_EXTERN PetscErrorCode TaoShellGetContext(Tao, void *);

356: 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)
357: {
358:   return TaoSetResidualRoutine(tao, res, func, ctx);
359: }
360: 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)
361: {
362:   return TaoSetResidualWeights(tao, sigma_v, n, rows, cols, vals);
363: }

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

367: PETSC_EXTERN PetscErrorCode TaoComputeObjective(Tao, Vec, PetscReal *);
368: PETSC_EXTERN PetscErrorCode TaoComputeResidual(Tao, Vec, Vec);
369: PETSC_EXTERN PetscErrorCode TaoTestGradient(Tao, Vec, Vec);
370: PETSC_EXTERN PetscErrorCode TaoComputeGradient(Tao, Vec, Vec);
371: PETSC_EXTERN PetscErrorCode TaoComputeObjectiveAndGradient(Tao, Vec, PetscReal *, Vec);
372: PETSC_EXTERN PetscErrorCode TaoComputeConstraints(Tao, Vec, Vec);
373: PETSC_EXTERN PetscErrorCode TaoComputeInequalityConstraints(Tao, Vec, Vec);
374: PETSC_EXTERN PetscErrorCode TaoComputeEqualityConstraints(Tao, Vec, Vec);
375: PETSC_EXTERN PetscErrorCode TaoDefaultComputeGradient(Tao, Vec, Vec, void *);
376: PETSC_EXTERN PetscErrorCode TaoIsObjectiveDefined(Tao, PetscBool *);
377: PETSC_EXTERN PetscErrorCode TaoIsGradientDefined(Tao, PetscBool *);
378: PETSC_EXTERN PetscErrorCode TaoIsObjectiveAndGradientDefined(Tao, PetscBool *);

380: PETSC_DEPRECATED_FUNCTION("Use TaoComputeResidual() (since version 3.11)") static inline PetscErrorCode TaoComputeSeparableObjective(Tao tao, Vec X, Vec F)
381: {
382:   return TaoComputeResidual(tao, X, F);
383: }

385: PETSC_EXTERN PetscErrorCode TaoTestHessian(Tao);
386: PETSC_EXTERN PetscErrorCode TaoComputeHessian(Tao, Vec, Mat, Mat);
387: PETSC_EXTERN PetscErrorCode TaoComputeResidualJacobian(Tao, Vec, Mat, Mat);
388: PETSC_EXTERN PetscErrorCode TaoComputeJacobian(Tao, Vec, Mat, Mat);
389: PETSC_EXTERN PetscErrorCode TaoComputeJacobianState(Tao, Vec, Mat, Mat, Mat);
390: PETSC_EXTERN PetscErrorCode TaoComputeJacobianEquality(Tao, Vec, Mat, Mat);
391: PETSC_EXTERN PetscErrorCode TaoComputeJacobianInequality(Tao, Vec, Mat, Mat);
392: PETSC_EXTERN PetscErrorCode TaoComputeJacobianDesign(Tao, Vec, Mat);

394: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessian(Tao, Vec, Mat, Mat, void *);
395: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessianColor(Tao, Vec, Mat, Mat, void *);
396: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessianMFFD(Tao, Vec, Mat, Mat, void *);
397: PETSC_EXTERN PetscErrorCode TaoComputeDualVariables(Tao, Vec, Vec);
398: PETSC_EXTERN PetscErrorCode TaoSetVariableBounds(Tao, Vec, Vec);
399: PETSC_EXTERN PetscErrorCode TaoGetVariableBounds(Tao, Vec *, Vec *);
400: PETSC_EXTERN PetscErrorCode TaoGetDualVariables(Tao, Vec *, Vec *);
401: PETSC_EXTERN PetscErrorCode TaoSetInequalityBounds(Tao, Vec, Vec);
402: PETSC_EXTERN PetscErrorCode TaoGetInequalityBounds(Tao, Vec *, Vec *);
403: PETSC_EXTERN PetscErrorCode TaoSetVariableBoundsRoutine(Tao, PetscErrorCode (*)(Tao, Vec, Vec, void *), void *);
404: PETSC_EXTERN PetscErrorCode TaoComputeVariableBounds(Tao);

406: PETSC_EXTERN PetscErrorCode TaoGetTolerances(Tao, PetscReal *, PetscReal *, PetscReal *);
407: PETSC_EXTERN PetscErrorCode TaoSetTolerances(Tao, PetscReal, PetscReal, PetscReal);
408: PETSC_EXTERN PetscErrorCode TaoGetConstraintTolerances(Tao, PetscReal *, PetscReal *);
409: PETSC_EXTERN PetscErrorCode TaoSetConstraintTolerances(Tao, PetscReal, PetscReal);
410: PETSC_EXTERN PetscErrorCode TaoSetFunctionLowerBound(Tao, PetscReal);
411: PETSC_EXTERN PetscErrorCode TaoSetInitialTrustRegionRadius(Tao, PetscReal);
412: PETSC_EXTERN PetscErrorCode TaoSetMaximumIterations(Tao, PetscInt);
413: PETSC_EXTERN PetscErrorCode TaoSetMaximumFunctionEvaluations(Tao, PetscInt);
414: PETSC_EXTERN PetscErrorCode TaoGetFunctionLowerBound(Tao, PetscReal *);
415: PETSC_EXTERN PetscErrorCode TaoGetInitialTrustRegionRadius(Tao, PetscReal *);
416: PETSC_EXTERN PetscErrorCode TaoGetCurrentTrustRegionRadius(Tao, PetscReal *);
417: PETSC_EXTERN PetscErrorCode TaoGetMaximumIterations(Tao, PetscInt *);
418: PETSC_EXTERN PetscErrorCode TaoGetCurrentFunctionEvaluations(Tao, PetscInt *);
419: PETSC_EXTERN PetscErrorCode TaoGetMaximumFunctionEvaluations(Tao, PetscInt *);
420: PETSC_EXTERN PetscErrorCode TaoGetIterationNumber(Tao, PetscInt *);
421: PETSC_EXTERN PetscErrorCode TaoSetIterationNumber(Tao, PetscInt);
422: PETSC_EXTERN PetscErrorCode TaoGetTotalIterationNumber(Tao, PetscInt *);
423: PETSC_EXTERN PetscErrorCode TaoSetTotalIterationNumber(Tao, PetscInt);
424: PETSC_EXTERN PetscErrorCode TaoGetResidualNorm(Tao, PetscReal *);

426: PETSC_EXTERN PetscErrorCode TaoAppendOptionsPrefix(Tao, const char[]);
427: PETSC_EXTERN PetscErrorCode TaoGetOptionsPrefix(Tao, const char *[]);
428: PETSC_EXTERN PetscErrorCode TaoResetStatistics(Tao);
429: PETSC_EXTERN PetscErrorCode TaoSetUpdate(Tao, PetscErrorCode (*)(Tao, PetscInt, void *), void *);

431: PETSC_EXTERN PetscErrorCode TaoGetKSP(Tao, KSP *);
432: PETSC_EXTERN PetscErrorCode TaoGetLinearSolveIterations(Tao, PetscInt *);
433: PETSC_EXTERN PetscErrorCode TaoKSPSetUseEW(Tao, PetscBool);

435: #include <petsctaolinesearch.h>

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

439: PETSC_EXTERN PetscErrorCode TaoSetConvergenceHistory(Tao, PetscReal *, PetscReal *, PetscReal *, PetscInt *, PetscInt, PetscBool);
440: PETSC_EXTERN PetscErrorCode TaoGetConvergenceHistory(Tao, PetscReal **, PetscReal **, PetscReal **, PetscInt **, PetscInt *);
441: PETSC_EXTERN PetscErrorCode TaoSetMonitor(Tao, PetscErrorCode (*)(Tao, void *), void *, PetscErrorCode (*)(void **));
442: PETSC_EXTERN PetscErrorCode TaoCancelMonitors(Tao);
443: PETSC_EXTERN PetscErrorCode TaoMonitorDefault(Tao, void *);
444: PETSC_DEPRECATED_FUNCTION("Use TaoMonitorDefault() (since version 3.9)") static inline PetscErrorCode TaoDefaultMonitor(Tao tao, void *ctx)
445: {
446:   return TaoMonitorDefault(tao, ctx);
447: }
448: PETSC_EXTERN PetscErrorCode TaoDefaultGMonitor(Tao, void *);
449: PETSC_EXTERN PetscErrorCode TaoDefaultSMonitor(Tao, void *);
450: PETSC_EXTERN PetscErrorCode TaoDefaultCMonitor(Tao, void *);
451: PETSC_EXTERN PetscErrorCode TaoSolutionMonitor(Tao, void *);
452: PETSC_EXTERN PetscErrorCode TaoResidualMonitor(Tao, void *);
453: PETSC_EXTERN PetscErrorCode TaoGradientMonitor(Tao, void *);
454: PETSC_EXTERN PetscErrorCode TaoStepDirectionMonitor(Tao, void *);
455: PETSC_EXTERN PetscErrorCode TaoDrawSolutionMonitor(Tao, void *);
456: PETSC_EXTERN PetscErrorCode TaoDrawStepMonitor(Tao, void *);
457: PETSC_EXTERN PetscErrorCode TaoDrawGradientMonitor(Tao, void *);
458: PETSC_EXTERN PetscErrorCode TaoAddLineSearchCounts(Tao);

460: PETSC_EXTERN PetscErrorCode TaoDefaultConvergenceTest(Tao, void *);
461: PETSC_EXTERN PetscErrorCode TaoSetConvergenceTest(Tao, PetscErrorCode (*)(Tao, void *), void *);

463: PETSC_EXTERN PetscErrorCode          TaoLCLSetStateDesignIS(Tao, IS, IS);
464: PETSC_EXTERN PetscErrorCode          TaoMonitor(Tao, PetscInt, PetscReal, PetscReal, PetscReal, PetscReal);
465: typedef struct _n_TaoMonitorDrawCtx *TaoMonitorDrawCtx;
466: PETSC_EXTERN PetscErrorCode          TaoMonitorDrawCtxCreate(MPI_Comm, const char[], const char[], int, int, int, int, PetscInt, TaoMonitorDrawCtx *);
467: PETSC_EXTERN PetscErrorCode          TaoMonitorDrawCtxDestroy(TaoMonitorDrawCtx *);

469: PETSC_EXTERN PetscErrorCode TaoBRGNGetSubsolver(Tao, Tao *);
470: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, void *), void *);
471: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerHessianRoutine(Tao, Mat, PetscErrorCode (*)(Tao, Vec, Mat, void *), void *);
472: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerWeight(Tao, PetscReal);
473: PETSC_EXTERN PetscErrorCode TaoBRGNSetL1SmoothEpsilon(Tao, PetscReal);
474: PETSC_EXTERN PetscErrorCode TaoBRGNSetDictionaryMatrix(Tao, Mat);
475: PETSC_EXTERN PetscErrorCode TaoBRGNGetDampingVector(Tao, Vec *);

477: PETSC_EXTERN PetscErrorCode TaoADMMGetMisfitSubsolver(Tao, Tao *);
478: PETSC_EXTERN PetscErrorCode TaoADMMGetRegularizationSubsolver(Tao, Tao *);
479: PETSC_EXTERN PetscErrorCode TaoADMMGetDualVector(Tao, Vec *);
480: PETSC_EXTERN PetscErrorCode TaoADMMGetSpectralPenalty(Tao, PetscReal *);
481: PETSC_EXTERN PetscErrorCode TaoADMMSetSpectralPenalty(Tao, PetscReal);
482: PETSC_EXTERN PetscErrorCode TaoGetADMMParentTao(Tao, Tao *);
483: PETSC_EXTERN PetscErrorCode TaoADMMSetConstraintVectorRHS(Tao, Vec);
484: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerCoefficient(Tao, PetscReal);
485: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitConstraintJacobian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
486: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerConstraintJacobian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
487: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerHessianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
488: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, void *), void *);
489: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitHessianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, void *), void *);
490: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, void *), void *);
491: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitHessianChangeStatus(Tao, PetscBool);
492: PETSC_EXTERN PetscErrorCode TaoADMMSetRegHessianChangeStatus(Tao, PetscBool);
493: PETSC_EXTERN PetscErrorCode TaoADMMSetMinimumSpectralPenalty(Tao, PetscReal);
494: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerType(Tao, TaoADMMRegularizerType);
495: PETSC_EXTERN PetscErrorCode TaoADMMGetRegularizerType(Tao, TaoADMMRegularizerType *);
496: PETSC_EXTERN PetscErrorCode TaoADMMSetUpdateType(Tao, TaoADMMUpdateType);
497: PETSC_EXTERN PetscErrorCode TaoADMMGetUpdateType(Tao, TaoADMMUpdateType *);

499: PETSC_EXTERN PetscErrorCode TaoALMMGetType(Tao, TaoALMMType *);
500: PETSC_EXTERN PetscErrorCode TaoALMMSetType(Tao, TaoALMMType);
501: PETSC_EXTERN PetscErrorCode TaoALMMGetSubsolver(Tao, Tao *);
502: PETSC_EXTERN PetscErrorCode TaoALMMSetSubsolver(Tao, Tao);
503: PETSC_EXTERN PetscErrorCode TaoALMMGetMultipliers(Tao, Vec *);
504: PETSC_EXTERN PetscErrorCode TaoALMMSetMultipliers(Tao, Vec);
505: PETSC_EXTERN PetscErrorCode TaoALMMGetPrimalIS(Tao, IS *, IS *);
506: PETSC_EXTERN PetscErrorCode TaoALMMGetDualIS(Tao, IS *, IS *);
507: #endif