The solver interface functions

decorate_objective!(M, o::AbstractManifoldObjective; kwargs...)

Decorate the AbstractManifoldObjective o with specific decorators.

Optional arguments

The optional arguments provide necessary details on the decorators; providing one of them activates the corresponding decorator.

• cache=missing: specify a cache. Currently :Simple is supported and :LRU if you load LRUCache.jl. For this case a tuple specifying what to cache and how many entries to keep has to be provided. For example (:LRU, [:Cost, :Gradient], 10) states that the last 10 used cost function evaluations and gradient evaluations should be stored. See objective_cache_factory for details.
• count=missing: specify which calls to the objective should be counted, see ManifoldCountObjective for the full list.
• objective_type=:Riemannian: specify that an objective is :Riemannian or :Euclidean. The :Euclidean symbol is equivalent to specifying it as :Embedding, since in the end, both refer to converting an objective from the embedding (whether it is Euclidean or not) to the Riemannian one.
• return_objective=false: indicate whether to wrap the objective in a ReturnManifoldObjective, indicating that the solver should return the objective as well.

See also

objective_cache_factory

decorate_state!(s::AbstractManoptSolverState; kwargs...)

Decorate the AbstractManoptSolverState s with specific decorators.

Optional arguments

The optional arguments provide necessary details on the decorators.

• callback=missing: (deprecated) add an arbitrary (simple) callback function cb() to be called every iteration.
• debug=Array{Union{Symbol,DebugAction,String,Int, Function},1}(): a set of symbols representing DebugActions, Strings used as dividers and a sub-sampling integer. These are passed as a DebugGroup within :Iteration to the DebugSolverState decorator dictionary. A function is added as a (non-simple) callback within a DebugCallback. Only exception is :Stop that is passed to :Stop.
• record=Array{Union{Symbol,RecordAction,Int},1}(): specify recordings by using Symbols or RecordActions directly. An integer can again be used for only recording every $k$-th iteration.
• return_state=false: indicate whether to wrap the state in a ReturnSolverState, indicating that the solver should return the state and not (only) the minimizer.

All other keywords are ignored.

See also

DebugSolverState, RecordSolverState, ReturnSolverState

get_cost(p::AbstractManoptProblem, s::AbstractManoptSolverState)

Get cost at the current iterate of the solver state s for the problem p. The method may be implemented by particular solvers if they store the cost at the current iterate in the state, but by default it is obtained by calling get_cost(p, get_iterate(s)).

initialize_solver!(amp::AbstractManoptProblem, ams::AbstractManoptSolverState)

Initialize the solver to the optimization AbstractManoptProblem amp by initializing the necessary values in the AbstractManoptSolverState ams.

solve!(problem::AbstractManoptProblem, state::AbstractManoptSolverState)

Run the solver implemented for the AbstractManoptProblem problem and the AbstractManoptSolverState state employing initialize_solver!, step_solver!, as well as the stop_solver! of the solver.

This includes the callbacks :BeforeInit, :Init, :BeforeStep, :Step, and :Stop.

step_solver!(amp::AbstractManoptProblem, ams::AbstractManoptSolverState, k)

Do one iteration step (the k-th) for an AbstractManoptProblem amp by modifying the values in the AbstractManoptSolverState ams.

stop_solver!(amp::AbstractManoptProblem, ams::AbstractManoptSolverState, k)

Determine whether the solver should stop.

Depending on the current AbstractManoptProblem amp, the current state of the solver stored in AbstractManoptSolverState ams and the current iteration k, this by default calls the internal StoppingCriterion ams.stop.

This includes a callback :BeforeStop.

ClosedFormSubSolverState <: AbstractManoptSolverState

Subsolver state indicating that a closed-form solution is available.

Constructor

ClosedFormSubSolverState()

ReturnSolverState{O<:AbstractManoptSolverState} <: AbstractManoptSolverState

This internal type is used to indicate that the contained AbstractManoptSolverState state should be returned at the end of a solver instead of the usual minimizer.

See also

get_solver_result

get_solver_return(s::ReturnSolverState)
get_solver_return(o::AbstractManifoldObjective, s::ReturnSolverState)

Determine the solver return.

Return the internally stored state of the ReturnSolverState instead of the minimizer.

Since a solver might return both a state and an objective in a tuple, this then re-iterates on the second argument.