C++/DLProblem/main.cpp

This example shows how to load optimization problems from an external library using dlopen.

This example shows how to load optimization problems from an external library using dlopen.

It solves a simple quadratic program of the form:

\[ \begin{aligned} & \underset{x}{\text{minimize}} && \tfrac12 \tp x Q x \\ & \text{subject to} && Ax \le b \\ \end{aligned} \]

Problem definition in C

#include <alpaqa/dl/dl-problem.h>
#include <problem-c-export.h>
 
#include <stdlib.h>
#include <string.h>
 
#include "matmul.h"
 
typedef alpaqa_real_t real_t;
typedef alpaqa_length_t length_t;
typedef alpaqa_index_t index_t;
 
struct ProblemData {
    real_t *Q;
    real_t *A;
    real_t *work;
 
    alpaqa_problem_functions_t functions;
};
 
static void eval_grad_f(void *instance, const real_t *x, real_t *grad_f) {
    struct ProblemData *problem = instance;
    length_t n                  = problem->functions.n;
    matmul(n, n, 1, problem->Q, x, grad_f); // grad_f = Q x
}
 
static real_t eval_f_grad_f(void *instance, const real_t *x, real_t *grad_f) {
    struct ProblemData *problem = instance;
    length_t n                  = problem->functions.n;
    real_t result;
    eval_grad_f(instance, x, grad_f);
    matmul(1, n, 1, x, grad_f, &result); // result = xᵀ grad_f
    return (real_t)0.5 * result;
}
 
static real_t eval_f(void *instance, const real_t *x) {
    struct ProblemData *problem = instance;
    return eval_f_grad_f(instance, x, problem->work);
}
 
static void eval_g(void *instance, const real_t *x, real_t *gx) {
    struct ProblemData *problem = instance;
    length_t n                  = problem->functions.n;
    length_t m                  = problem->functions.m;
    matmul(m, n, 1, problem->A, x, gx); // gx = A x
}
 
static void eval_grad_g_prod(void *instance, const real_t *x, const real_t *y,
                             real_t *grad_gxy) {
    (void)x;
    struct ProblemData *problem = instance;
    length_t n                  = problem->functions.n;
    length_t m                  = problem->functions.m;
    matvec_transp(m, n, problem->A, y, grad_gxy); // grad_gxy = Aᵀ y
}
 
static void eval_jac_g(void *instance, const real_t *x, real_t *J_values) {
    (void)x;
    struct ProblemData *problem = instance;
    size_t n                    = (size_t)problem->functions.n;
    size_t m                    = (size_t)problem->functions.m;
    memcpy(J_values, problem->A, sizeof(real_t) * m * n);
}
 
static void initialize_box_D(void *instance, real_t *lb, real_t *ub) {
    (void)instance;
    (void)lb; // -inf by default
    ub[0] = -1;
}
 
static struct ProblemData *create_problem(void *user_data) {
    (void)user_data;
    struct ProblemData *problem = malloc(sizeof(*problem));
    size_t n = 2, m = 1;
    problem->functions = (alpaqa_problem_functions_t){
        .n                = (length_t)n,
        .m                = (length_t)m,
        .eval_f           = &eval_f,
        .eval_grad_f      = &eval_grad_f,
        .eval_g           = &eval_g,
        .eval_grad_g_prod = &eval_grad_g_prod,
        .eval_jac_g       = &eval_jac_g,
        .eval_f_grad_f    = &eval_f_grad_f,
        .initialize_box_D = &initialize_box_D,
    };
    problem->Q    = malloc(sizeof(real_t) * n * n);
    problem->A    = malloc(sizeof(real_t) * m * n);
    problem->work = malloc(sizeof(real_t) * n);
    // Note: column major order
    problem->Q[0] = 3;
    problem->Q[1] = -1;
    problem->Q[2] = -1;
    problem->Q[3] = 3;
    problem->A[0] = 2;
    problem->A[1] = 1;
    return problem;
}
 
static void cleanup_problem(void *instance) {
    struct ProblemData *problem = instance;
    free(problem->Q);
    free(problem->A);
    free(problem->work);
    free(problem);
}
 
