Record values

To record values during the iterations of a solver run, there are in general two possibilities. On the one hand, the high-level interfaces provide a record= keyword, that accepts several different inputs. For more details see How to record.

For example recording the gradient from the GradientDescentOptions is automatically available, as explained in the gradient_descent solver.

Record Options


A RecordAction is a small functor to record values. The usual call is given by (p,o,i) -> s that performs the record based on a Problem p, Options o and the current iterate i.

By convention i<=0 is interpreted as "For Initialization only", i.e. only initialize internal values, but not trigger any record, the same holds for i=typemin(Inf) which is used to indicate stop, i.e. that the record is called from within stop_solver! which returns true afterwards.

Fields (assumed by subtypes to exist)

  • recorded_values an Array of the recorded values.
RecordChange <: RecordAction

debug for the amount of change of the iterate (stored in o.x of the Options) during the last iteration.

Additional Fields

  • storage a StoreOptionsAction to store (at least) o.x to use this as the last value (to compute the change)
RecordEntry{T} <: RecordAction

record a certain fields entry of type {T} during the iterates


  • recorded_values – the recorded Iterates
  • field – Symbol the entry can be accessed with within Options
RecordEntryChange{T} <: RecordAction

record a certain entries change during iterates

Additional Fields

  • recorded_values – the recorded Iterates
  • field – Symbol the field can be accessed with within Options
  • distance – function (p,o,x1,x2) to compute the change/distance between two values of the entry
  • storage – a StoreOptionsAction to store (at least) getproperty(o, d.field)
RecordEvery <: RecordAction

record only every $i$th iteration. Otherwise (optionally, but activated by default) just update internal tracking values.

This method does not perform any record itself but relies on it's childrens methods

RecordGroup <: RecordAction

group a set of RecordActions into one action, where the internal RecordActions act independently, but the results can be collected in a grouped fashion, i.e. tuples per calls of this group. The enries can be later addressed either by index or semantic Symbols


RecordGroup(g::Array{<:RecordAction, 1})

construct a group consisting of an Array of RecordActions g,

RecordGroup(g, symbols)


r = RecordGroup([RecordIteration(), RecordCost()])

A RecordGroup to record the current iteration and the cost. The cost can then be accessed using get_record(r,2) or r[2].

r = RecordGroup([RecordIteration(), RecordCost()], Dict(:Cost => 2))

A RecordGroup to record the current iteration and the cost, wich can then be accesed using get_record(:Cost) or r[:Cost].

r = RecordGroup([RecordIteration(), :Cost => RecordCost()])

A RecordGroup identical to the previous constructor, just a little easier to use.

RecordIterate <: RecordAction

record the iterate



initialize the iterate record array to the type of x0, e.g. your initial data.


initialize the iterate record array to the data type T.

RecordOptions <: Options

append to any Options the decorator with record functionality, Internally a Dictionary is kept that stores a RecordAction for several concurrent modes using a Symbol as reference. The default mode is :Iteration, which is used to store information that is recorded during the iterations. RecordActions might be added to :Start or :Stop to record values at the beginning or for the stopping time point, respectively

The original options can still be accessed using the get_options function.


  • options – the options that are extended by debug information
  • recordDictionary – a Dict{Symbol,RecordAction} to keep track of all different recorded values



construct record decorated Options, where dR can be

  • a RecordAction, then it is stored within the dictionary at :Iteration
  • an Array of RecordActions, then it is stored as a recordDictionary(@ref) within the dictionary at :All.
  • a Dict{Symbol,RecordAction}.
RecordTime <: RecordAction

record the time elapsed during the current iteration.

The three possible modes are

  • :cumulative record times without resetting the timer
  • :iterative record times with resetting the timer
  • :total record a time only at the end of an algorithm (see stop_solver!)

The default is :cumulative, and any non-listed symbol default to using this mode.


RecordTime(; mode::Symbol=:cumulative)
getindex(r::RecordGroup, s::Symbol)
getindex(r::RecordGroup, sT::NTuple{N,Symbol})
getindex(r::RecordGroup, i)

return an array of recorded values with respect to the s, the symbols from the tuple sT or the index i. See get_record for details.

get_index(ro::RecordOptions, s::Symbol)

Get the recorded values for reording type s, see get_record for details.

get_index(ro::RecordOptions, s::Symbol, i...)
ro[s, i...]

Acces the recording type of type s and call its RecordAction with [i...].


create a RecordAction where

  • a RecordAction is passed through
  • a [Symbol] creates RecordEntry of that symbol, with the exceptions of
    • :Change - to recorde the change of the iterates in o.x`
    • :Iterate - to record the iterate
    • :Iteration - to record the current iteration numner
    • :Cost - to record the current cost function value
    • :Time - to record the total time taken after every iteration
    • :IterativeTime – to record the times taken for each iteration.
get_record(o::Options, [,s=:Iteration])
get_record(o::RecordOptions, [,s=:Iteration])

return the recorded values from within the RecordOptions o that where recorded with respect to the Symbol s as an Array. The default refers to any recordings during an :Iteration.

When called with arbitrary Options, this method looks for the RecordOptions decorator and calls get_record on the decorator.


return an array of tuples, where each tuple is a recorded set, e.g. per iteration / record call.

get_record(r::RecordGruop, i::Int)

return an array of values corresponding to the ith entry in this record group

get_record(r::RecordGruop, s::Symbol)

return an array of recorded values with respect to the s, see RecordGroup.

get_record(r::RecordGroup, s1::Symbol, s2::Symbol,...)

return an array of tuples, where each tuple is a recorded set corresponding to the symbols s1, s2,... per iteration / record call.


either record (i>0 and not Inf) the value v within the RecordAction r or reset (i<0) the internal storage, where v has to match the internal value type of the corresponding Recordaction.


see recording values for details on the decorated solver.

Further specific RecordActions can be found when specific types of Options define them on their corresponding site.

Technical Details: The Record Solver