`FirstOrderSolvers.Dykstra`

— TypeDykstra

`FirstOrderSolvers.FISTA`

— TypeFISTA

`FirstOrderSolvers.GAP`

— TypeGAP

`FirstOrderSolvers.GAPA`

— Type`GAPA(α=1.0, β=0.0; kwargs...)`

`

GAP Adaptive Same as GAP but with adaptive `α1,α2`

set to optimal `αopt=2/(1+sinθ)`

according to the estimate of the Friedrischs angle `θ`

. `β`

is averaging factor between `αopt`

and `2`

: `α1=α2= (1-β)*αopt + β*2.0`

.

`FirstOrderSolvers.GAPP`

— TypeGAPP projected GAP Defaults to direct solve of the linear system

`FirstOrderSolvers.AffinePlusLinear`

— TypeRepresentation of the function `f([x;z]) = q'x+i(Ax-βz==b)`

where `β`

is `1`

or `-1`

.

`FirstOrderSolvers.DualConeProduct`

— TypeIndicator of K2×K1*×R+ × K2*×K1×R+ ∈ (R^n,R^m,R)^2

`FirstOrderSolvers.HSDEMatrix`

— MethodHSDEMatrix(Q::HSDEMatrixQ)

`FirstOrderSolvers.HSDEMatrix`

— MethodHSDEMatrix(A::M, b::V, c::V) where {T,M<:AbstractMatrix{T},V<:AbstractVector{T}}

`FirstOrderSolvers.HSDEMatrixQ`

— MethodHSDEMatrixQ(A::M, b::V, c::V) where {T,M<:AbstractMatrix{T},V<:AbstractVector{T}}

`FirstOrderSolvers.KKTMatrix`

— TypeRepresentation of the matrix [I A'; A -I]

`FirstOrderSolvers.addprojineq`

— MethodSaves inequalities as equality for now

`FirstOrderSolvers.checkstatus`

— Methodcheckstatus(stat::FeasibilityStatus, x) Returns `false`

if no check was made If convergence check is done, returns `true`

and sets stat.status to one of: :Continue, :Optimal, :Infeasible

`FirstOrderSolvers.checkstatus`

— Methodcheckstatus(stat::HSDEStatus, x) Returns `false`

if no check was made If convergence check is done, returns `true`

and sets stat.status to one of: :Continue, :Optimal, :Unbounded, :Infeasible

`FirstOrderSolvers.conjugategradient!`

— Method`conjugategradient!(x,A,b,r,p,Ap; tol = size(A,2)*eps(), max_iters = 10000)`

Solve `A*x==b`

with the conjugate gradient method. Uses `x`

as warm start and stores solution in `x`

. `r`

,`p`

,`Ap`

should be same size as `x`

and will be changed.

Implemented as in "Matrix Compuatations" 2nd edition, Golub and Van Loan (1989)

`FirstOrderSolvers.get_sets_and_status`

— Method``S1, S2, n, status_generator = get_sets_and_status(alg::FOSAlgorithm, model::FOSMathProgModel)``

Get the sets S1, S2 and their size n

`FirstOrderSolvers.get_sets_and_status`

— Method``S1, S2, n, status_generator = get_sets_and_status(alg::FOSAlgorithm, model::FOSMathProgModel)``

Get the sets S1, S2 and their size n

`FirstOrderSolvers.normedScalar`

— MethodnormedScalar(x1,x2,y1,y2) Calculate |<x1-x2,y1-y2>|/(||x1-x2||*||y1-y2||)

`FirstOrderSolvers.support_linesearch`

— MethodLine search types: Val{:False} : No line search available

Val{:True} : Line search available, but at the cost of extra evaluations Should provide an nonexpansive operator `y=T(x)`

as `T!(y, alg<:FOSAlgorithm, data<:FOSSolverData, x, i, status, longstep)`

so the algorithm becomes `x^(k+1) = (1-αk)x^k = αk*T(x^k)`

Val{:Fast} : Line search available with low extra cost Should provide two operators `y=S1(x)`

, `z=S2(y)`

as `S1!(y, alg<:FOSAlgorithm, data<:FOSSolverData, x, i, status, longstep)`

`S2!(y, alg<:FOSAlgorithm, data<:FOSSolverData, x, i, status, longstep)`

so the algorithm becomes `x^(k+1) = (1-αk)x^k = αk*S2(S1(x^k))`

`S1`

has to be an affine operator, i.e. S1(x+y)+S1(0)=S1(x)+S2(y).

`ProximalOperators.prox!`

— Method`solve argmin_y{||x-y||₂}, s.t. Q*u==v, where [u;v] == x`