scs 0.2.0

data/vendor/scs/linsys/external/qdldl/README.md

@@ -0,0 +1,120 @@
+# QDLDL
+A free LDL factorisation routine for quasi-definite linear systems: `Ax=b`
+
+[![Build Status](https://travis-ci.org/oxfordcontrol/qdldl.svg?branch=master)](https://travis-ci.org/oxfordcontrol/qdldl)
+[![Build status](https://ci.appveyor.com/api/projects/status/ns4br7v6y3i5stai/branch/master?svg=true)](https://ci.appveyor.com/project/bstellato/qdldl-8q1mv/branch/master)
+[![Coverage Status](https://coveralls.io/repos/github/oxfordcontrol/qdldl/badge.svg)](https://coveralls.io/github/oxfordcontrol/qdldl)
+
+
+## Getting started
+To start using QDLDL, first clone the repository
+
+```bash
+git clone https://github.com/oxfordcontrol/qdldl.git
+```
+
+### Build
+
+To build QDLDL, you need to install [cmake](https://cmake.org/) and run
+
+```bash
+mkdir build
+cd build
+cmake ..
+cmake --build .
+```
+
+This will generate an `out/` folder with contents:
+
+- `qdldl_example`: a **code example** from [`examples/c/example.c`](./examples/c/example.c)
+- `libqdldl`: a static and a dynamic versions of the library.
+
+You can include an addition option `-DUNITTESTS=ON` when calling `cmake`, which will result in an additional executable `qdldl_tester` being built in the `out/` folder to test QDLDL on a variety of problems, including those with rank deficient or otherwise ill-formatted inputs.
+
+**N.B.** All files will have file extensions appropriate to your operating system.
+
+
+### Install/Uninstall
+
+To install (uninstall) the libraries and headers you can simply run `make install` (`make uninstall`) after running the `cmake` command above.
+
+
+## Calling QDLDL
+
+### Main API
+
+The QDLDL API consists of 5 functions documented in [`include/qdldl.h`](./include/qdldl.h).
+For more details and a working example see [`examples/c/example.c`](./examples/c/example.c).
+
+**N.B.** There is **no memory allocation** performed in these routines. The user is assumed to have the working vectors already allocated.
+
+Here is a brief summary.
+
+* `QDLDL_etree`: compute the elimination tree for the quasidefinite matrix factorization `A = LDL'`
+* `QDLDL_factor`: return the factors `L`, `D` and `Dinv = 1./D`
+* `QDLDL_solve`: solves the linear system `LDL'x = b`
+* `QDLDL_Lsolve`: solves `Lx = b`
+* `QDLDL_Ltsolve`: solves `L'x = b`
+
+In the above function calls the matrices `A` and `L` are stored in compressed sparse column (CSC) format.   The matrix `A` is assumed to be symmetric and only the upper triangular portion of A should be passed to the API.   The factor `L` is lower triangular with implicit ones on the diagonal (i.e. the diagonal of L is not stored as part of the CSC formatted data.)
+
+The matrices `D` and `Dinv` are both diagonal matrices, with the diagonal values stored in an array.
+
+The matrix input `A` should be quasidefinite.   The API provides some (non-comprehensive) error checking to protect against non-quasidefinite or non-upper triangular inputs.
+
+### Custom types for integer, floats and booleans
+QDLDL uses its own internal types for integers, floats and booleans (`QDLDL_int, QDLDL_float, QDLDL_bool`. They can be specified using the cmake options:
+
+- `DFLOAT` (default false): uses float numbers instead of doubles
+- `DLONG` (default true): uses long integers for indexing (for large matrices)
+
+The `QDLDL_bool` is internally defined as `unsigned char`.
+
+
+## Linking QDLDL
+
+### Basic Example
+A basic example appears in [`examples/c/example.c`](./examples/c/example.c) and is compiled using cmake and the `CMakeLists.txt` file in the root folder.
+
+
+### Including in a cmake project
+
+You can include QDLDL in a cmake project `foo` by adding the subdirectory as
+```
+# Add project
+add_subdirectory(qdldl)
+```
+
+QDLDL can be linked using a static or dynamic linker
+```
+# Link static library
+target_link_libraries (foo qdldlstatic)
+
+# Link shared library
+target_link_libraries (foo qdldl)
+```
+for dynamic linking the shared library should be available in your path.
+
+There is also the option to include QDLDL as an object library in your project.
+The current `CMakeLists.txt` file creates an object library called `qdldlobject`.
+This can be added to your project by adding it after your sources.
+For example, when creating a library `foo` you can add
+
+```
+add_library(foo foo.c foo.h $<TARGET_OBJECTS:qdldlobject>)
+```
+for more details see the [cmake documentation](https://cmake.org/cmake/help/latest/command/add_library.html#object-libraries).
+
+
+## The algorithm
+
+The algorithm is an independent implementation of the elimination tree and factorisation procedures outlined in
+
+> T. A Davis. [Algorithm 849: a concise sparse cholesky factorization package](https://dl.acm.org/citation.cfm?id=1114277). ACM Trans. Math. Softw., 31(4):587–591, 2005.
+
+
+## Credits
+
+- [Paul Goulart](http://users.ox.ac.uk/~engs1373/): main development
+- [Bartolomeo Stellato](https://stellato.io/): code refactoring and testing
+- [Goran Banjac](http://control.ee.ethz.ch/~gbanjac/)

data/vendor/scs/linsys/external/qdldl/changes

@@ -0,0 +1,4 @@
+flatten into one dir
+create qdldl_types.h from template file
+add 'include "glbopts.h"' to qdldl_types.h
+manually insert scs types into qdldl_types.h

data/vendor/scs/linsys/external/qdldl/qdldl.c

@@ -0,0 +1,298 @@
+#include "qdldl.h"
+#include "ctrlc.h"
+
+#define QDLDL_UNKNOWN (-1)
+#define QDLDL_USED (1)
+#define QDLDL_UNUSED (0)
+
+// //DEBUG
+// #include <stdio.h>
+// void qdprint_arrayi(const QDLDL_int* data, QDLDL_int n,char* varName){
+
+//   QDLDL_int i;
+//   printf("%s = [",varName);
+//   for(i=0; i< n; i++){
+//     printf("%lli,",data[i]);
+//   }
+//   printf("]\n");
+
+// }
+
+// void qdprint_arrayf(const QDLDL_float* data, QDLDL_int n, char* varName){
+
+//   QDLDL_int i;
+//   printf("%s = [",varName);
+//   for(i=0; i< n; i++){
+//     printf("%.3g,",data[i]);
+//   }
+//   printf("]\n");
+
+// }
+// // END DEBUG
+
+/* Compute the elimination tree for a quasidefinite matrix
+   in compressed sparse column form.
+*/
+
+QDLDL_int QDLDL_etree(const QDLDL_int  n,
+                      const QDLDL_int* Ap,
+                      const QDLDL_int* Ai,
+                      QDLDL_int* work,
+                      QDLDL_int* Lnz,
+                      QDLDL_int* etree){
+
+  QDLDL_int sumLnz = 0;
+  QDLDL_int i,j,p;
+
+
+  for(i = 0; i < n; i++){
+  // zero out Lnz and work.  Set all etree values to unknown
+    work[i]  = 0;
+    Lnz[i]   = 0;
+    etree[i] = QDLDL_UNKNOWN;
+
+    //Abort if A doesn't have at least one entry
+    //one entry in every column
+    if(Ap[i] == Ap[i+1]){
+      return -1;
+    }
+
+  }
+
+  for(j = 0; j < n; j++){
+    work[j] = j;
+    for(p = Ap[j]; p < Ap[j+1]; p++){
+      i = Ai[p];
+      if(i > j){return -1;}; //abort if entries on lower triangle
+      while(work[i] != j){
+        if(etree[i] == QDLDL_UNKNOWN){
+          etree[i] = j;
+        }
+        Lnz[i]++;         //nonzeros in this column
+        work[i] = j;
+        i = etree[i];
+      }
+    }
+  }
+
+  //compute the total nonzeros in L.  This much
+  //space is required to store Li and Lx
+  for(i = 0; i < n; i++){sumLnz += Lnz[i];}
+
+  return sumLnz;
+}
+
+
+
+QDLDL_int QDLDL_factor(const QDLDL_int    n,
+                  const QDLDL_int*   Ap,
+                  const QDLDL_int*   Ai,
+                  const QDLDL_float* Ax,
+                  QDLDL_int*   Lp,
+                  QDLDL_int*   Li,
+                  QDLDL_float* Lx,
+                  QDLDL_float* D,
+                  QDLDL_float* Dinv,
+                  const QDLDL_int* Lnz,
+                  const QDLDL_int* etree,
+                  QDLDL_bool*  bwork,
+                  QDLDL_int*   iwork,
+                  QDLDL_float* fwork){
+
+  QDLDL_int i,j,k,nnzY, bidx, cidx, nextIdx, nnzE, tmpIdx;
+  QDLDL_int *yIdx, *elimBuffer, *LNextSpaceInCol;
+  QDLDL_float *yVals;
+  QDLDL_float yVals_cidx;
+  QDLDL_bool  *yMarkers;
+  QDLDL_int   positiveValuesInD = 0;
+
+  //partition working memory into pieces
+  yMarkers        = bwork;
+  yIdx            = iwork;
+  elimBuffer      = iwork + n;
+  LNextSpaceInCol = iwork + n*2;
+  yVals           = fwork;
+
+
+  Lp[0] = 0; //first column starts at index zero
+
+  for(i = 0; i < n; i++){
+
+    //compute L column indices
+    Lp[i+1] = Lp[i] + Lnz[i];   //cumsum, total at the end
+
+    // set all Yidx to be 'unused' initially
+    //in each column of L, the next available space
+    //to start is just the first space in the column
+    yMarkers[i]  = QDLDL_UNUSED;
+    yVals[i]     = 0.0;
+    D[i]         = 0.0;
+    LNextSpaceInCol[i] = Lp[i];
+  }
+
+  // First element of the diagonal D.
+  D[0]     = Ax[0];
+  if(D[0] == 0.0){return -1;}
+  if(D[0]  > 0.0){positiveValuesInD++;}
+  Dinv[0] = 1/D[0];
+
+  //Start from 1 here. The upper LH corner is trivially 0
+  //in L b/c we are only computing the subdiagonal elements
+  for(k = 1; k < n; k++){
+    if(scs_is_interrupted()) {
+      scs_printf("interrupt detected in factorization\n");
+      return -1;
+    }
+
+    //NB : For each k, we compute a solution to
+    //y = L(0:(k-1),0:k-1))\b, where b is the kth
+    //column of A that sits above the diagonal.
+    //The solution y is then the kth row of L,
+    //with an implied '1' at the diagonal entry.
+
+    //number of nonzeros in this row of L
+    nnzY = 0;  //number of elements in this row
+
+    //This loop determines where nonzeros
+    //will go in the kth row of L, but doesn't
+    //compute the actual values
+    tmpIdx = Ap[k+1];
+
+    for(i = Ap[k]; i < tmpIdx; i++){
+
+      bidx = Ai[i];   // we are working on this element of b
+
+      //Initialize D[k] as the element of this column
+      //corresponding to the diagonal place.  Don't use
+      //this element as part of the elimination step
+      //that computes the k^th row of L
+      if(bidx == k){
+        D[k] = Ax[i];
+        continue;
+      }
+
+      yVals[bidx] = Ax[i];   // initialise y(bidx) = b(bidx)
+
+      // use the forward elimination tree to figure
+      // out which elements must be eliminated after
+      // this element of b
+      nextIdx = bidx;
+
+      if(yMarkers[nextIdx] == QDLDL_UNUSED){   //this y term not already visited
+
+        yMarkers[nextIdx] = QDLDL_USED;     //I touched this one
+        elimBuffer[0]     = nextIdx;  // It goes at the start of the current list
+        nnzE              = 1;         //length of unvisited elimination path from here
+
+        nextIdx = etree[bidx];
+
+        while(nextIdx != QDLDL_UNKNOWN && nextIdx < k){
+          if(yMarkers[nextIdx] == QDLDL_USED) break;
+
+          yMarkers[nextIdx] = QDLDL_USED;   //I touched this one
+          elimBuffer[nnzE] = nextIdx; //It goes in the current list
+          nnzE++;                     //the list is one longer than before
+          nextIdx = etree[nextIdx];   //one step further along tree
+
+        } //end while
+
+        // now I put the buffered elimination list into
+        // my current ordering in reverse order
+        while(nnzE){
+          yIdx[nnzY++] = elimBuffer[--nnzE];
+        } //end while
+      } //end if
+
+    } //end for i
+
+    //This for loop places nonzeros values in the k^th row
+    for(i = (nnzY-1); i >=0; i--){
+
+      //which column are we working on?
+      cidx = yIdx[i];
+
+      // loop along the elements in this
+      // column of L and subtract to solve to y
+      tmpIdx = LNextSpaceInCol[cidx];
+      yVals_cidx = yVals[cidx];
+      for(j = Lp[cidx]; j < tmpIdx; j++){
+        yVals[Li[j]] -= Lx[j]*yVals_cidx;
+      }
+
+      //Now I have the cidx^th element of y = L\b.
+      //so compute the corresponding element of
+      //this row of L and put it into the right place
+      Li[tmpIdx] = k;
+      Lx[tmpIdx] = yVals_cidx *Dinv[cidx];
+
+      //D[k] -= yVals[cidx]*yVals[cidx]*Dinv[cidx];
+      D[k] -= yVals_cidx*Lx[tmpIdx];
+      LNextSpaceInCol[cidx]++;
+
+      //reset the yvalues and indices back to zero and QDLDL_UNUSED
+      //once I'm done with them
+      yVals[cidx]     = 0.0;
+      yMarkers[cidx]  = QDLDL_UNUSED;
+
+    } //end for i
+
+    //Maintain a count of the positive entries
+    //in D.  If we hit a zero, we can't factor
+    //this matrix, so abort
+    if(D[k] == 0.0){return -1;}
+    if(D[k]  > 0.0){positiveValuesInD++;}
+
+    //compute the inverse of the diagonal
+    Dinv[k]= 1/D[k];
+
+  } //end for k
+
+  return positiveValuesInD;
+
+}
+
+// Solves (L+I)x = b
+void QDLDL_Lsolve(const QDLDL_int    n,
+                  const QDLDL_int*   Lp,
+                  const QDLDL_int*   Li,
+                  const QDLDL_float* Lx,
+                  QDLDL_float* x){
+
+QDLDL_int i,j;
+  for(i = 0; i < n; i++){
+      for(j = Lp[i]; j < Lp[i+1]; j++){
+          x[Li[j]] -= Lx[j]*x[i];
+      }
+  }
+}
+
+// Solves (L+I)'x = b
+void QDLDL_Ltsolve(const QDLDL_int    n,
+                   const QDLDL_int*   Lp,
+                   const QDLDL_int*   Li,
+                   const QDLDL_float* Lx,
+                   QDLDL_float* x){
+
+QDLDL_int i,j;
+  for(i = n-1; i>=0; i--){
+      for(j = Lp[i]; j < Lp[i+1]; j++){
+          x[i] -= Lx[j]*x[Li[j]];
+      }
+  }
+}
+
+// Solves Ax = b where A has given LDL factors
+void QDLDL_solve(const QDLDL_int       n,
+                    const QDLDL_int*   Lp,
+                    const QDLDL_int*   Li,
+                    const QDLDL_float* Lx,
+                    const QDLDL_float* Dinv,
+                    QDLDL_float* x){
+
+QDLDL_int i;
+
+QDLDL_Lsolve(n,Lp,Li,Lx,x);
+for(i = 0; i < n; i++) x[i] *= Dinv[i];
+QDLDL_Ltsolve(n,Lp,Li,Lx,x);
+
+}

data/vendor/scs/linsys/external/qdldl/qdldl.h

@@ -0,0 +1,177 @@
+#ifndef QDLDL_H
+#define QDLDL_H
+
+// Include qdldl type options
+#include "qdldl_types.h"
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+/**
+  * Compute the elimination tree for a quasidefinite matrix
+  * in compressed sparse column form, where the input matrix is
+  * assumed to contain data for the upper triangular part of A only,
+  * and there are no duplicate indices.
+  *
+  * Returns an elimination tree for the factorization A = LDL^T and a
+  * count of the nonzeros in each column of L that are strictly below the
+  * diagonal.
+  *
+  * Does not use MALLOC.  It is assumed that the arrays work, Lnz, and
+  * etree will be allocated with a number of elements equal to n.
+  *
+  * The data in (n,Ap,Ai) are from a square matrix A in CSC format, and
+  * should include the upper triangular part of A only.
+  *
+  * This function is only intended for factorisation of QD matrices specified
+  * by their upper triangular part.  An error is returned if any column has
+  * data below the diagonal or s completely empty.
+  *
+  * For matrices with a non-empty column but a zero on the corresponding diagonal,
+  * this function will *not* return an error, as it may still be possible to factor
+  * such a matrix in LDL form.   No promises are made in this case though...
+  *
+  * @param   n     number of columns in CSC matrix A (assumed square)
+  * @param  Ap     column pointers (size n+1) for columns of A
+  * @param  Ai     row indices of A.  Has Ap[n] elements
+  * @param  work   work vector (size n) (no meaning on return)
+  * @param  Lnz    count of nonzeros in each column of L (size n) below diagonal
+  * @param  etree  elimination tree (size n)
+  * @return total  sum of Lnz (i.e. total nonzeros in L below diagonal). Returns
+  *                -1 if the input does not have triu structure or has an empty
+  *                column.
+  *
+  *
+*/
+
+ QDLDL_int QDLDL_etree(const QDLDL_int   n,
+                       const QDLDL_int* Ap,
+                       const QDLDL_int* Ai,
+                       QDLDL_int* work,
+                       QDLDL_int* Lnz,
+                       QDLDL_int* etree);
+
+/**
+  * Compute an LDL decomposition for a quasidefinite matrix
+  * in compressed sparse column form, where the input matrix is
+  * assumed to contain data for the upper triangular part of A only,
+  * and there are no duplicate indices.
+  *
+  * Returns factors L, D and Dinv = 1./D.
+  *
+  * Does not use MALLOC.  It is assumed that L will be a compressed
+  * sparse column matrix with data (Ln,Lp,Li)  with sufficient space
+  * allocated, with a number of nonzeros equal to the count given
+  * as a return value by osqp_ldl_etree
+  *
+  * @param   n     number of columns in L and A (both square)
+  * @param  Ap     column pointers (size n+1) for columns of A
+  * @param  Ai     row indices of A.  Has Ap[n] elements
+  * @param  Ln     number of columns in CSC matrix L
+  * @param  Lp     column pointers (size Ln+1) for columns of L
+  * @param  Li     row indices of L.  Has Lp[Ln] elements
+  * @param  D      vectorized factor D.  Length is n
+  * @param  Dinv   reciprocal of D.  Length is n
+  * @param  Lnz    count of nonzeros in each column of L below diagonal,
+  *                as given by osqp_ldl_etree (not modified)
+  * @param  etree  elimination tree as as given by osqp_ldl_etree (not modified)
+  * @param  bwork  working array of bools. Length is n
+  * @param  iwork  working array of integers. Length is 3*n
+  * @param  fwork  working array of floats. Length is n
+  * @return        Returns a count of the number of positive elements
+  *                in D.  Returns -1 and exits immediately if any element
+  *                of D evaluates exactly to zero (matrix is not quasidefinite
+  *                or otherwise LDL factorisable)
+  *
+*/
+
+
+QDLDL_int QDLDL_factor(const QDLDL_int    n,
+                  const QDLDL_int*   Ap,
+                  const QDLDL_int*   Ai,
+                  const QDLDL_float* Ax,
+                  QDLDL_int*   Lp,
+                  QDLDL_int*   Li,
+                  QDLDL_float* Lx,
+                  QDLDL_float* D,
+                  QDLDL_float* Dinv,
+                  const QDLDL_int* Lnz,
+                  const QDLDL_int* etree,
+                  QDLDL_bool* bwork,
+                  QDLDL_int* iwork,
+                  QDLDL_float* fwork);
+
+
+/**
+  * Solves LDL'x = b
+  *
+  * It is assumed that L will be a compressed
+  * sparse column matrix with data (Ln,Lp,Li).
+  *
+  * @param   n     number of columns in L (both square)
+  * @param  Ln     number of columns in CSC matrix L
+  * @param  Lp     column pointers (size Ln+1) for columns of L
+  * @param  Li     row indices of L.  Has Lp[Ln] elements
+  * @param  Dinv   reciprocal of D.  Length is n
+  * @param  x      initialized to b.  Equal to x on return
+  *
+  *
+*/
+void QDLDL_solve(const QDLDL_int    n,
+                 const QDLDL_int*   Lp,
+                 const QDLDL_int*   Li,
+                 const QDLDL_float* Lx,
+                 const QDLDL_float* Dinv,
+                 QDLDL_float* x);
+
+
+/**
+ * Solves (L+I)x = b
+ *
+ * It is assumed that L will be a compressed
+ * sparse column matrix with data (Ln,Lp,Li).
+ *
+ * @param   n     number of columns in L (both square)
+ * @param  Ln     number of columns in CSC matrix L
+ * @param  Lp     column pointers (size Ln+1) for columns of L
+ * @param  Li     row indices of L.  Has Lp[Ln] elements
+ * @param  Dinv   reciprocal of D.  Length is n
+ * @param  x      initialized to b.  Equal to x on return
+ *
+ *
+*/
+
+void QDLDL_Lsolve(const QDLDL_int    n,
+                  const QDLDL_int*   Lp,
+                  const QDLDL_int*   Li,
+                  const QDLDL_float* Lx,
+                  QDLDL_float* x);
+
+/**
+ * Solves (L+I)'x = b
+ *
+ * It is assumed that L will be a compressed
+ * sparse column matrix with data (Ln,Lp,Li).
+ *
+ * @param   n     number of columns in L (both square)
+ * @param  Ln     number of columns in CSC matrix L
+ * @param  Lp     column pointers (size Ln+1) for columns of L
+ * @param  Li     row indices of L.  Has Lp[Ln] elements
+ * @param  Dinv   reciprocal of D.  Length is n
+ * @param  x      initialized to b.  Equal to x on return
+ *
+ *
+*/
+
+void QDLDL_Ltsolve(const QDLDL_int    n,
+                   const QDLDL_int*   Lp,
+                   const QDLDL_int*   Li,
+                   const QDLDL_float* Lx,
+                   QDLDL_float* x);
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif // ifndef QDLDL_H

data/vendor/scs/linsys/external/qdldl/qdldl_types.h

@@ -0,0 +1,21 @@
+#ifndef QDLDL_TYPES_H
+# define QDLDL_TYPES_H
+
+#include "glbopts.h"
+
+# ifdef __cplusplus
+extern "C" {
+# endif /* ifdef __cplusplus */
+
+// QDLDL integer and float types
+
+#define QDLDL_int scs_int
+#define QDLDL_float scs_float
+#define QDLDL_bool scs_int
+
+# ifdef __cplusplus
+}
+# endif /* ifdef __cplusplus */
+
+#endif /* ifndef QDLDL_TYPES_H */
+

data/vendor/scs/linsys/gpu/gpu.c

@@ -0,0 +1,41 @@
+#include "gpu.h"
+
+void SCS(_accum_by_atrans_gpu)(const ScsGpuMatrix *Ag, const scs_float *x,
+                               scs_float *y, cusparseHandle_t cusparse_handle) {
+  /* y += A'*x
+     x and y MUST be on GPU already
+  */
+  const scs_float onef = 1.0;
+  CUSPARSE(csrmv)
+  (cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE, Ag->n, Ag->m, Ag->Annz,
+   &onef, Ag->descr, Ag->x, Ag->p, Ag->i, x, &onef, y);
+}
+
+void SCS(_accum_by_a_gpu)(const ScsGpuMatrix *Ag, const scs_float *x,
+                          scs_float *y, cusparseHandle_t cusparse_handle) {
+  /* y += A*x
+     x and y MUST be on GPU already
+   */
+  const scs_float onef = 1.0;
+  /* The A matrix idx pointers must be ORDERED */
+  CUSPARSE(csrmv)
+  (cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE, Ag->n, Ag->m, Ag->Annz, &onef,
+   Ag->descr, Ag->x, Ag->p, Ag->i, x, &onef, y);
+}
+
+void SCS(free_gpu_matrix)(ScsGpuMatrix *A) {
+  cudaFree(A->x);
+  cudaFree(A->i);
+  cudaFree(A->p);
+  cusparseDestroyMatDescr(A->descr);
+}
+
+void SCS(normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,
+                      ScsScaling *scal) {
+  SCS(_normalize_a)(A, stgs, k, scal);
+}
+
+void SCS(un_normalize_a)(ScsMatrix *A, const ScsSettings *stgs,
+                         const ScsScaling *scal) {
+  SCS(_un_normalize_a)(A, stgs, scal);
+}