## SYMMLQ

Krylov.symmlqFunction
(x, stats) = symmlq(A, b::AbstractVector{FC}; window::Int=0,
M=I, λ::T=zero(T), transfer_to_cg::Bool=true,
λest::T=zero(T), atol::T=√eps(T), rtol::T=√eps(T),
etol::T=√eps(T), itmax::Int=0, conlim::T=1/√eps(T),
verbose::Int=0, history::Bool=false,
ldiv::Bool=false, callback=solver->false)

T is an AbstractFloat such as Float32, Float64 or BigFloat. FC is T or Complex{T}.

Solve the shifted linear system

(A + λI) x = b

using the SYMMLQ method, where λ is a shift parameter, and A is square and symmetric.

SYMMLQ produces monotonic errors ‖x* - x‖₂.

A preconditioner M may be provided in the form of a linear operator and is assumed to be symmetric and positive definite.

SYMMLQ can be warm-started from an initial guess x0 with

(x, stats) = symmlq(A, b, x0; kwargs...)

where kwargs are the same keyword arguments as above.

The callback is called as callback(solver) and should return true if the main loop should terminate, and false otherwise.

Reference

source

## MINRES

Krylov.minresFunction
(x, stats) = minres(A, b::AbstractVector{FC};
M=I, λ::T=zero(T), atol::T=√eps(T)/100,
rtol::T=√eps(T)/100, ratol :: T=zero(T),
rrtol :: T=zero(T), etol::T=√eps(T),
window::Int=5, itmax::Int=0,
conlim::T=1/√eps(T), verbose::Int=0,
history::Bool=false, ldiv::Bool=false,
callback=solver->false)

T is an AbstractFloat such as Float32, Float64 or BigFloat. FC is T or Complex{T}.

Solve the shifted linear least-squares problem

minimize ‖b - (A + λI)x‖₂²

or the shifted linear system

(A + λI) x = b

using the MINRES method, where λ ≥ 0 is a shift parameter, where A is square and symmetric.

MINRES is formally equivalent to applying CR to Ax=b when A is positive definite, but is typically more stable and also applies to the case where A is indefinite.

MINRES produces monotonic residuals ‖r‖₂ and optimality residuals ‖Aᴴr‖₂.

A preconditioner M may be provided in the form of a linear operator and is assumed to be symmetric and positive definite.

MINRES can be warm-started from an initial guess x0 with

(x, stats) = minres(A, b, x0; kwargs...)

where kwargs are the same keyword arguments as above.

The callback is called as callback(solver) and should return true if the main loop should terminate, and false otherwise.

Reference

source

## MINRES-QLP

Krylov.minres_qlpFunction
(x, stats) = minres_qlp(A, b::AbstractVector{FC};
M=I, atol::T=√eps(T), rtol::T=√eps(T),
ctol::T=√eps(T), λ::T=zero(T), itmax::Int=0,
verbose::Int=0, history::Bool=false,
ldiv::Bool=false, callback=solver->false)

T is an AbstractFloat such as Float32, Float64 or BigFloat. FC is T or Complex{T}.

MINRES-QLP is the only method based on the Lanczos process that returns the minimum-norm solution on singular inconsistent systems (A + λI)x = b, where λ is a shift parameter. It is significantly more complex but can be more reliable than MINRES when A is ill-conditioned.

A preconditioner M may be provided in the form of a linear operator and is assumed to be symmetric and positive definite. M also indicates the weighted norm in which residuals are measured.

MINRES-QLP can be warm-started from an initial guess x0 with

(x, stats) = minres_qlp(A, b, x0; kwargs...)

where kwargs are the same keyword arguments as above.

The callback is called as callback(solver) and should return true if the main loop should terminate, and false otherwise.

References

source