Python

Import

The OSQP module can be imported with

import osqp

Setup

The solver is initialized by creating an OSQP object

m = osqp.OSQP()

The problem is specified in the setup phase by running

m.setup(P=P, q=q, A=A, l=l, u=u, **settings)

The arguments q, l and u are numpy arrays. The elements of l and u can be \(\pm \infty\) ( using numpy.inf).

The arguments P and A are scipy sparse matrices in CSC format. Matrix P can be either complete or just the upper triangular part. OSQP will make use of only the upper triangular part. If they are sparse matrices are in another format, the interface will attempt to convert them. There is no need to specify all the arguments.

The keyword arguments **settings specify the solver settings. The allowed parameters are defined in Solver settings.

Solve

The problem can be solved by

results = m.solve()

The results object contains the primal solution x, the dual solution y, certificate of primal infeasibility prim_inf_cert, certificate of dual infeasibility dual_inf_cert and the info object containing the solver statistics defined in the following table

Member

Description

iter

Number of iterations

status

Solver status

status_val

Solver status value as in Status values and errors

status_polish

Polishing status

obj_val

Objective value

prim_res

Primal residual

dual_res

Dual residual

setup_time

Setup time

solve_time

Solve time

update_time

Update time

polish_time

Polish time

run_time

Total run time: setup/update + solve + polish

rho_estimate

Optimal rho estimate

rho_updates

Number of rho updates

Note that if multiple solves are executed from single setup, then after the first one run_time includes update_time + solve_time + polish_time.

Solve in just one function (with GIL disabled)

We have a dedicated solve function that performs setup and solve operations for you. It also disables the GIL in case you need it. Just run it from the main module without creating the object as follows

results = osqp.solve(P=P, q=q, A=A, l=l, u=u, **settings)

Update

Part of problem data and settings can be updated without requiring a new problem setup.

Update problem vectors

Vectors q, l and u can be updated with new values q_new, l_new and u_new by just running

m.update(q=q_new, l=l_new, u=u_new)

The user does not have to specify all the keyword arguments.

Update problem matrices

Matrices A and P can be updated by changing the value of their elements but not their sparsity pattern. The interface is designed to mimic the C counterpart. Note that the new values of P represent only the upper triangular part while A is always represented as a full matrix.

You can update the values of all the elements of P by executing

m.update(Px=Px_new)

If you want to update only some elements, you can pass

m.update(Px=Px_new, Px_idx=Px_new_idx)

where Px_new_idx is the vector of indices of mapping the elements of Px_new to the original vector Px representing the data of the sparse matrix P.

Matrix A can be changed in the same way. You can also change both matrices at the same time by running, for example

m.update(Px=Px_new, Px_idx=Px_new_idx, Ax=Ax_new, Ax=Ax_new_idx)

Update settings

Settings can be updated by running

m.update_settings(**kwargs)

where kwargs are the settings that can be updated which are marked with an * in Solver settings.

Warm start

OSQP automatically warm starts primal and dual variables from the previous QP solution. If you would like to warm start their values manually, you can use

m.warm_start(x=x0, y=y0)

where x0 and y0 are the new primal and dual variables.