CasADi/Rosenbrock/main.cpp

This example shows how to generate a problem using CasADi and how to load and solve it using alpaqa.

Problem generation using CasADi

from casadi import SX, Function, CodeGenerator, vertcat, jtimes, gradient
from sys import argv
 
if len(argv) < 2:
    print(f"Usage:    {argv[0]} <name>")
    exit(0)
 
x = SX.sym("x")
y = SX.sym("y")
z = SX.sym("z")
unknwns = vertcat(x, y, z)
 
w = SX.sym("w")
 
# Formulate the NLP
f = x**2 + 100*z**2
g = z + (1-x)**2 - y
 
cg = CodeGenerator(f"{argv[1]}.c")
cg.add(Function("f", [unknwns], 
                [f], 
                ["x"], ["f"]))
cg.add(Function("grad_f", [unknwns], 
                [gradient(f, unknwns)],
                ["x"], ["grad_f"]))
cg.add(Function("g", [unknwns],
                [g],
                ["x"], ["g"]))
cg.add(Function("grad_g", [unknwns, w],
                [jtimes(g, unknwns, w, True)],
                ["x", "w"], ["grad_g"]))
cg.generate()

Problem solution using alpaqa

/** 
 * @example CasADi/Rosenbrock/main.cpp
 *
 * This example shows how to generate a problem using CasADi and how to load
 * and solve it using alpaqa.
 *
 * # Problem generation using CasADi
 * @include CasADi/Rosenbrock/codegen-rosenbrock.py
 * # Problem solution using alpaqa
 */
 
#include <alpaqa/decl/alm.hpp>
#include <alpaqa/inner/decl/panoc.hpp>
#include <alpaqa/inner/directions/decl/lbfgs.hpp>
 
#include <alpaqa/interop/casadi/CasADiLoader.hpp>
 
#include <iostream>
 
int main(int argc, char *argv[]) {
    using alpaqa::inf;
    using alpaqa::vec;
 
    auto so_name = "examples/CasADi/Rosenbrock/librosenbrock_functions.so";
    if (argc > 1)
        so_name = argv[1];
 
    // Load the problem (with 3 decision variables and 1 general constraint)
    alpaqa::Problem p = alpaqa::load_CasADi_problem(so_name, 3, 1);
 
    // Specify the bounds
    p.C.upperbound = vec::Constant(3, inf);
    p.C.lowerbound = vec::Constant(3, -inf);
    p.D.upperbound = vec::Constant(1, 0.);
    p.D.lowerbound = vec::Constant(1, 0.);
 
    // Settings for the outer augmented Lagrangian method
    alpaqa::ALMParams almparam;
    almparam.ε              = 1e-8; // tolerance
    almparam.δ              = 1e-8;
    almparam.Δ              = 10;
    almparam.max_iter       = 20;
    almparam.print_interval = 1;
 
    // Settings for the inner PANOC solver
    alpaqa::PANOCParams panocparam;
    panocparam.max_iter       = 500;
    panocparam.print_interval = 10;
    // Settings for the L-BFGS algorithm used by PANOC
    alpaqa::LBFGSParams lbfgsparam;
    lbfgsparam.memory = 10;
 
    // Create an ALM solver using PANOC as inner solver
    alpaqa::ALMSolver<alpaqa::PANOCSolver<>> solver{
        almparam,                 // params for outer solver
        {panocparam, lbfgsparam}, // inner solver
    };
 
    // Initial guess
    vec x(3);
    x << 2.5, 3.0, 0.75;
    vec y(1);
    y << 1;
 
    // Solve the problem
    auto stats = solver(p, y, x);
 
    // Print the results
    vec g(p.m);
    p.g(x, g);
    std::cout << "status: " << stats.status << std::endl;
    std::cout << "x = " << x.transpose() << std::endl;
    std::cout << "y = " << y.transpose() << std::endl;
    std::cout << "g = " << g.transpose() << std::endl;
    std::cout << "f = " << p.f(x) << std::endl;
    std::cout << "inner: " << stats.inner.iterations << std::endl;
    std::cout << "outer: " << stats.outer_iterations << std::endl;
}