Actual source code: petsctao.h
1: #pragma once
3: #include <petscsnes.h>
4: #include <petsctaotypes.h>
5: #include <petsctaoterm.h>
7: /* SUBMANSEC = Tao */
9: PETSC_EXTERN PetscErrorCode MatDSFischer(Mat, Vec, Vec, Vec, Vec, PetscReal, Vec, Vec, Vec, Vec, Vec);
10: PETSC_EXTERN PetscErrorCode TaoSoftThreshold(Vec, PetscReal, PetscReal, Vec);
12: /*E
13: TaoSubsetType - Type representing the way the `Tao` solvers handle active sets
15: Values:
16: + `TAO_SUBSET_SUBVEC` - Tao uses `MatCreateSubMatrix()` and `VecGetSubVector()`
17: . `TAO_SUBSET_MASK` - Matrices are zeroed out corresponding to active set entries
18: - `TAO_SUBSET_MATRIXFREE` - Same as `TAO_SUBSET_MASK` but it can be applied to matrix-free operators
20: Options database Key:
21: . -different_hessian - `Tao` will use a copy of the Hessian operator for masking. By default `Tao` will directly alter the Hessian operator.
23: Level: intermediate
25: .seealso: [](ch_tao), `TaoVecGetSubVec()`, `TaoMatGetSubMat()`, `Tao`, `TaoCreate()`, `TaoDestroy()`, `TaoSetType()`, `TaoType`
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: /*E
35: TaoADMMUpdateType - Determine the spectral penalty update routine for the Lagrange augmented term for `TAOADMM`.
37: Level: advanced
39: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoADMMSetUpdateType()`
40: E*/
41: typedef enum {
42: TAO_ADMM_UPDATE_BASIC,
43: TAO_ADMM_UPDATE_ADAPTIVE,
44: TAO_ADMM_UPDATE_ADAPTIVE_RELAXED
45: } TaoADMMUpdateType;
46: PETSC_EXTERN const char *const TaoADMMUpdateTypes[];
48: /*MC
49: TAO_ADMM_UPDATE_BASIC - Use same spectral penalty set at the beginning. This never performs an update to the penalty
51: Level: advanced
53: Note:
54: Most basic implementation of `TAOADMM`. Generally slower than adaptive or adaptive relaxed version.
56: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_ADAPTIVE`, `TAO_ADMM_UPDATE_ADAPTIVE_RELAXED`
57: M*/
59: /*MC
60: TAO_ADMM_UPDATE_ADAPTIVE - Adaptively update the spectral penalty
62: Level: advanced
64: Note:
65: Adaptively updates spectral penalty of `TAOADMM` by using both steepest descent and minimum gradient.
67: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_BASIC`, `TAO_ADMM_UPDATE_ADAPTIVE_RELAXED`
68: M*/
70: /*MC
71: ADMM_UPDATE_ADAPTIVE_RELAXED - Adaptively update spectral penalty, and relaxes parameter update
73: Level: advanced
75: Note:
76: With adaptive spectral penalty update, it also relaxes the `x` vector update by a factor.
78: .seealso: [](ch_tao), `Tao`, `TaoADMMSetUpdateType()`, `TAO_ADMM_UPDATE_BASIC`, `TAO_ADMM_UPDATE_ADAPTIVE`
79: M*/
81: /*E
82: TaoADMMRegularizerType - Determine regularizer routine - either user provided or soft threshold for `TAOADMM`
84: Level: advanced
86: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoADMMSetRegularizerType()`
87: E*/
88: typedef enum {
89: TAO_ADMM_REGULARIZER_USER,
90: TAO_ADMM_REGULARIZER_SOFT_THRESH
91: } TaoADMMRegularizerType;
92: PETSC_EXTERN const char *const TaoADMMRegularizerTypes[];
94: /*MC
95: TAO_ADMM_REGULARIZER_USER - User provided routines for regularizer part of `TAOADMM`
97: Level: advanced
99: Note:
100: User needs to provided appropriate routines and type for regularizer solver
102: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoADMMSetRegularizerType()`, `TAO_ADMM_REGULARIZER_SOFT_THRESH`
103: M*/
105: /*MC
106: TAO_ADMM_REGULARIZER_SOFT_THRESH - Soft threshold to solve regularizer part of `TAOADMM`
108: Level: advanced
110: Note:
111: Utilizes built-in SoftThreshold routines
113: .seealso: [](ch_tao), `Tao`, `TAOADMM`, `TaoSoftThreshold()`, `TaoADMMSetRegularizerObjectiveAndGradientRoutine()`,
114: `TaoADMMSetRegularizerHessianRoutine()`, `TaoADMMSetRegularizerType()`, `TAO_ADMM_REGULARIZER_USER`
115: M*/
117: /*E
118: TaoALMMType - Determine the augmented Lagrangian formulation used in the `TAOALMM` subproblem.
120: Values:
121: + `TAO_ALMM_CLASSIC` - classic augmented Lagrangian definition including slack variables for inequality constraints
122: - `TAO_ALMM_PHR` - Powell-Hestenes-Rockafellar formulation without slack variables, uses pointwise `min()` for inequalities
124: Level: advanced
126: .seealso: [](ch_tao), `Tao`, `TAOALMM`, `TaoALMMSetType()`, `TaoALMMGetType()`
127: E*/
128: typedef enum {
129: TAO_ALMM_CLASSIC,
130: TAO_ALMM_PHR
131: } TaoALMMType;
132: PETSC_EXTERN const char *const TaoALMMTypes[];
134: /*E
135: TaoBNCGType - Determine the conjugate gradient update formula used in the `TAOBNCG` algorithm.
137: Values:
138: + `TAO_BNCG_GD` - basic gradient descent, no CG update
139: . `TAO_BNCG_PCGD` - preconditioned/scaled gradient descent
140: . `TAO_BNCG_HS` - Hestenes-Stiefel
141: . `TAO_BNCG_FR` - Fletcher-Reeves
142: . `TAO_BNCG_PRP` - Polak-Ribiere-Polyak (PRP)
143: . `TAO_BNCG_PRP_PLUS` - Polak-Ribiere-Polyak "plus" (PRP+)
144: . `TAO_BNCG_DY` - Dai-Yuan
145: . `TAO_BNCG_HZ` - Hager-Zhang (CG_DESCENT 5.3)
146: . `TAO_BNCG_DK` - Dai-Kou (2013)
147: . `TAO_BNCG_KD` - Kou-Dai (2015)
148: . `TAO_BNCG_SSML_BFGS` - Self-Scaling Memoryless BFGS (Perry-Shanno)
149: . `TAO_BNCG_SSML_DFP` - Self-Scaling Memoryless DFP
150: - `TAO_BNCG_SSML_BRDN` - Self-Scaling Memoryless (Symmetric) Broyden
152: Level: advanced
154: .seealso: `Tao`, `TAOBNCG`, `TaoBNCGSetType()`, `TaoBNCGGetType()`
155: E*/
157: typedef enum {
158: TAO_BNCG_GD,
159: TAO_BNCG_PCGD,
160: TAO_BNCG_HS,
161: TAO_BNCG_FR,
162: TAO_BNCG_PRP,
163: TAO_BNCG_PRP_PLUS,
164: TAO_BNCG_DY,
165: TAO_BNCG_HZ,
166: TAO_BNCG_DK,
167: TAO_BNCG_KD,
168: TAO_BNCG_SSML_BFGS,
169: TAO_BNCG_SSML_DFP,
170: TAO_BNCG_SSML_BRDN
171: } TaoBNCGType;
172: PETSC_EXTERN const char *const TaoBNCGTypes[];
174: /*J
175: TaoType - String with the name of a `Tao` method
177: Values:
178: + `TAONLS` - nls Newton's method with line search for unconstrained minimization
179: . `TAONTR` - ntr Newton's method with trust region for unconstrained minimization
180: . `TAONTL` - ntl Newton's method with trust region, line search for unconstrained minimization
181: . `TAOLMVM` - lmvm Limited memory variable metric method for unconstrained minimization
182: . `TAOCG` - cg Nonlinear conjugate gradient method for unconstrained minimization
183: . `TAONM` - nm Nelder-Mead algorithm for derivate-free unconstrained minimization
184: . `TAOTRON` - tron Newton Trust Region method for bound constrained minimization
185: . `TAOGPCG` - gpcg Newton Trust Region method for quadratic bound constrained minimization
186: . `TAOBLMVM` - blmvm Limited memory variable metric method for bound constrained minimization
187: . `TAOLCL` - lcl Linearly constrained Lagrangian method for pde-constrained minimization
188: - `TAOPOUNDERS` - Pounders Model-based algorithm for nonlinear least squares
190: Level: beginner
192: .seealso: [](doc_taosolve), [](ch_tao), `Tao`, `TaoCreate()`, `TaoSetType()`
193: J*/
194: typedef const char *TaoType;
195: #define TAOLMVM "lmvm"
196: #define TAONLS "nls"
197: #define TAONTR "ntr"
198: #define TAONTL "ntl"
199: #define TAOCG "cg"
200: #define TAOTRON "tron"
201: #define TAOOWLQN "owlqn"
202: #define TAOBMRM "bmrm"
203: #define TAOBLMVM "blmvm"
204: #define TAOBQNLS "bqnls"
205: #define TAOBNCG "bncg"
206: #define TAOBNLS "bnls"
207: #define TAOBNTR "bntr"
208: #define TAOBNTL "bntl"
209: #define TAOBNK "bnk"
210: #define TAOBQNKLS "bqnkls"
211: #define TAOBQNKTR "bqnktr"
212: #define TAOBQNKTL "bqnktl"
213: #define TAOBQPIP "bqpip"
214: #define TAOGPCG "gpcg"
215: #define TAONM "nm"
216: #define TAOPOUNDERS "pounders"
217: #define TAOBRGN "brgn"
218: #define TAOLCL "lcl"
219: #define TAOSSILS "ssils"
220: #define TAOSSFLS "ssfls"
221: #define TAOASILS "asils"
222: #define TAOASFLS "asfls"
223: #define TAOIPM "ipm"
224: #define TAOPDIPM "pdipm"
225: #define TAOSHELL "shell"
226: #define TAOADMM "admm"
227: #define TAOALMM "almm"
228: #define TAOPYTHON "python"
229: #define TAOSNES "snes"
231: PETSC_EXTERN PetscClassId TAO_CLASSID;
232: PETSC_EXTERN PetscFunctionList TaoList;
234: /*E
235: TaoConvergedReason - reason a `Tao` optimizer was said to have converged or diverged
237: Values:
238: + `TAO_CONVERGED_GATOL` - $\|g(X)\| < gatol$
239: . `TAO_CONVERGED_GRTOL` - $\|g(X)\| / f(X) < grtol$
240: . `TAO_CONVERGED_GTTOL` - $\|g(X)\| / \|g(X0)\| < gttol$
241: . `TAO_CONVERGED_STEPTOL` - step size smaller than tolerance
242: . `TAO_CONVERGED_MINF` - $F < F_min$
243: . `TAO_CONVERGED_USER` - the user indicates the optimization has succeeded
244: . `TAO_DIVERGED_MAXITS` - the maximum number of iterations allowed has been achieved
245: . `TAO_DIVERGED_NAN` - not a number appeared in the computations
246: . `TAO_DIVERGED_MAXFCN` - the maximum number of function evaluations has been computed
247: . `TAO_DIVERGED_LS_FAILURE` - a linesearch failed
248: . `TAO_DIVERGED_TR_REDUCTION` - trust region failure
249: . `TAO_DIVERGED_USER` - the user has indicated the optimization has failed
250: - `TAO_CONTINUE_ITERATING` - the optimization is still running, `TaoSolve()`
252: where
253: + X - current solution
254: . X0 - initial guess
255: . f(X) - current function value
256: . f(X*) - true solution (estimated)
257: . g(X) - current gradient
258: . its - current iterate number
259: . maxits - maximum number of iterates
260: . fevals - number of function evaluations
261: - max_funcsals - maximum number of function evaluations
263: Level: beginner
265: Note:
266: The two most common reasons for divergence are an incorrectly coded or computed gradient or Hessian failure or lack of convergence
267: 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).
269: Developer Note:
270: The names in `KSPConvergedReason`, `SNESConvergedReason`, and `TaoConvergedReason` should be uniformized
272: .seealso: [](ch_tao), `Tao`, `TaoSolve()`, `TaoGetConvergedReason()`, `KSPConvergedReason`, `SNESConvergedReason`
273: E*/
274: typedef enum { /* converged */
275: TAO_CONVERGED_GATOL = 3, /* ||g(X)|| < gatol */
276: TAO_CONVERGED_GRTOL = 4, /* ||g(X)|| / f(X) < grtol */
277: TAO_CONVERGED_GTTOL = 5, /* ||g(X)|| / ||g(X0)|| < gttol */
278: TAO_CONVERGED_STEPTOL = 6, /* step size small */
279: TAO_CONVERGED_MINF = 7, /* F < F_min */
280: TAO_CONVERGED_USER = 8, /* User defined */
281: /* diverged */
282: TAO_DIVERGED_MAXITS = -2,
283: TAO_DIVERGED_NAN = -4,
284: TAO_DIVERGED_MAXFCN = -5,
285: TAO_DIVERGED_LS_FAILURE = -6,
286: TAO_DIVERGED_TR_REDUCTION = -7,
287: TAO_DIVERGED_USER = -8, /* User defined */
288: /* keep going */
289: TAO_CONTINUE_ITERATING = 0
290: } TaoConvergedReason;
292: PETSC_EXTERN const char **TaoConvergedReasons;
294: PETSC_EXTERN PetscErrorCode TaoInitializePackage(void);
295: PETSC_EXTERN PetscErrorCode TaoFinalizePackage(void);
296: PETSC_EXTERN PetscErrorCode TaoCreate(MPI_Comm, Tao *);
297: PETSC_EXTERN PetscErrorCode TaoSetFromOptions(Tao);
298: PETSC_EXTERN PetscErrorCode TaoSetUp(Tao);
299: PETSC_EXTERN PetscErrorCode TaoSetType(Tao, TaoType);
300: PETSC_EXTERN PetscErrorCode TaoGetType(Tao, TaoType *);
301: PETSC_EXTERN PetscErrorCode TaoSetApplicationContext(Tao, PetscCtx);
302: PETSC_EXTERN PetscErrorCode TaoGetApplicationContext(Tao, PetscCtxRt);
303: PETSC_EXTERN PetscErrorCode TaoDestroy(Tao *);
304: PETSC_EXTERN PetscErrorCode TaoParametersInitialize(Tao);
306: PETSC_EXTERN PetscErrorCode TaoSetOptionsPrefix(Tao, const char[]);
307: PETSC_EXTERN PetscErrorCode TaoView(Tao, PetscViewer);
308: PETSC_EXTERN PetscErrorCode TaoViewFromOptions(Tao, PetscObject, const char[]);
310: PETSC_EXTERN PetscErrorCode TaoSolve(Tao);
312: PETSC_EXTERN PetscErrorCode TaoRegister(const char[], PetscErrorCode (*)(Tao));
313: PETSC_EXTERN PetscErrorCode TaoRegisterDestroy(void);
315: PETSC_EXTERN PetscErrorCode TaoGetConvergedReason(Tao, TaoConvergedReason *);
316: PETSC_EXTERN TaoConvergedReason TaoConvergedReasonFromSNES(SNESConvergedReason);
317: PETSC_EXTERN PetscErrorCode TaoGetConvergedReasonString(Tao, const char *[]);
318: PETSC_EXTERN PetscErrorCode TaoGetSolutionStatus(Tao, PetscInt *, PetscReal *, PetscReal *, PetscReal *, PetscReal *, TaoConvergedReason *);
319: PETSC_EXTERN PetscErrorCode TaoSetConvergedReason(Tao, TaoConvergedReason);
320: PETSC_EXTERN PetscErrorCode TaoSetSolution(Tao, Vec);
321: PETSC_EXTERN PetscErrorCode TaoGetSolution(Tao, Vec *);
323: PETSC_EXTERN PetscErrorCode TaoSetObjective(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, PetscCtx), PetscCtx);
324: PETSC_EXTERN PetscErrorCode TaoGetObjective(Tao, PetscErrorCode (**)(Tao, Vec, PetscReal *, PetscCtx), PetscCtxRt);
325: PETSC_EXTERN PetscErrorCode TaoSetGradient(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, PetscCtx), PetscCtx);
326: PETSC_EXTERN PetscErrorCode TaoGetGradient(Tao, Vec *, PetscErrorCode (**)(Tao, Vec, Vec, PetscCtx), PetscCtxRt);
327: PETSC_EXTERN PetscErrorCode TaoSetObjectiveAndGradient(Tao, Vec, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, PetscCtx), PetscCtx);
328: PETSC_EXTERN PetscErrorCode TaoGetObjectiveAndGradient(Tao, Vec *, PetscErrorCode (**)(Tao, Vec, PetscReal *, Vec, PetscCtx), PetscCtxRt);
329: PETSC_EXTERN PetscErrorCode TaoSetHessian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
330: PETSC_EXTERN PetscErrorCode TaoGetHessian(Tao, Mat *, Mat *, PetscErrorCode (**)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtxRt);
331: PETSC_EXTERN PetscErrorCode TaoGetHessianMatrices(Tao, Mat *, Mat *);
332: PETSC_EXTERN PetscErrorCode TaoGetDM(Tao, DM *);
333: PETSC_EXTERN PetscErrorCode TaoSetDM(Tao, DM);
335: PETSC_EXTERN PetscErrorCode TaoSetGradientNorm(Tao, Mat);
336: PETSC_EXTERN PetscErrorCode TaoGetGradientNorm(Tao, Mat *);
337: PETSC_EXTERN PetscErrorCode TaoSetLMVMMatrix(Tao, Mat);
338: PETSC_EXTERN PetscErrorCode TaoGetLMVMMatrix(Tao, Mat *);
339: PETSC_EXTERN PetscErrorCode TaoSetRecycleHistory(Tao, PetscBool);
340: PETSC_EXTERN PetscErrorCode TaoGetRecycleHistory(Tao, PetscBool *);
341: PETSC_EXTERN PetscErrorCode TaoLMVMSetH0(Tao, Mat);
342: PETSC_EXTERN PetscErrorCode TaoLMVMGetH0(Tao, Mat *);
343: PETSC_EXTERN PetscErrorCode TaoLMVMGetH0KSP(Tao, KSP *);
344: PETSC_EXTERN PetscErrorCode TaoLMVMRecycle(Tao, PetscBool);
345: PETSC_EXTERN PetscErrorCode TaoSetResidualRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, PetscCtx), PetscCtx);
346: PETSC_EXTERN PetscErrorCode TaoSetResidualWeights(Tao, Vec, PetscInt, PetscInt *, PetscInt *, PetscReal *);
347: PETSC_EXTERN PetscErrorCode TaoSetConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, PetscCtx), PetscCtx);
348: PETSC_EXTERN PetscErrorCode TaoSetInequalityConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, PetscCtx), PetscCtx);
349: PETSC_EXTERN PetscErrorCode TaoGetInequalityConstraintsRoutine(Tao, Vec *, PetscErrorCode (**)(Tao, Vec, Vec, PetscCtx), PetscCtxRt);
350: PETSC_EXTERN PetscErrorCode TaoSetEqualityConstraintsRoutine(Tao, Vec, PetscErrorCode (*)(Tao, Vec, Vec, PetscCtx), PetscCtx);
351: PETSC_EXTERN PetscErrorCode TaoGetEqualityConstraintsRoutine(Tao, Vec *, PetscErrorCode (**)(Tao, Vec, Vec, PetscCtx), PetscCtxRt);
352: PETSC_EXTERN PetscErrorCode TaoSetJacobianResidualRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
353: PETSC_EXTERN PetscErrorCode TaoSetJacobianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
354: PETSC_EXTERN PetscErrorCode TaoSetJacobianStateRoutine(Tao, Mat, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, Mat, PetscCtx), PetscCtx);
355: PETSC_EXTERN PetscErrorCode TaoSetJacobianDesignRoutine(Tao, Mat, PetscErrorCode (*)(Tao, Vec, Mat, PetscCtx), PetscCtx);
356: PETSC_EXTERN PetscErrorCode TaoSetJacobianInequalityRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
357: PETSC_EXTERN PetscErrorCode TaoGetJacobianInequalityRoutine(Tao, Mat *, Mat *, PetscErrorCode (**)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtxRt);
358: PETSC_EXTERN PetscErrorCode TaoSetJacobianEqualityRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
359: PETSC_EXTERN PetscErrorCode TaoGetJacobianEqualityRoutine(Tao, Mat *, Mat *, PetscErrorCode (**)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtxRt);
361: PETSC_EXTERN PetscErrorCode TaoPythonSetType(Tao, const char[]);
362: PETSC_EXTERN PetscErrorCode TaoPythonGetType(Tao, const char *[]);
364: PETSC_EXTERN PetscErrorCode TaoShellSetSolve(Tao, PetscErrorCode (*)(Tao));
365: PETSC_EXTERN PetscErrorCode TaoShellSetContext(Tao, PetscCtx);
366: PETSC_EXTERN PetscErrorCode TaoShellGetContext(Tao, PetscCtxRt);
368: PETSC_EXTERN PetscErrorCode TaoSetStateDesignIS(Tao, IS, IS);
370: PETSC_EXTERN PetscErrorCode TaoComputeObjective(Tao, Vec, PetscReal *);
371: PETSC_EXTERN PetscErrorCode TaoComputeResidual(Tao, Vec, Vec);
372: PETSC_EXTERN PetscErrorCode TaoTestGradient(Tao, Vec, Vec);
373: PETSC_EXTERN PetscErrorCode TaoComputeGradient(Tao, Vec, Vec);
374: PETSC_EXTERN PetscErrorCode TaoComputeObjectiveAndGradient(Tao, Vec, PetscReal *, Vec);
375: PETSC_EXTERN PetscErrorCode TaoComputeConstraints(Tao, Vec, Vec);
376: PETSC_EXTERN PetscErrorCode TaoComputeInequalityConstraints(Tao, Vec, Vec);
377: PETSC_EXTERN PetscErrorCode TaoComputeEqualityConstraints(Tao, Vec, Vec);
378: PETSC_EXTERN PetscErrorCode TaoDefaultComputeGradient(Tao, Vec, Vec, PetscCtx);
379: PETSC_EXTERN PetscErrorCode TaoIsObjectiveDefined(Tao, PetscBool *);
380: PETSC_EXTERN PetscErrorCode TaoIsGradientDefined(Tao, PetscBool *);
381: PETSC_EXTERN PetscErrorCode TaoIsObjectiveAndGradientDefined(Tao, PetscBool *);
383: PETSC_EXTERN PetscErrorCode TaoTestHessian(Tao);
384: PETSC_EXTERN PetscErrorCode TaoComputeHessian(Tao, Vec, Mat, Mat);
385: PETSC_EXTERN PetscErrorCode TaoComputeResidualJacobian(Tao, Vec, Mat, Mat);
386: PETSC_EXTERN PetscErrorCode TaoComputeJacobian(Tao, Vec, Mat, Mat);
387: PETSC_EXTERN PetscErrorCode TaoComputeJacobianState(Tao, Vec, Mat, Mat, Mat);
388: PETSC_EXTERN PetscErrorCode TaoComputeJacobianEquality(Tao, Vec, Mat, Mat);
389: PETSC_EXTERN PetscErrorCode TaoComputeJacobianInequality(Tao, Vec, Mat, Mat);
390: PETSC_EXTERN PetscErrorCode TaoComputeJacobianDesign(Tao, Vec, Mat);
392: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessian(Tao, Vec, Mat, Mat, PetscCtx);
393: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessianColor(Tao, Vec, Mat, Mat, PetscCtx);
394: PETSC_EXTERN PetscErrorCode TaoDefaultComputeHessianMFFD(Tao, Vec, Mat, Mat, PetscCtx);
395: PETSC_EXTERN PetscErrorCode TaoComputeDualVariables(Tao, Vec, Vec);
396: PETSC_EXTERN PetscErrorCode TaoSetVariableBounds(Tao, Vec, Vec);
397: PETSC_EXTERN PetscErrorCode TaoGetVariableBounds(Tao, Vec *, Vec *);
398: PETSC_EXTERN PetscErrorCode TaoGetDualVariables(Tao, Vec *, Vec *);
399: PETSC_EXTERN PetscErrorCode TaoSetInequalityBounds(Tao, Vec, Vec);
400: PETSC_EXTERN PetscErrorCode TaoGetInequalityBounds(Tao, Vec *, Vec *);
401: PETSC_EXTERN PetscErrorCode TaoSetVariableBoundsRoutine(Tao, PetscErrorCode (*)(Tao, Vec, Vec, PetscCtx), PetscCtx);
402: PETSC_EXTERN PetscErrorCode TaoComputeVariableBounds(Tao);
404: PETSC_EXTERN PetscErrorCode TaoGetTolerances(Tao, PetscReal *, PetscReal *, PetscReal *);
405: PETSC_EXTERN PetscErrorCode TaoSetTolerances(Tao, PetscReal, PetscReal, PetscReal);
406: PETSC_EXTERN PetscErrorCode TaoGetConstraintTolerances(Tao, PetscReal *, PetscReal *);
407: PETSC_EXTERN PetscErrorCode TaoSetConstraintTolerances(Tao, PetscReal, PetscReal);
408: PETSC_EXTERN PetscErrorCode TaoSetFunctionLowerBound(Tao, PetscReal);
409: PETSC_EXTERN PetscErrorCode TaoSetInitialTrustRegionRadius(Tao, PetscReal);
410: PETSC_EXTERN PetscErrorCode TaoSetMaximumIterations(Tao, PetscInt);
411: PETSC_EXTERN PetscErrorCode TaoSetMaximumFunctionEvaluations(Tao, PetscInt);
412: PETSC_EXTERN PetscErrorCode TaoGetFunctionLowerBound(Tao, PetscReal *);
413: PETSC_EXTERN PetscErrorCode TaoGetInitialTrustRegionRadius(Tao, PetscReal *);
414: PETSC_EXTERN PetscErrorCode TaoGetCurrentTrustRegionRadius(Tao, PetscReal *);
415: PETSC_EXTERN PetscErrorCode TaoGetMaximumIterations(Tao, PetscInt *);
416: PETSC_EXTERN PetscErrorCode TaoGetCurrentFunctionEvaluations(Tao, PetscInt *);
417: PETSC_EXTERN PetscErrorCode TaoGetMaximumFunctionEvaluations(Tao, PetscInt *);
418: PETSC_EXTERN PetscErrorCode TaoGetIterationNumber(Tao, PetscInt *);
419: PETSC_EXTERN PetscErrorCode TaoSetIterationNumber(Tao, PetscInt);
420: PETSC_EXTERN PetscErrorCode TaoGetTotalIterationNumber(Tao, PetscInt *);
421: PETSC_EXTERN PetscErrorCode TaoSetTotalIterationNumber(Tao, PetscInt);
422: PETSC_EXTERN PetscErrorCode TaoGetResidualNorm(Tao, PetscReal *);
424: PETSC_EXTERN PetscErrorCode TaoAppendOptionsPrefix(Tao, const char[]);
425: PETSC_EXTERN PetscErrorCode TaoGetOptionsPrefix(Tao, const char *[]);
426: PETSC_EXTERN PetscErrorCode TaoResetStatistics(Tao);
427: PETSC_EXTERN PetscErrorCode TaoSetUpdate(Tao, PetscErrorCode (*)(Tao, PetscInt, PetscCtx), PetscCtx);
429: PETSC_EXTERN PetscErrorCode TaoGetKSP(Tao, KSP *);
430: PETSC_EXTERN PetscErrorCode TaoGetLinearSolveIterations(Tao, PetscInt *);
431: PETSC_EXTERN PetscErrorCode TaoKSPSetUseEW(Tao, PetscBool);
433: #include <petsctaolinesearch.h>
435: PETSC_EXTERN PetscErrorCode TaoGetLineSearch(Tao, TaoLineSearch *);
437: PETSC_EXTERN PetscErrorCode TaoSetConvergenceHistory(Tao, PetscReal *, PetscReal *, PetscReal *, PetscInt *, PetscInt, PetscBool);
438: PETSC_EXTERN PetscErrorCode TaoGetConvergenceHistory(Tao, PetscReal **, PetscReal **, PetscReal **, PetscInt **, PetscInt *);
439: PETSC_EXTERN PetscErrorCode TaoMonitorSet(Tao, PetscErrorCode (*)(Tao, PetscCtx), PetscCtx, PetscCtxDestroyFn *);
440: PETSC_EXTERN PetscErrorCode TaoMonitorSetFromOptions(Tao, const char[], const char[], const char[], PetscErrorCode (*)(Tao, PetscViewerAndFormat *));
441: PETSC_EXTERN PetscErrorCode TaoMonitorCancel(Tao);
442: PETSC_EXTERN PetscErrorCode TaoMonitorDefault(Tao, PetscViewerAndFormat *);
443: PETSC_EXTERN PetscErrorCode TaoMonitorGlobalization(Tao, PetscViewerAndFormat *);
444: PETSC_EXTERN PetscErrorCode TaoMonitorConstraintNorm(Tao, PetscViewerAndFormat *);
445: PETSC_EXTERN PetscErrorCode TaoMonitorSolution(Tao, PetscViewerAndFormat *);
446: PETSC_EXTERN PetscErrorCode TaoMonitorResidual(Tao, PetscViewerAndFormat *);
447: PETSC_EXTERN PetscErrorCode TaoMonitorGradient(Tao, PetscViewerAndFormat *);
448: PETSC_EXTERN PetscErrorCode TaoMonitorStep(Tao, PetscViewerAndFormat *);
449: PETSC_EXTERN PetscErrorCode TaoMonitorSolutionDraw(Tao, PetscCtx);
450: PETSC_EXTERN PetscErrorCode TaoMonitorStepDraw(Tao, PetscCtx);
451: PETSC_EXTERN PetscErrorCode TaoMonitorGradientDraw(Tao, PetscCtx);
452: PETSC_EXTERN PetscErrorCode TaoAddLineSearchCounts(Tao);
454: PETSC_EXTERN PetscErrorCode TaoDefaultConvergenceTest(Tao, PetscCtx);
455: PETSC_EXTERN PetscErrorCode TaoSetConvergenceTest(Tao, PetscErrorCode (*)(Tao, PetscCtx), PetscCtx);
457: PETSC_EXTERN PetscErrorCode TaoMonitor(Tao, PetscInt, PetscReal, PetscReal, PetscReal, PetscReal);
458: /*S
459: TaoMonitorDrawCtx - Context object for the `Tao` graphical monitor routines that draw convergence information on a `PetscDraw`
461: Level: developer
463: .seealso: `Tao`, `TaoMonitorDrawCtxCreate()`, `TaoMonitorDrawCtxDestroy()`, `TaoMonitorSet()`
464: S*/
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: /*E
470: TaoBRGNRegularizationType - The regularization added in the `TAOBRGN` solver.
472: Values:
473: + TAOBRGN_REGULARIZATION_USER - A user-defined regularizer
474: . TAOBRGN_REGULARIZATION_L2PROX - $\tfrac{1}{2}\|x - x_k\|_2^$, where $x_k$ is the latest solution
475: . TAOBRGN_REGULARIZATION_L2PURE - $\tfrac{1}{2}\|x\|_2^2$
476: . TAOBRGN_REGULARIZATION_L1DICT - $\|D x\|_1$, where $D$ is a dictionary matrix
477: - TAOBRGN_REGULARIZATION_LM - Levenberg-Marquardt, $\tfrac{1}{2} x^T \mathrm{diag}(J^T J) x$, where $J$ is the Jacobian of the least-squares residual
479: Options database Key:
480: . -tao_brgn_regularization_type (l2prox|l2pure|l1dict|lm|user) - select one of the regularization types
482: Level: advanced
484: Notes:
485: If `TAOBRGN_REGULARIZATION_USER`, the regularizer is set either by calling
486: `TaoBRGNSetRegularizerObjectiveAndGradientRoutine()` and
487: `TaoBRGNSetRegulazerHessianRoutine()`
489: If `TAOBRGN_REGULARIZATION_L1DICT`, the dictionary matrix is set with `TaoBRGNSetDictionaryMatrix()` and the smoothing parameter of the
490: approximate $\ell_1$ norm is set with `TaoBRGNSetL1SmoothEpsilon()`.
492: If `TAOBRGN_REGULARIZATION_LM`, the diagonal damping vector $\mathrm{diag}(J^T J)$ can be obtained with `TaoBRGNGetDampingVector()`.
494: .seealso: [](ch_tao), `Tao`, `TaoBRGNGetSubsolver()`, `TaoBRGNSetRegularizerWeight()`, `TaoBRGNSetL1SmoothEpsilon()`, `TaoBRGNSetDictionaryMatrix()`,
495: `TaoBRGNSetRegularizerObjectiveAndGradientRoutine()`, `TaoBRGNSetRegularizerHessianRoutine()`,
496: `TaoBRGNGetRegularizationType()`, `TaoBRGNSetRegularizationType()`
497: E*/
498: typedef enum {
499: TAOBRGN_REGULARIZATION_USER,
500: TAOBRGN_REGULARIZATION_L2PROX,
501: TAOBRGN_REGULARIZATION_L2PURE,
502: TAOBRGN_REGULARIZATION_L1DICT,
503: TAOBRGN_REGULARIZATION_LM,
504: } TaoBRGNRegularizationType;
506: PETSC_EXTERN const char *const TaoBRGNRegularizationTypes[];
508: PETSC_EXTERN PetscErrorCode TaoBRGNGetSubsolver(Tao, Tao *);
509: PETSC_EXTERN PetscErrorCode TaoBRGNGetRegularizationType(Tao, TaoBRGNRegularizationType *);
510: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizationType(Tao, TaoBRGNRegularizationType);
511: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, PetscCtx), PetscCtx);
512: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerHessianRoutine(Tao, Mat, PetscErrorCode (*)(Tao, Vec, Mat, PetscCtx), PetscCtx);
513: PETSC_EXTERN PetscErrorCode TaoBRGNSetRegularizerWeight(Tao, PetscReal);
514: PETSC_EXTERN PetscErrorCode TaoBRGNSetL1SmoothEpsilon(Tao, PetscReal);
515: PETSC_EXTERN PetscErrorCode TaoBRGNSetDictionaryMatrix(Tao, Mat);
516: PETSC_EXTERN PetscErrorCode TaoBRGNGetDampingVector(Tao, Vec *);
518: PETSC_EXTERN PetscErrorCode TaoBNCGSetType(Tao, TaoBNCGType);
519: PETSC_EXTERN PetscErrorCode TaoBNCGGetType(Tao, TaoBNCGType *);
521: PETSC_EXTERN PetscErrorCode TaoADMMGetMisfitSubsolver(Tao, Tao *);
522: PETSC_EXTERN PetscErrorCode TaoADMMGetRegularizationSubsolver(Tao, Tao *);
523: PETSC_EXTERN PetscErrorCode TaoADMMGetDualVector(Tao, Vec *);
524: PETSC_EXTERN PetscErrorCode TaoADMMGetSpectralPenalty(Tao, PetscReal *);
525: PETSC_EXTERN PetscErrorCode TaoADMMSetSpectralPenalty(Tao, PetscReal);
526: PETSC_EXTERN PetscErrorCode TaoGetADMMParentTao(Tao, Tao *);
527: PETSC_EXTERN PetscErrorCode TaoADMMSetConstraintVectorRHS(Tao, Vec);
528: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerCoefficient(Tao, PetscReal);
529: PETSC_EXTERN PetscErrorCode TaoADMMGetRegularizerCoefficient(Tao, PetscReal *);
530: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitConstraintJacobian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
531: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerConstraintJacobian(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
532: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerHessianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
533: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, PetscCtx), PetscCtx);
534: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitHessianRoutine(Tao, Mat, Mat, PetscErrorCode (*)(Tao, Vec, Mat, Mat, PetscCtx), PetscCtx);
535: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitObjectiveAndGradientRoutine(Tao, PetscErrorCode (*)(Tao, Vec, PetscReal *, Vec, PetscCtx), PetscCtx);
536: PETSC_EXTERN PetscErrorCode TaoADMMSetMisfitHessianChangeStatus(Tao, PetscBool);
537: PETSC_EXTERN PetscErrorCode TaoADMMSetRegHessianChangeStatus(Tao, PetscBool);
538: PETSC_EXTERN PetscErrorCode TaoADMMSetMinimumSpectralPenalty(Tao, PetscReal);
539: PETSC_EXTERN PetscErrorCode TaoADMMSetRegularizerType(Tao, TaoADMMRegularizerType);
540: PETSC_EXTERN PetscErrorCode TaoADMMGetRegularizerType(Tao, TaoADMMRegularizerType *);
541: PETSC_EXTERN PetscErrorCode TaoADMMSetUpdateType(Tao, TaoADMMUpdateType);
542: PETSC_EXTERN PetscErrorCode TaoADMMGetUpdateType(Tao, TaoADMMUpdateType *);
544: PETSC_EXTERN PetscErrorCode TaoALMMGetType(Tao, TaoALMMType *);
545: PETSC_EXTERN PetscErrorCode TaoALMMSetType(Tao, TaoALMMType);
546: PETSC_EXTERN PetscErrorCode TaoALMMGetSubsolver(Tao, Tao *);
547: PETSC_EXTERN PetscErrorCode TaoALMMSetSubsolver(Tao, Tao);
548: PETSC_EXTERN PetscErrorCode TaoALMMGetMultipliers(Tao, Vec *);
549: PETSC_EXTERN PetscErrorCode TaoALMMSetMultipliers(Tao, Vec);
550: PETSC_EXTERN PetscErrorCode TaoALMMGetPrimalIS(Tao, IS *, IS *);
551: PETSC_EXTERN PetscErrorCode TaoALMMGetDualIS(Tao, IS *, IS *);
553: PETSC_EXTERN PetscErrorCode TaoSNESGetSNES(Tao, SNES *);
555: PETSC_EXTERN PetscErrorCode TaoVecGetSubVec(Vec, IS, TaoSubsetType, PetscReal, Vec *);
556: PETSC_EXTERN PetscErrorCode TaoMatGetSubMat(Mat, IS, Vec, TaoSubsetType, Mat *);
557: PETSC_EXTERN PetscErrorCode TaoGradientNorm(Tao, Vec, NormType, PetscReal *);
558: PETSC_EXTERN PetscErrorCode TaoEstimateActiveBounds(Vec, Vec, Vec, Vec, Vec, Vec, PetscReal, PetscReal *, IS *, IS *, IS *, IS *, IS *);
559: PETSC_EXTERN PetscErrorCode TaoBoundStep(Vec, Vec, Vec, IS, IS, IS, PetscReal, Vec);
560: PETSC_EXTERN PetscErrorCode TaoBoundSolution(Vec, Vec, Vec, PetscReal, PetscInt *, Vec);
562: PETSC_EXTERN PetscErrorCode MatCreateSubMatrixFree(Mat, IS, IS, Mat *);
564: PETSC_EXTERN PetscErrorCode TaoGetTerm(Tao, PetscReal *, TaoTerm *, Vec *, Mat *);
565: PETSC_EXTERN PetscErrorCode TaoAddTerm(Tao, const char[], PetscReal, TaoTerm, Vec, Mat);
567: #include <petsctao_deprecations.h>