Documentation

HCL_UMin_lbfgs_d implements the limited memory BFGS algorithm for unconstrained minimization. This algorithm is due to Nocedal (see, for example, D. C. Liu and J. Nocedal, ``On the limited memory BFGS method for large scale optimization methods'' Mathematical Programming 45 (1989), pp. 503-528).

The minimization algorithm is based on the limited memory BFGS inverse Hessian approximation (represented by a class, but hidden from the user), and on a line search algorithm.

The line search is represented by an abstract base class, HCL_LineSearch_d; this allows the algorithm to be executed with different choices of the line search algorithm.

The purpose of the algorithm is to take a functional with gradient and a starting guess in the domain of the functional, and to produce a local minimizer via a descent algorithm. If desired, the calling routine may provide a (symmetric positive definite) linear operator (and a corresponding linear solver, if needed) to be used to change the inner product on the solution space. If these are provided, it is assumed that the functional computes the gradient with respect to the default inner product (i.e. the one provided by the vector class).

The primary methods of this class are:

• Minimize, which performs the minimization;
• Parameters,which provides a means of accessing or changing algorithmic parameters which control the iteration. These parameters are typically set initially by passing a file name to the constructor; this file contains parameter values. Any parameters not specified for the constructor are assigned default values. See the documentation of the parameters for more information.
• LastEval, which provides access to the "evaluation" object at the final point.

Use of this minimizer typically involves the following steps:

• Construct functional with gradient, i.e. an object of a class derived from HCL_Functional_d;
• Construct a starting vector in the domain of the functional;
• Construct a line search object, i.e. an object of a class derived from HCL_LineSearch_d;
• Construct the minimizer by passing the constructor the line search object and a parameter file;
• Call the Minimize method;
• Manipulate the value and/or gradient at the approximate minimizer through the LastEval method.

Here's an example:

   MyFcnl f;  // MyFcnl must be derived from HCL\_Functional_d
   MyVector x( "x0" ); // Assume MyVector has a constructor which
                       //reads from a file
   HCL_LineSearch_DS_d lsearch( "lsearch.dat" );  // Dennis-Schnabel
                                                  // line search
   HCL_UMin_lbfgs_d umin( "umin.dat",&lsearch );  // Parameters read
                                                  // from "umin.dat"
   umin.Minimize( f,x );  // Search for local minimum
   cout << "Final value of f: " << umin.LastEval().ValueRef() << endl;
   cout << "Final gradient norm: "
        << umin.LastEval().GradientRef().Norm() << endl;

(If the display flag is turned on, the final function value and gradient norm will be displayed anyway, so the last two lines are not necessary. But they illustrate that the last function value and gradient are stored in case they are needed.)

This class has no child classes.