Update matrices

Consider the following QP

\[\begin{split}\begin{array}{ll} \mbox{minimize} & \frac{1}{2} x^T \begin{bmatrix}4 & 1\\ 1 & 2 \end{bmatrix} x + \begin{bmatrix}1 \\ 1\end{bmatrix}^T x \\ \mbox{subject to} & \begin{bmatrix}1 \\ 0 \\ 0\end{bmatrix} \leq \begin{bmatrix} 1 & 1\\ 1 & 0\\ 0 & 1\end{bmatrix} x \leq \begin{bmatrix}1 \\ 0.7 \\ 0.7\end{bmatrix} \end{array}\end{split}\]

We show below how to setup and solve the problem. Then we update the matrices \(P\) and \(A\) and solve the updated problem

\[\begin{split}\begin{array}{ll} \mbox{minimize} & \frac{1}{2} x^T \begin{bmatrix}5 & 1.5\\ 1.5 & 1 \end{bmatrix} x + \begin{bmatrix}1 \\ 1\end{bmatrix}^T x \\ \mbox{subject to} & \begin{bmatrix}1 \\ 0 \\ 0\end{bmatrix} \leq \begin{bmatrix} 1.2 & 1.1\\ 1.5 & 0\\ 0 & 0.8\end{bmatrix} x \leq \begin{bmatrix}1 \\ 0.7 \\ 0.7\end{bmatrix} \end{array}\end{split}\]

Python

import osqp
import numpy as np
from scipy import sparse

# Define problem data
P = sparse.csc_matrix([[4, 1], [1, 2]])
q = np.array([1, 1])
A = sparse.csc_matrix([[1, 1], [1, 0], [0, 1]])
l = np.array([1, 0, 0])
u = np.array([1, 0.7, 0.7])

# Create an OSQP object
prob = osqp.OSQP()

# Setup workspace
prob.setup(P, q, A, l, u)

# Solve problem
res = prob.solve()

# Update problem
# NB: Update only upper triangular part of P
P_new = sparse.csc_matrix([[5, 1.5], [1.5, 1]])
A_new = sparse.csc_matrix([[1.2, 1.1], [1.5, 0], [0, 0.8]])
prob.update(Px=sparse.triu(P_new).data, Ax=A_new.data)

# Solve updated problem
res = prob.solve()

Matlab

% Define problem data
P = sparse([4, 1; 1, 2]);
q = [1; 1];
A = sparse([1, 1; 1, 0; 0, 1]);
l = [1; 0; 0];
u = [1; 0.7; 0.7];

% Create an OSQP object
prob = osqp;

% Setup workspace
prob.setup(P, q, A, l, u);

% Solve problem
res = prob.solve();

% Update problem
% NB: Update only upper triangular part of P
P_new = sparse([5, 1.5; 1.5, 1]);
A_new = sparse([1.2, 1.1; 1.5, 0; 0, 0.8]);
prob.update('Px', nonzeros(triu(P_new)), 'Ax', nonzeros(A_new));

% Solve updated problem
res = prob.solve();

Julia

using OSQP
using SparseArrays, LinearAlgebra

# Define problem data
P = sparse([4. 1.; 1. 2.])
q = [1.; 1.]
A = sparse([1. 1.; 1. 0.; 0. 1.])
l = [1.; 0.; 0.]
u = [1.; 0.7; 0.7]

# Crate OSQP object
prob = OSQP.Model()

# Setup workspace
OSQP.setup!(prob; P=P, q=q, A=A, l=l, u=u)

# Solve problem
results = OSQP.solve!(prob)

# Update problem
# NB: Update only upper triangular part of P
P_new = sparse([5. 1.5; 1.5 1.])
A_new = sparse([1.2 1.1; 1.5 0.; 0. 0.8])
OSQP.update!(prob, Px=triu(P_new).nzval, Ax=A_new.nzval)

# Solve updated problem
results = OSQP.solve!(prob)

R

library(osqp)
library(Matrix)

# Define problem data
P <- Matrix(c(4., 1.,
              1., 2.), 2, 2, sparse = TRUE)
q <- c(1., 1.)
A <- Matrix(c(1., 1., 0.,
              1., 0., 1.), 3, 2, sparse = TRUE)
l <- c(1., 0., 0.)
u <- c(1., 0.7, 0.7)

