# yixuan/LBFGSpp

A header-only C++ library for L-BFGS algorithm
Switch branches/tags
Nothing to show
yixuan Merge pull request #3 from DirkToewe/master
`Added bracketing to LineSearch`
Latest commit 8092658 Nov 7, 2018
Type Name Latest commit message Commit time
Failed to load latest commit information.
doxygen Jul 31, 2016
include Nov 6, 2018
.gitignore Jul 29, 2016
LICENSE.md Aug 4, 2016
README.md Aug 6, 2016
example-quadratic.cpp Aug 6, 2016
example-rosenbrock.cpp Aug 6, 2016
test-rosenbrock.cpp Nov 6, 2018

# LBFGS++

LBFGS++ is a header-only C++ library that implements the Limited-memory BFGS algorithm (L-BFGS) for unconstrained minimization problem. The code is derived and modified from the libLBFGS library developed by Naoaki Okazaki.

LBFGS++ is implemented as a header-only C++ library, whose only dependency, Eigen, is also header-only.

## A Quick Example

To use LBFGS++, one needs to first define a functor to represent the multivariate function to be minimized. It should return the objective function value on a vector `x` and overwrite the vector `grad` with the gradient evaluated on `x`. For example we could define the Rosenbrock function in the following way:

```#include <Eigen/Core>
#include <iostream>
#include <LBFGS.h>

using Eigen::VectorXd;
using namespace LBFGSpp;

class Rosenbrock
{
private:
int n;
public:
Rosenbrock(int n_) : n(n_) {}
double operator()(const VectorXd& x, VectorXd& grad)
{
double fx = 0.0;
for(int i = 0; i < n; i += 2)
{
double t1 = 1.0 - x[i];
double t2 = 10 * (x[i + 1] - x[i] * x[i]);
grad[i + 1] = 20 * t2;
grad[i]     = -2.0 * (x[i] * grad[i + 1] + t1);
fx += t1 * t1 + t2 * t2;
}
return fx;
}
};```

Then we just need to set up parameters, create solver object, provide initial guess, and then run the minimization function.

```int main()
{
const int n = 10;
// Set up parameters
LBFGSParam<double> param;
param.epsilon = 1e-6;
param.max_iterations = 100;

// Create solver and function object
LBFGSSolver<double> solver(param);
Rosenbrock fun(n);

// Initial guess
VectorXd x = VectorXd::Zero(n);
// x will be overwritten to be the best point found
double fx;
int niter = solver.minimize(fun, x, fx);

std::cout << niter << " iterations" << std::endl;
std::cout << "x = \n" << x.transpose() << std::endl;
std::cout << "f(x) = " << fx << std::endl;

return 0;
}```

The example can then be compiled and run.

```\$ g++ -I/path/to/eigen -I/path/to/lbfgspp/include -O2 example.cpp
\$ ./a.out
23 iterations
x =
1 1 1 1 1 1 1 1 1 1
f(x) = 1.87948e-19```

## Documentation

The API reference page contains the documentation of LBFGS++ generated by Doxygen.