For most algorithms a certain set of options can either be generated beforehand of the function with keywords can be used. Generally the type


A general super type for all options.


The following fields are assumed to be default. If you use different ones, provide the access functions accordingly


Since the Options directly relate to a solver, they are documented with the corresponding solvers. You can always access the options (since they might be decorated) by calling get_options.

For easier access, and to abstract where these are actually stored, there exists


return the (last stored) iterate within Options`O. By default also undecorates the options beforehand


Decorators for Options

Options can be decorated using the following trait and function to initialize


Indicate internally, whether an Options o to be of decorating type, i.e. it stores (encapsulates) options in itself, by default in the field o. options.

Decorators indicate this by returning Val{true} for further dispatch.

The default is Val{false}, i.e. by default an options is not decorated.


decorate the Optionso with specific decorators.

Optional Arguments

optional arguments provide necessary details on the decorators. A specific one is used to activate certain decorators.

  • debug – (Array{Union{Symbol,DebugAction,String,Int},1}()) a set of symbols representing DebugActions, Strings used as dividers and a subsampling integer. These are passed as a DebugGroup within :All to the DebugOptions decorator dictionary. Only excention is :Stop that is passed to :Stop.
  • record – (Array{Union{Symbol,RecordAction,Int},1}()) specify recordings by using Symbols or RecordActions directly. The integer can again be used for only recording every $i$th iteration.
  • return_options - (false) indicate whether to wrap the options in a ReturnOptions, indicating that the solver should return options and not (only) the minimizer.

See also

DebugOptions, RecordOptions, ReturnOptions


In general decorators often perform actions so we introduce

as well as a helper for storing values using keys, i.e.

StoreTupleAction <: AbstractOptionsAction

internal storage for AbstractOptionsActions to store a tuple of fields from an Optionss

This functor posesses the usual interface of functions called during an iteration, i.e. acts on (p,o,i), where p is a Problem, o is an Options and i is the current iteration.


  • values – a dictionary to store interims values based on certain Symbols
  • keys – an NTuple of Symbols to refer to fields of Options
  • once – whether to update the internal values only once per iteration
  • lastStored – last iterate, where this AbstractOptionsAction was called (to determine once


StoreOptionsAction([keys=(), once=true])

Initialize the Functor to an (empty) set of keys, where once determines whether more that one update per iteration are effective

StoreOptionsAction(keys, once=true])

Initialize the Functor to a set of keys, where the dictionary is initialized to be empty. Further, once determines whether more that one update per iteration are effective, otherwise only the first update is stored, all others are ignored.


A simple example is the

as well as DebugOptions and RecordOptions.