Problem Formulation

PIQP expects QP of the form

with primal decision variables \(x \in \mathbb{R}^n\), matrices \(P\in \mathbb{S}_+^n\), \(A \in \mathbb{R}^{p \times n}\), \(G \in \mathbb{R}^{m \times n}\), and vectors \(c \in \mathbb{R}^n\), \(b \in \mathbb{R}^p\), \(h \in \mathbb{R}^m\), \(x_{lb} \in \mathbb{R}^n\), and \(x_{ub} \in \mathbb{R}^n\).

PIQP can handle infinite box constraints well, i.e. when elements of \(x_{lb}\) or \(x_{ub}\) are \(-\infty\) or \(\infty\), respectively. On the contrary, infinite values in the general inequalities \(Gx \leq h = \pm \infty\) can cause problems, i.e., they are converted internally to -1e30 and 1e30, respectively.

Example QP

In the following the C++ interface of PIQP will be introduced using the following example QP problem:

Problem Data

PIQP supports dense and sparse problem formulations. For small and dense problems the dense interface is preferred since vectorized instructions and cache locality can be exploited more efficiently, but for sparse problems the sparse interface and result in significant speedups.

To include the C interface of PIQP include the following headers

#include "stdlib.h"
#include "piqp.h"

stdlib.h is later needed to allocate necessary structs.

We can then define the problem data as

piqp_int n = 2;
piqp_int p = 1;
piqp_int m = 2;

piqp_float P[4] = {6, 0, 0, 4};
piqp_float c[2] = {-1, -4};

piqp_float A[2] = {1, -2};
piqp_float b[1] = {1};

piqp_float G[4] = {1, -1, 2, 0};
piqp_float h[2] = {0.2, -1};

piqp_float x_lb[2] = {-1, -PIQP_INF};
piqp_float x_ub[2] = {1, PIQP_INF};

piqp_data_sparse* data = (piqp_data_sparse*) malloc(sizeof(piqp_data_sparse));
data->n = n;
data->p = p;
data->m = m;
data->P = P;
data->c = c;
data->A = A;
data->b = b;
data->G = G;
data->h = h;
data->x_lb = x_lb;
data->x_ub = x_ub;

Here PIQP_INF represents \(\infty\), and we store the whole problem in the data struct.

For the sparse interface \(P\), \(A\), and \(G\) have to be in compressed sparse column (CSC) format.

piqp_float P_x[2] = {6, 4};
piqp_int P_nnz = 2;
piqp_int P_p[3] = {0, 1, 2};
piqp_int P_i[2] = {0, 1};

piqp_float A_x[2] = {1, -2};
piqp_int A_nnz = 2;
piqp_int A_p[3] = {0, 1, 2};
piqp_int A_i[2] = {0, 0};

piqp_float G_x[3] = {1, 2, -1};
piqp_int G_nnz = 3;
piqp_int G_p[3] = {0, 2, 3};
piqp_int G_i[4] = {0, 1, 0};

data->P = piqp_csc_matrix(data->n, data->n, P_nnz, P_p, P_i, P_x);
data->A = piqp_csc_matrix(data->p, data->n, A_nnz, A_p, A_i, A_x);
data->G = piqp_csc_matrix(data->m, data->n, G_nnz, G_p, G_i, G_x);

piqp_csc_matrix(...) is a helper function allocating a piqp_csc struct and filling its fields accordingly.

Settings

To set custom settings, a piqp_settings struct has to be instantiated and the default settings have to be set:

piqp_settings* settings = (piqp_settings*) malloc(sizeof(piqp_settings));

piqp_set_default_settings(settings);
settings->verbose = 1;
settings->compute_timings = 1;

In this example we enable the verbose output and internal timings. The full set of configuration options can be found here.

Solving the Problem

We can now set up the problem using

// workspace
piqp_workspace* work;
// dense interface
piqp_setup_dense(&work, data, settings);
// or sparse interface
piqp_setup_sparse(&work, data, settings);

The data is internally copied, and the solver initializes all internal data structures. Note that the settings field is optional and NULL can be passed.

Now, the problem can be solver using

piqp_status status = piqp_solve(work);

Status code

Extracting the Result

The result of the optimization can be obtained from the work->result struct. More specifically, the most important information includes

• work->result->x: primal solution
• work->result->y: dual solution of equality constraints
• work->result->z: dual solution of inequality constraints
• work->result->z_lb: dual solution of lower bound box constraints
• work->result->z_ub: dual solution of upper bound box constraints
• work->result->info.primal_obj: primal objective value
• work->result->info.run_time: total runtime

Timing information like work->result->info.run_time is only measured if settings->compute_timings is set to 1.