foges/pogs

Proximal Operator Graph Solver

POGS

Proximal Graph Solver (POGS) is a solver for convex optimization problems in graph form using Alternating Direction Method of Multipliers (ADMM).

• The GitHub.io page contains Documentation.
• We recently posted a paper online, with details about the implementation, as well as many numerical examples.

---

A graph form problem can be expressed as

minimize        f(y) + g(x)
subject to      y = Ax

where f and g are convex and can take on the values R \cup {∞}. The solver requires that the proximal operators of f and g are known and that f and g are separable, meaning that they can be written as

f(y) = sum_{i=1}^m f_i(y_i)
g(x) = sum_{i=1}^n g_i(x_i)

The following functions are currently supported

where I(.) is the indicator function, taking on the value 0 if the condition is satisfied and infinity otherwise. More functions can be added by modifying the proximal operator header file: <pogs>/src/include/prox_lib.h.

Languages / Frameworks

Three different implementations of the solver are either planned or already supported:

1. C++/BLAS/OpenMP: A CPU version can be found in the file <pogs>/src/cpu/. POGS must be linked to a BLAS library (such as the Apple Accelerate Framework or ATLAS).
2. C++/cuBLAS/CUDA: A GPU version is located in the file <pogs>/src/gpu/. To use the GPU version, the CUDA SDK must be installed, and the computer must have a CUDA-capable GPU.
3. MATLAB: A MATLAB implementation along with examples can be found in the <pogs>/matlab directory. The code is heavily documented and primarily intended for pedagogical purposes.

Problem Classes

Among others, the solver can be used for the following classes of (linearly constrained) problems

• Lasso, Ridge Regression, Logistic Regression, Huber Fitting and Elastic Net Regulariation,
• Total Variation Denoising, Optimal Control,
• Linear Programs and Quadratic Programs.

References

1. Parameter Selection and Pre-Conditioning for a Graph Form Solver -- C. Fougner and S. Boyd
2. Block Splitting for Distributed Optimization -- N. Parikh and S. Boyd
3. Distributed Optimization and Statistical Learning via the Alternating Direction Method of Multipliers -- S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein
4. Proximal Algorithms -- N. Parikh and S. Boyd

License

POGS is licensed with BSD-3.

Authors

Chris Fougner, with input from Stephen Boyd. The basic algorithm is from "Block Splitting for Distributed Optimization -- N. Parikh and S. Boyd".

pogs's Issues

Iterative pogs memory leak in MATLAB 2018

This is a really great method! However, I have embedded pogs in a loop that iterates many many times and there is a memory leak resulting in an inevitable crash. Any ideas/suggestions? I'm assuming somewhere an array needs destroying.

Thanks

Path include error on ubuntu/debian R installation + fix

I was getting a R.h not found error when installing according to the docs, and did some digging about where it was looking for R.h. interface_r/pogs/src/config.mk defines R_INC:=$(R_HOME)/include, but the debian install of R stores these files in /usr/share/R/include. Commenting out Line 7 in config.mk and installing from the package directory using devtools::install worked.

License file

Would be good to have a license file in the repo to make the terms of the license clear and to make it easier for people new to the project to evaluate quickly whether it meets their needs.

Add check to see if primal or dual residual are stationary => maybe infeasible

Figure out why CPU and GPU version require different number of iterations

(maybe has to do with different equilibration)

return unbounded/infeasible if primal or dual residuals don't change

use of unitialised data in src/cpu/include/gsl/gsl_vector.h

The "data" member is not initialised (src/cpu/include/gls/gsl_vector.h, line 27). This causes a lot of "Conditional jump or move depends on uninitialised value(s)" with valgrind.

Although I did not notice any strange behaviour, a std::fill or - according to stackoverflow - new T[n]() may be safer.

Quantile loss

Roger Koenker has mentioned POGS as a good choice for solving large scale quantile regression problems. In one paper he mentions that he has ran some experiments with the GPU implementation of POGS.

How can one apply POGS to quantile regression? Were Koenker's experiments using an unpublished POGS implementation of quantile loss? Or is it possible to to define a quantile regression problem using the 16 available functions in prox_lib.sh?

