standalone d2_min - optim_doc
Description: optim_doc

Next: bfgsmin, Previous: powell, Up: Scalar optimization

### 1.12 Unconstrained Newton-like minimization, standalone function

This function features a Newton-like algorithm. The user has to supply a Hessian function. No constraints are honoured.

This function is deprecated. It is now available as a backend for `nonlin_min` (see nonlin_min).

#### Helptext:

    [x,v,nev,h,args] = d2_min(f,d2f,args,ctl,code) - Newton-like minimization

    Minimize f(x) using 1st and 2nd derivatives. Any function w/ second
    derivatives can be minimized, as in Newton. f(x) decreases at each
    iteration, as in Levenberg-Marquardt. This function is inspired from the
    Levenberg-Marquardt algorithm found in the book "Numerical Recipes".

    ARGUMENTS :
    f    : string : Cost function's name

    d2f  : string : Name of function returning the cost (1x1), its
                    differential (1xN) and its second differential or it's
                    pseudo-inverse (NxN) (see ctl(5) below) :

                    [v,dv,d2v] = d2f (x).

    args : list   : f and d2f's arguments. By default, minimize the 1st
        or matrix : argument.

    ctl  : vector : Control arguments (see below)
         or struct

    code : string : code will be evaluated after each outer loop that
                    produced some (any) improvement. Variables visible from
                    "code" include "x", the best parameter found, "v" the
                    best value and "args", the list of all arguments. All can
                    be modified. This option can be used to re-parameterize
                    the argument space during optimization

    CONTROL VARIABLE ctl : (optional). May be a struct or a vector of length
    ---------------------- 5 or less where NaNs are ignored. Default values
                           are written <value>.
    FIELD  VECTOR
    NAME    POS

    ftol, f N/A    : Stop search when value doesn't improve, as tested by

                      f > Deltaf/max(|f(x)|,1)

                where Deltaf is the decrease in f observed in the last
                iteration.                                     <10*sqrt(eps)>

    utol, u N/A    : Stop search when updates are small, as tested by

                      u > max { dx(i)/max(|x(i)|,1) | i in 1..N }

                where  dx is the change in the x that occured in the last
                iteration.                                              <NaN>

    dtol, d N/A    : Stop search when derivative is small, as tested by

                      d > norm (dv)                                     <eps>

    crit, c ctl(1) : Set one stopping criterion, 'ftol' (c=1), 'utol' (c=2)
                     or 'dtol' (c=3) to the value of by the 'tol' option. <1>

    tol, t  ctl(2) : Threshold in termination test chosen by 'crit'  <10*eps>

    narg, n ctl(3) : Position of the minimized argument in args           <1>
    maxev,m ctl(4) : Maximum number of function evaluations             <inf>
    maxout,m       : Maximum number of outer loops                      <inf>
    id2f, i ctl(5) : 0 if d2f returns the 2nd derivatives, 1 if           <0>
                     it returns its pseudo-inverse.

    verbose, v N/A : Be more or less verbose (quiet=0)                    <0>