sidereus

For QPs it looks like. Mosek works really well for SDPs. However, it converts QPs to SOCPs before solving them. This slows down a lot the timings.

We compared our OSQP solver to other general-purpose solvers. That's why we chose GUROBI and Mosek. There are also examples of control problems for which it is possible to design very efficient tailored methods. However our point is not to compare our solver to specific methods for certain classes (like libsvm).

In the benchmarks we are comparing examples with randomly generated data because we were interested in ~1400 problems in a range from 100 to 10 million nonzeros. The examples are not just random QPs, but data are generated in a reasonable manner and they have the same structure as problems people would actually solve in practice. In the arXiv paper we described in detail how we generated and checked optimality for the examples.

As mentioned in the README of the repository that you checked out (https://github.com/oxfordcontrol/osqp_benchmarks) we used the conversion scripts from here: https://github.com/YimingYAN/QP-Test-Problems

If you know better ways to convert the Maros problems (or other QP/LP benchmarks) to mat files or other formats compatible with Python, please let me know. I would be happy to try them.

Haven't tried the MIQP extension against the QPLIB yet. It is just a prototype and it is written in Python. We first need to implement it in C to compare the timings.

Which version of OSQP did you try for? 0.2 has improved a lot compared to previous versions (much better convergence behavior with adaptive rho).

Even though OSQP can solve also LPs, it is optimized to solve QPs. You can find some benchmarks here: https://github.com/oxfordcontrol/osqp_benchmarks They include:

- Randomly generated QPs from several classes such as control, portfolio, lasso, svm, Huber fitting

- The hard QP problems from the Maros-Meszaros test class (the reference benchmark testset for convex QPs)

OSQP solves only continuous QPs. For integer variables you need an MIQP solver.

We wrote a Python branch-and-bound wrapper around OSQP to solve MIQPs: https://github.com/oxfordcontrol/miosqp

However, there are more advanced MIQP algorithms out there such as GUROBI or CPLEX.

Yes! Cvxpy 1.0 now detects QPs and avoids the slow SOCP reduction. Also, it exploits OSQP to perform factorization caching and warm starting. If you solve parametric QPs in a sequence (e.g., lasso pareto frontier) the speedups are even bigger.

It would be very interesting to try the Anderson acceleration for QPs! We tried other line search methods but they did not bring consistent improvements for different problems. I think Anderson acceleration could be more useful (also from the theoretical point of view).

Could you put me in touch with the person working on that in the lab? I would be happy to try it. We have a prototype Python implementation that could be used for that.

I am happy to compare IPOPT as well. There was a github issue for this: https://github.com/oxfordcontrol/osqp_benchmarks/issues/1

As I said there, the current IPOPT Python interfaces do not report the timings. If you are aware of any fair way to time it from Python, I would be happy to add it. In my opinion using the Python "time" module can cause lags due to the Python interpreter.

arXiv paper: https://arxiv.org/abs/1711.08013

benchmarks: https://github.com/oxfordcontrol/osqp_benchmarks

It is the default LP/QP solver in cvxpy 1.0: https://github.com/cvxgrp/cvxpy

Very interesting! It would be nice to integrate it into a professional music production tool.