Otherwise, I'd love a bit of direction on how to implement quantile loss in POGS.

Matlab CPUs\GPU ?

How do I ensure GPU optimization in Matlab ?
I checked pogs help under Matlab and went trough code quickly, but no luck.
Is there a way to tell it use CPUs\GPU, or it just happens in the background ?

Julia interface

check if x0 = 0 in cgls

If it is the case, then skip Ax in the first iteration

Check why sparse and dense column - format don't seem to produce the same results

Missing memory movement in the C interface

The three lines with memcpy omit "sizeof(T)"....

(1) The final argument, "n", wants to be "n * sizeof(T)":

pogs/src/interface_c/pogs_c.cpp

Line 48 in 81e3d89

memcpy(x, pogs_data.GetX(), n);

(2) The final argument, "m", wants to be "m * sizeof(T)":

pogs/src/interface_c/pogs_c.cpp

Line 49 in 81e3d89

memcpy(y, pogs_data.GetY(), m);

(3) The final argument, "m", wants to be "m * sizeof(T)":

pogs/src/interface_c/pogs_c.cpp

Line 50 in 81e3d89

memcpy(l, pogs_data.GetLambda(), m);

MATLAB version will not compile

Hi,

I tried to compile PGOS on MATLAB with no success.

Any help?

Win 10
MATLAB 2017b
MinGW64 Compiler

Error message:

pogs_setup
'make' is not recognized as an internal or external command,
operable program or batch file.
'make' is not recognized as an internal or external command,
operable program or batch file.

Error using mex
MEX cannot find library 'mwblas' specified with the -l option.
MEX looks for a file with one of the names:
libmwblas.lib
mwblas.lib
Please specify the path to this library with the -L option.