PROBLEM_C_EXPORT alpaqa_problem_register_t
alpaqa_problem_register(void *user_data) {
    struct ProblemData *problem = create_problem(user_data);
    alpaqa_problem_register_t result;
    ALPAQA_PROBLEM_REGISTER_INIT(&result);
    result.instance  = problem;
    result.cleanup   = &cleanup_problem;
    result.functions = &problem->functions;
    return result;
}

Problem solution using alpaqa

#include <alpaqa/dl/dl-problem.hpp>
#include <alpaqa/problem/problem-with-counters.hpp>
#include <alpaqa/structured-panoc-alm.hpp>
 
#include <filesystem>
#include <iostream>
 
namespace fs = std::filesystem;
 
// Double precision, same as in C
USING_ALPAQA_CONFIG(alpaqa::DefaultConfig);
 
int main(int argc, char *argv[]) {
    // Find the problem to load
    fs::path so_name = DLPROBLEM_DLL;
    if (argc > 1)
        so_name = fs::path(argv[1]);
    else if (argc > 0)
        so_name = fs::canonical(fs::path(argv[0])).parent_path() / so_name;
    std::cout << "Loading " << so_name << std::endl;
 
    // Instantiate a problem
    alpaqa::dl::DLProblem problem{so_name.string()};
    // Wrap the problem to count the function evaluations
    auto counted_problem = alpaqa::problem_with_counters_ref(problem);
 
    // Specify the bounds (optional, overrides any bounds set in problem.c)
    length_t n           = problem.get_n();
    length_t m           = problem.get_m();
    vec b                = vec::Constant(m, -1);
    problem.C.lowerbound = vec::Constant(n, -alpaqa::inf<config_t>);
    problem.C.upperbound = vec::Constant(n, +alpaqa::inf<config_t>);
    problem.D.lowerbound = vec::Constant(m, -alpaqa::inf<config_t>);
    problem.D.upperbound = b;
 
    // Define the solvers to use
    using Direction   = alpaqa::StructuredLBFGSDirection<config_t>;
    using InnerSolver = alpaqa::PANOCSolver<Direction>;
    using OuterSolver = alpaqa::ALMSolver<InnerSolver>;
 
    // Settings for the outer augmented Lagrangian method
    OuterSolver::Params almparam;
    almparam.tolerance             = 1e-8; // tolerance
    almparam.dual_tolerance        = 1e-8;
    almparam.penalty_update_factor = 10; // penalty update factor
    almparam.max_iter              = 20;
    almparam.print_interval        = 1;
 
    // Settings for the inner PANOC solver
    InnerSolver::Params panocparam;
    panocparam.max_iter       = 500;
    panocparam.print_interval = 10;
    // Settings for the L-BFGS algorithm used by PANOC
    Direction::AcceleratorParams lbfgsparam;
    lbfgsparam.memory = 2;
 
    // Create an ALM solver using PANOC as inner solver
    OuterSolver solver{
        almparam,                 // params for outer solver
        {panocparam, lbfgsparam}, // inner solver
    };
 
    // Initial guess
    vec x(2);
    x << 2, 2; // decision variables
    vec y(1);
    y << 1; // Lagrange multipliers
 
    // Solve the problem
    auto stats = solver(counted_problem, x, y);
    // y and x have been overwritten by the solution
 
    // Print the results
    std::cout << '\n' << *counted_problem.evaluations << '\n';
    std::cout << "status: " << stats.status << '\n'
              << "solver: " << solver.get_name() << '\n'
              << "f = " << problem.eval_f(x) << '\n'
              << "inner iterations: " << stats.inner.iterations << '\n'
              << "outer iterations: " << stats.outer_iterations << '\n'
              << "ε = " << stats.ε << '\n'
              << "δ = " << stats.δ << '\n'
              << "elapsed time:     "
              << std::chrono::duration<double>{stats.elapsed_time}.count()
              << " s" << '\n'
              << "x = " << x.transpose() << '\n'
              << "y = " << y.transpose() << '\n'
              << "avg τ = " << (stats.inner.sum_τ / stats.inner.count_τ) << '\n'
              << "L-BFGS rejected = " << stats.inner.lbfgs_rejected << '\n'
              << "L-BFGS failures = " << stats.inner.lbfgs_failures << '\n'
              << "Line search failures = " << stats.inner.linesearch_failures
              << '\n'
              << std::endl;
}