RecordAction

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
• invretr - (default_inverse_retraction_method(manifold)) the inverse retraction to be used for approximating distance.

Additional constructor keyword parameters

• manifold (DefaultManifold(1)) manifold whose default inverse retraction should be used

for approximating the distance.

RecordCost <: RecordAction

record the current cost function value, see get_cost.

RecordEntry{T} <: RecordAction

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

Fields

• 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

Constructors

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

construct a group consisting of an Array of RecordActions g,

RecordGroup(g, symbols)

Examples

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

Constructors

RecordIterate(x0)

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

RecordIterate(P)

initialize the iterate record array to the data type T.

RecordIteration <: RecordAction

record the current iteration

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.

Fields

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

Constructors

RecordOptions(o,dR)

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.

Constructor

RecordTime(; mode::Symbol=:cumulative)

getindex(r::RecordGroup, s::Symbol)
r[s]
getindex(r::RecordGroup, sT::NTuple{N,Symbol})
r[sT]
getindex(r::RecordGroup, i)
r[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)
ro[s]

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...].

RecordActionFactory(s)

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.

RecordFactory(o::Options, a)

given an array of Symbols and RecordActions and Ints

• The symbol :Cost creates a RecordCost
• The symbol :iteration creates a RecordIteration
• The symbol :Change creates a RecordChange
• any other symbol creates a RecordEntry of the corresponding field in Options
• any RecordAction is directly included
• an semantic pair :symbol => RecordAction is directly included
• an Integer k introduces that record is only performed every kth 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.

get_record(r::RecordAction)

return the recorded values stored within a RecordAction r.

get_record(r::RecordGroup)

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.

get_record_action(o::Options, s::Symbol)

return the action contained in the (first) RecordOptions decorator within the Options o.

get_record_options(o::Options)

return the RecordOptions among the decorators from the Options o

has_record(o::Options)

check whether the Optionso are decorated with RecordOptions

record_or_reset!(r,v,i)

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.

initialize_solver!(p,o)

Initialize the solver to the optimization Problem by initializing the encapsulated options from within the RecordOptionso.

step_solver!(p,o,iter)

Do one iteration step (the iterth) for Problemp by modifying the values in the Optionso.options and record the result(s).

stop_solver!(p,o,i)

determine whether the solver for Problem p and the RecordOptions o should stop at iteration i. If so, do a (final) record to :All and :Stop.