Error in pogs_setup (line 33)
eval(sprintf(['mex -largeArrayDims -I../include ' ...

Massive example code build errors

Hi!
I tried to build pogs but encountered a s**t ton of build errors.
A small portion of the errors I experienced are posted below.
Is this a version error or somthing?

I built the cpp examples with make gpu

This is what I got.

gpu/include/cml/cml_spmat.cuh(41): error: identifier "CUSPARSE_ACTION_NUMERIC" is undefined
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(40): error: argument of type "int" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(40): error: argument of type "const float *" is incompatible with parameter of type "const int *"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(41): error: argument of type "const int *" is incompatible with parameter of type "float *"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(41): error: argument of type "float *" is incompatible with parameter of type "int *"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(41): error: argument of type "int *" is incompatible with parameter of type "int"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(42): error: too many arguments in function call
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(48): error: identifier "CUSPARSE_ACTION_NUMERIC" is undefined
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(47): error: argument of type "int" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(47): error: argument of type "const float *" is incompatible with parameter of type "const int *"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(48): error: argument of type "const int *" is incompatible with parameter of type "float *"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(48): error: argument of type "float *" is incompatible with parameter of type "int *"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(48): error: argument of type "int *" is incompatible with parameter of type "int"
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spmat.cuh(49): error: too many arguments in function call
          detected during:
            instantiation of "void cml::spmat_memcpy(cusparseHandle_t, cml::spmat<T, I, O> *, const T *, const I *, const I *) [with T=float, I=pogs::POGS_INT, O=CblasRowMajor]" 
gpu/matrix/matrix_sparse.cu(139): here
            instantiation of "int pogs::MatrixSparse<T>::Init() [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(60): error: argument of type "float *" is incompatible with parameter of type "cusparseMatDescr_t"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(60): error: argument of type "cusparseMatDescr_t" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(61): error: argument of type "float *" is incompatible with parameter of type "const int *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(61): error: argument of type "pogs::POGS_INT *" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(61): error: argument of type "float *" is incompatible with parameter of type "float"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(61): error: too many arguments in function call
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(63): error: argument of type "float *" is incompatible with parameter of type "cusparseMatDescr_t"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(63): error: argument of type "cusparseMatDescr_t" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(64): error: argument of type "float *" is incompatible with parameter of type "const int *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(64): error: argument of type "pogs::POGS_INT *" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(64): error: argument of type "float *" is incompatible with parameter of type "float"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(65): error: too many arguments in function call
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasRowMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(171): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(80): error: argument of type "float *" is incompatible with parameter of type "cusparseMatDescr_t"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(81): error: argument of type "cusparseMatDescr_t" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(81): error: argument of type "float *" is incompatible with parameter of type "const int *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(81): error: argument of type "pogs::POGS_INT *" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(81): error: argument of type "float *" is incompatible with parameter of type "float"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(82): error: too many arguments in function call
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(84): error: argument of type "float *" is incompatible with parameter of type "cusparseMatDescr_t"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(85): error: argument of type "cusparseMatDescr_t" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(85): error: argument of type "float *" is incompatible with parameter of type "const int *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(85): error: argument of type "pogs::POGS_INT *" is incompatible with parameter of type "const float *"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(85): error: argument of type "float *" is incompatible with parameter of type "float"
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

gpu/include/cml/cml_spblas.cuh(85): error: too many arguments in function call
          detected during:
            instantiation of "cusparseStatus_t cml::spblas_gemv(cusparseHandle_t, cusparseOperation_t, cusparseMatDescr_t, float, const cml::spmat<float, I, CblasColMajor> *, const cml::vector<float> *, float, cml::vector<float> *) [with I=pogs::POGS_INT]" 
gpu/matrix/matrix_sparse.cu(176): here
            instantiation of "int pogs::MatrixSparse<T>::Mul(char, T, const T *, T, T *) const [with T=float]" 
gpu/matrix/matrix_sparse.cu(376): here

76 errors detected in the compilation of "/tmp/tmpxft_0000776b_00000000-6_matrix_sparse.cpp1.ii".
make[1]: *** [build/gpu/matrix/matrix_sparse.o] Error 2
make[1]: Leaving directory `/home/msca8h/project/POGS_test/pogs/src'
make: *** [gpu] Error 2

Clearify license

Can you please clarify the license of POGS? I neither found a COPYING file nor a license/copyright header at the top of a source file.

http://foges.github.io/pogs/ says GPL.
Paper and src/interface_r/pogs/DESCRIPTION say 3-Clause-BSD.

BSD is great. GPL would be quite limiting.

Make equilibration fully part of equilibrate file (not partly in pogs).

Make pogs part of namespace and then change name.

Add more prox operators

• Berhu
• Switch for x \in Z

posg_setup not working on Matlab

I tried to run pogs_setup on Matlab, but it gives a series of errors.

'make' is not recognized as an internal or external command,
operable program or batch file.
'make' is not recognized as an internal or external command,
operable program or batch file.
Building with 'Microsoft Visual C++ 2015'.
Error using mex
pogs_mex.cpp

I am running it on Matlab R2018a and CUDA 9.0 is installed on my machine.

Make Indirect version and derive sparse from that

1. Let CGLS take a functor.
2. Each type must
   2.1 Define Type with alloc constructor.
   2.2 Implement Memcpy.
   2.2 Implement Equilibrate.
   2.3 Implement Gemv.
   2.4 Implement AllocFactor/FreeFactor

Add readthedocs documentation

• If you care a lot about an inequality constraint, then add some epsilon.

function "norms" not defined or found

matlab implementation of pogs calls norms(matrix, int, int), line 355 and 357. To my believe this function is not provided.

Make verbosity an integer value

0 : Nothing
1 : Residuals + Final time and other stats
2 : Rho changes
3 : Sparse solving steps

Add option for 1-based indexing in sparse format.

Initialize dual variables to \nabla f(x)

I'm not sure if there is an ideal way to guess the dual variables, but assuming x0 and y0 are primal optimal, then the relation

x0 = prox_g(x0 - \tilde x)
y0 = prox_f(y0 - \tilde y)

holds, which means

\nabla g(x0) + rho \tilde x = 0 <=> \tilde x = -(1/rho) \nabla g(x0) and \tilde y = -(1/rho) \nabla f(y0)

Update documentation

Should reflect current state of solver.

change sinkhorn_knopp -> equilibrate

Interface for Python

Interface using numpy (will probably use swig).

Change CblasRow, etc.. in cml and gsl to ROW and COL

util.cuh -> util.h and make _EPS error messages more useful