Docstrings · FastLevenbergMarquardt.jl

FastLevenbergMarquardt.lmsolve — Function

lmsolve(
    fun,
    jac,
    x0::StaticVector{N, <:AbstractFloat},
    data = nothing,
    lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing,
    ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing;
    kwargs...
) -> x, F, info, iter, nfev, njev

lmsolve!(
    fun!,
    jac!,
    x0::AbstractVector{<:AbstractFloat},
    m::Integer = length(x0),
    data = nothing,
    lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing,
    ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing;
    kwargs...,
) -> x, F, info, iter, nfev, njev, LM, solver

lmsolve!(
    fun!,
    jac!,
    x0::AbstractVector{<:AbstractFloat},
    f::AbstractVector{<:AbstractFloat},
    J::AbstractMatrix{<:AbstractFloat},
    data = nothing,
    lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing,
    ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing;
    kwargs...,
) -> x, F, info, iter, nfev, njev, LM, solver

lmsolve!(
    fun!,
    jac!,
    LM::LMWorkspace,
    data = nothing,
    lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing,
    ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing;
    kwargs...
) -> x, F, info, iter, nfev, njev, LM, solver

Minimize F(x) = ||f(x)||^2 using the Levenberg-Marquardt algorithm.

Arguments

fun/fun!: function to be minimized ||f||^2, f = fun(x, data), f = fun!(f, x, data)
jac/jac!: jacobian of f, J = jac(x, data), J = jac!(J, x, data)
x0::AbstractVector{<:AbstractFloat}: initial guess
m::Integer = length(x0): number of function values
data = nothing: data passed to fun/fun! and jac/jac!
f::AbstractVector{<:AbstractFloat}: preallocated function vector
J::AbstractMatrix{<:AbstractFloat}: preallocated Jacobian matrix
LM::LMWorkspace: preallocated workspace
lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing: lower bounds for x. Vectors must have same length as x
ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing: upper bounds for x. Vectors must have same length as x

Keywords

solver::Union{Nothing, Symbol} = nothing: linear solver for lmsolve! (lmsolve always uses Cholesky factorization)
- nothing: QR for dense Jacobian, Cholesky for sparse Jacobian
- :cholesky: Cholesky factorization
- :qr: QR factorization
ftol::Real = eps(eltype(x)): relative tolerance for function: both actual and predicted reductions are less than ftol
xtol::Real = 1e-10: relative tolerance for change in x: all(abs(x - xk) < xtol * (xtol + abs(x)))
gtol::Real = eps(eltype(x)): tolerance for gradient: norm(g, Inf) < gtol
maxit::Integer = 1000: maximum number of iterations
factor::Real = 1e-6: initial factor for damping
factoraccept::Real = 13: factor for decreasing damping on good step
factorreject::Real = 3: factor for increasing damping on bad step
factorupdate::Symbol = :marquardt: factor update method ∈ (:marquardt, :nielsen)
minscale::Real = 1e-12: diagonal scaling lower bound
maxscale::Real = 1e16: diagonal scaling upper bound
minfactor::Real = 1e-28: damping factor lower bound
maxfactor::Real = 1e32: damping factor upper bound

Returns

x/LM.x: solution
F: final objective
info::Int: convergence status
- 1: both actual and predicted reductions are less than ftol
- 2: relative difference between two consecutive iterates is less than xtol
- 3: inf norm of the gradient is less than gtol
- -1: maxit reached
iter::Int: number of iterations
nfev::Int: number of function evaluations
njev::Int: number of Jacobian evaluations
LM::LMWorkspace: workspace
solver::AbstractSolver: solver

Notes

In the returned LMWorkspace, only LM.x and LM.f are guaranteed to be updated. That is, LM.J might not be the Jacobian at the returned x.

FastLevenbergMarquardt.lmsolve! — Function

lmsolve(
    fun,
    jac,
    x0::StaticVector{N, <:AbstractFloat},
    data = nothing,
    lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing,
    ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing;
    kwargs...
) -> x, F, info, iter, nfev, njev

lmsolve!(
    fun!,
    jac!,
    x0::AbstractVector{<:AbstractFloat},
    m::Integer = length(x0),
    data = nothing,
    lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing,
    ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing;
    kwargs...,
) -> x, F, info, iter, nfev, njev, LM, solver

lmsolve!(
    fun!,
    jac!,
    x0::AbstractVector{<:AbstractFloat},
    f::AbstractVector{<:AbstractFloat},
    J::AbstractMatrix{<:AbstractFloat},
    data = nothing,
    lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing,
    ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing;
    kwargs...,
) -> x, F, info, iter, nfev, njev, LM, solver

lmsolve!(
    fun!,
    jac!,
    LM::LMWorkspace,
    data = nothing,
    lb::Union{Nothing, Real, AbstractVector{<:Real}} = nothing,
    ub::Union{Nothing, Real, AbstractVector{<:Real}} = nothing;
    kwargs...
) -> x, F, info, iter, nfev, njev, LM, solver