LbfgsSolver.hpp

Go to the documentation of this file.

#pragma once

#include <iostream>
#include <Eigen/Dense>
#include <solver/interface/NlpDescription.hpp>

namespace solver {
  enum {
    LBFGS_SUCCESS = 0,
    LBFGS_STOP,
    LBFGS_ALREADY_MINIMIZED,
    LBFGSERR_UNKNOWNERROR = -1024,
    LBFGSERR_LOGICERROR,
    LBFGSERR_OUTOFMEMORY,
    LBFGSERR_INVALID_N,
    LBFGSERR_INVALID_EPSILON,
    LBFGSERR_INVALID_TESTPERIOD,
    LBFGSERR_INVALID_DELTA,
    LBFGSERR_INVALID_LINESEARCH,
    LBFGSERR_INVALID_MINSTEP,
    LBFGSERR_INVALID_MAXSTEP,
    LBFGSERR_INVALID_FTOL,
    LBFGSERR_INVALID_WOLFE,
    LBFGSERR_INVALID_GTOL,
    LBFGSERR_INVALID_XTOL,
    LBFGSERR_INVALID_MAXLINESEARCH,
    LBFGSERR_INVALID_ORTHANTWISE,
    LBFGSERR_INVALID_ORTHANTWISE_START,
    LBFGSERR_INVALID_ORTHANTWISE_END,
    LBFGSERR_OUTOFINTERVAL,
    LBFGSERR_INCORRECT_TMINMAX,
    LBFGSERR_ROUNDING_ERROR,
    LBFGSERR_MINIMUMSTEP,
    LBFGSERR_MAXIMUMSTEP,
    LBFGSERR_MAXIMUMLINESEARCH,
    LBFGSERR_MAXIMUMITERATION,
    LBFGSERR_WIDTHTOOSMALL,
    LBFGSERR_INVALIDPARAMETERS,
    LBFGSERR_INCREASEGRADIENT,
  };

  enum {
    LBFGS_LINESEARCH_DEFAULT = 0,
    LBFGS_LINESEARCH_MORETHUENTE = 0,
    LBFGS_LINESEARCH_BACKTRACKING_ARMIJO = 1,
    LBFGS_LINESEARCH_BACKTRACKING = 2,
    LBFGS_LINESEARCH_BACKTRACKING_WOLFE = 2,
    LBFGS_LINESEARCH_BACKTRACKING_STRONG_WOLFE = 3,
  };

  typedef struct {
    int m;

    double epsilon;

    int past;

    double delta;

    int max_iterations;

    int linesearch;

    int max_linesearch;

    double min_step;

    double max_step;

    double ftol;

    double wolfe;

    double gtol;

    double xtol;
  } lbfgs_parameter_t;


  typedef double (*lbfgs_evaluate_t)(void *instance, const double *x,
    double *g, const int n, const double step);

  typedef int (*lbfgs_progress_t)(void *instance, const double *x,
    const double *g, const double fx, const double xnorm,
    const double gnorm, const double step, int n, int k, int ls);

  /*
  A user must implement a function compatible with ::lbfgs_evaluate_t (evaluation
  callback) and pass the pointer to the callback function to lbfgs() arguments.
  Similarly, a user can implement a function compatible with ::lbfgs_progress_t
  (progress callback) to obtain the current progress (e.g., variables, function
  value, ||G||, etc) and to cancel the iteration process if necessary.
  Implementation of a progress callback is optional: a user can pass \c NULL if
  progress notification is not necessary.

  In addition, a user must preserve two requirements:
    - The number of variables must be multiples of 16 (this is not 4).
    - The memory block of variable array ::x must be aligned to 16.

  This algorithm terminates an optimization
  when:

    ||G|| < \epsilon \cdot \max(1, ||x||) .

  In this formula, ||.|| denotes the Euclidean norm.
  */

  int lbfgs(int n, double *x, double *ptr_fx,
    lbfgs_evaluate_t proc_evaluate, lbfgs_progress_t proc_progress,
    void *instance, lbfgs_parameter_t *param);

  void lbfgs_parameter_init(lbfgs_parameter_t *param);

  double* lbfgs_malloc(int n);

  void lbfgs_free(double *x);

  /*
   *  LBFGS Interface Class
   */
  class LbfgsSolver
  {
    public:
      LbfgsSolver();
      virtual ~LbfgsSolver(){}

      bool initialize(NlpDescription* nlproblem, double constraints_weight = 1.);
      void optimize();

      bool& verbose() { return verbose_; }
      lbfgs_parameter_t& opt_params() { return opt_params_; }

    private:
      // definition of cost evaluation
      static double delegate_evaluate(void *instance, const double *x, double *g, const int n, const double step );
      double evaluate(void *instance, const double *x, double *g, const int n, const double step );
      double evaluate_objective_function(const double* eig_x);

      // definition of how to show progress of the optimization
      static int delegate_progress(void *instance, const double *x, const double *g, const double fx, const double xnorm,
                                   const double gnorm, const double step, int n, int k, int ls );
      int progress(const double *x, const double *g, double fx, double xnorm, double gnorm, int n, int k );

    private:
      NlpDescription* nlproblem_;
      double constraints_weight_;
      bool verbose_, initialized_;
      lbfgs_parameter_t opt_params_;
      int nvars_, ncons_, *user_info_, opt_status_, length_of_address_to_this_;
  };

}