# Setup workspace
model <- osqp(P, q, A, l, u)

# Solve problem
res <- model$Solve()

# Update problem
# NB: Update only upper triangular part of P
P_new <- Matrix(c(5., 1.5,
                  1.5, 1.), 2, 2, sparse = TRUE)
A_new <- Matrix(c(1.2, 1.5, 0.,
                  1.1, 0., 0.8), 3, 2, sparse = TRUE)
model$Update(Px = P_new@x, Ax = A_new@x)

# Solve updated problem
res <- model$Solve()

C

#include <stdlib.h>
#include "osqp.h"

int main(int argc, char **argv) {
    /* Load problem data */
    OSQPFloat P_x[3] = {4.0, 1.0, 2.0, };
    OSQPFloat P_x_new[3] = {5.0, 1.5, 1.0, };
    OSQPInt P_nnz = 3;
    OSQPInt P_i[3] = {0, 0, 1, };
    OSQPInt P_p[3] = {0, 1, 3, };
    OSQPFloat q[2] = {1.0, 1.0, };
    OSQPFloat q_new[2] = {2.0, 3.0, };
    OSQPFloat A_x[4] = {1.0, 1.0, 1.0, 1.0, };
    OSQPFloat A_x_new[4] = {1.2, 1.5, 1.1, 0.8, };
    OSQPInt A_nnz = 4;
    OSQPInt A_i[4] = {0, 1, 0, 2, };
    OSQPInt A_p[3] = {0, 2, 4, };
    OSQPFloat l[3] = {1.0, 0.0, 0.0, };
    OSQPFloat l_new[3] = {2.0, -1.0, -1.0, };
    OSQPFloat u[3] = {1.0, 0.7, 0.7, };
    OSQPFloat u_new[3] = {2.0, 2.5, 2.5, };
    OSQPInt n = 2;
    OSQPInt m = 3;

    /* Exitflag */
    OSQPInt exitflag = 0;

    /* Solver */
    OSQPSolver *solver;

    /* Create CSC matrices that are backed by the above data arrays. */
    OSQPCscMatrix* P = OSQPCscMatrix_new(n, n, P_nnz, P_x, P_i, P_p);
    OSQPCscMatrix* A = OSQPCscMatrix_new(m, n, A_nnz, A_x, A_i, A_p);

    /* Set default settings */
    OSQPSettings *settings = OSQPSettings_new();

    /* Setup solver */
    exitflag = osqp_setup(&solver, P, q, A, l, u, m, n, settings);

    /* Solve problem */
    if (!exitflag) exitflag = osqp_solve(solver);

    /*  Update problem
        NB: Update only upper triangular part of P
     */
    if (!exitflag) exitflag = osqp_update_data_mat(solver,
                                                   P_x_new, OSQP_NULL, 3,
                                                   A_x_new, OSQP_NULL, 4);

    /* Solve updated problem */
    if (!exitflag) exitflag = osqp_solve(solver);

    /* Cleanup */
    osqp_cleanup(solver);
    OSQPCscMatrix_free(A);
    OSQPCscMatrix_free(P);
    OSQPSettings_free(settings);

    return (int)exitflag;
};

Rust

use osqp::{CscMatrix, Problem, Settings};

fn main() {
    // Define problem data
    let P = &[[4.0, 1.0],
        [1.0, 2.0]];
    let q = &[1.0, 1.0];
    let A = &[[1.0, 1.0],
        [1.0, 0.0],
        [0.0, 1.0]];
    let l = &[1.0, 0.0, 0.0];
    let u = &[1.0, 0.7, 0.7];

    // Extract the upper triangular elements of `P`
    let P = CscMatrix::from(P).into_upper_tri();

    let settings = Settings::default();

    // Create an OSQP problem
    let mut prob = Problem::new(P, q, A, l, u, &settings).expect("failed to setup problem");

    // Solve problem
    let result = prob.solve();

    // Update P/A without changing their sparsity structure
    // NB: Update only upper triangular part of P
    prob.update_P_A(
        &CscMatrix::from(&[[5.0, 1.5], [1.5, 1.0]]).into_upper_tri(),
        &[[1.2, 1.1], [1.5, 0.0], [0.0, 0.8]],
    );

    // Solve updated problem
    let result = prob.solve();

    // Print the solution
    println!("{:?}", result.x().expect("failed to solve problem"));
}