scs 0.2.2

data/vendor/scs/linsys/external/amd/amd_valid.c

@@ -0,0 +1,92 @@
+/* ========================================================================= */
+/* === AMD_valid =========================================================== */
+/* ========================================================================= */
+
+/* ------------------------------------------------------------------------- */
+/* AMD, Copyright (c) Timothy A. Davis,					     */
+/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
+/* email: DrTimothyAldenDavis@gmail.com                                      */
+/* ------------------------------------------------------------------------- */
+
+/* Check if a column-form matrix is valid or not.  The matrix A is
+ * n_row-by-n_col.  The row indices of entries in column j are in
+ * Ai [Ap [j] ... Ap [j+1]-1].  Required conditions are:
+ *
+ *	n_row >= 0
+ *	n_col >= 0
+ *	nz = Ap [n_col] >= 0	    number of entries in the matrix
+ *	Ap [0] == 0
+ *	Ap [j] <= Ap [j+1] for all j in the range 0 to n_col.
+ *      Ai [0 ... nz-1] must be in the range 0 to n_row-1.
+ *
+ * If any of the above conditions hold, AMD_INVALID is returned.  If the
+ * following condition holds, AMD_OK_BUT_JUMBLED is returned (a warning,
+ * not an error):
+ *
+ *	row indices in Ai [Ap [j] ... Ap [j+1]-1] are not sorted in ascending
+ *	    order, and/or duplicate entries exist.
+ *
+ * Otherwise, AMD_OK is returned.
+ *
+ * In v1.2 and earlier, this function returned TRUE if the matrix was valid
+ * (now returns AMD_OK), or FALSE otherwise (now returns AMD_INVALID or
+ * AMD_OK_BUT_JUMBLED).
+ */
+
+#include "amd_internal.h"
+
+GLOBAL Int AMD_valid
+(
+    /* inputs, not modified on output: */
+    Int n_row,		/* A is n_row-by-n_col */
+    Int n_col,
+    const Int Ap [ ],	/* column pointers of A, of size n_col+1 */
+    const Int Ai [ ]	/* row indices of A, of size nz = Ap [n_col] */
+)
+{
+    Int nz, j, p1, p2, ilast, i, p, result = AMD_OK ;
+
+    if (n_row < 0 || n_col < 0 || Ap == NULL || Ai == NULL)
+    {
+	return (AMD_INVALID) ;
+    }
+    nz = Ap [n_col] ;
+    if (Ap [0] != 0 || nz < 0)
+    {
+	/* column pointers must start at Ap [0] = 0, and Ap [n] must be >= 0 */
+	AMD_DEBUG0 (("column 0 pointer bad or nz < 0\n")) ;
+	return (AMD_INVALID) ;
+    }
+    for (j = 0 ; j < n_col ; j++)
+    {
+	p1 = Ap [j] ;
+	p2 = Ap [j+1] ;
+	AMD_DEBUG2 (("\nColumn: "ID" p1: "ID" p2: "ID"\n", j, p1, p2)) ;
+	if (p1 > p2)
+	{
+	    /* column pointers must be ascending */
+	    AMD_DEBUG0 (("column "ID" pointer bad\n", j)) ;
+	    return (AMD_INVALID) ;
+	}
+	ilast = EMPTY ;
+	for (p = p1 ; p < p2 ; p++)
+	{
+	    i = Ai [p] ;
+	    AMD_DEBUG3 (("row: "ID"\n", i)) ;
+	    if (i < 0 || i >= n_row)
+	    {
+		/* row index out of range */
+		AMD_DEBUG0 (("index out of range, col "ID" row "ID"\n", j, i));
+		return (AMD_INVALID) ;
+	    }
+	    if (i <= ilast)
+	    {
+		/* row index unsorted, or duplicate entry present */
+		AMD_DEBUG1 (("index unsorted/dupl col "ID" row "ID"\n", j, i));
+		result = AMD_OK_BUT_JUMBLED ;
+	    }
+	    ilast = i ;
+	}
+    }
+    return (result) ;
+}

data/vendor/scs/linsys/external/amd/changes

@@ -0,0 +1,11 @@
+Flatten out all .c and .h to single dir.
+All files: double -> scs_float.
+  git grep -l 'double' | xargs sed -i 's/double/scs_float/g'
+SuiteSparse_config.h: add '#include "scs.h"'
+                      add '#include "ctrlc.h"'
+                      add '#define SuiteSparse_long scs_int'
+                      disable timer #define NTIMER
+SuiteSparse_config.c: replace *alloc and printf in 2 structs.
+amd_internal.h: remove all refs to long version, int -> scs_int
+amd_global.c: add typedef to rm warning
+amd.h: int -> scs_int.h

data/vendor/scs/linsys/external/qdldl/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

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);
+
+}