scs 0.5.2 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f6156bd39776692e6bf684208d4401859c8b76cbff5b031866a0e269ae66893
-  data.tar.gz: f2316371287f4b2492509950591bd763a08dc142af46e71f770e1a68897a566a
+  metadata.gz: 74c42ade2bfa33aa1b1ca6e48e221f0be32ae4897cd8355f85a112e06b8098f5
+  data.tar.gz: ae4548ba21f56ee5cdf091dd8ba89d415578f326b6d6f57df0ae7b4d53900eff
 SHA512:
-  metadata.gz: ee213ecedba119f6a551a9df9afb634f18dba8f022817baead85c77c9befd82c33690f942f6e5be0070f20a4ef3331eab289d8d3fffe5c1a801dbc66ce99efae
-  data.tar.gz: '071879f9a45ffc9c990e3510926c028f7f33ab199e13898325da87ff368eb19463b43feca04c5c296026150ae46aa86711098d15be4792f11c0bee1ac6e6993c'
+  metadata.gz: e3d8bc5c1f8c366a7aee9eb20a5281c9f6df77073618bfa63f2f106f002b9a1cb6db0d6985e16e7473d65063b567efc86278b88f91b311d5d6977aa9bf2dfafa
+  data.tar.gz: df1d393aa13d5be060f1f3a25243efa651df803cafe3705707a1c5cd934c8386619891418effd5b53cf38bf2c164539dd579ad3fa3a001c8cf23fea2e6bd0d9f

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.5.4 (2026-01-02)
+
+- Updated SCS to 3.2.10
+
+## 0.5.3 (2025-10-14)
+
+- Updated SCS to 3.2.9
+
 ## 0.5.2 (2025-08-13)
 
 - Updated SCS to 3.2.8

data/LICENSE.txt

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2012 Brendan O'Donoghue (bodonoghue85@gmail.com)
-Copyright (c) 2019-2024 Andrew Kane
+Copyright (c) 2019-2025 Andrew Kane
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/scs/version.rb

@@ -1,3 +1,3 @@
 module SCS
-  VERSION = "0.5.2"
+  VERSION = "0.5.4"
 end

data/vendor/scs/CITATION.cff

@@ -10,7 +10,7 @@ authors:
 - family-names: "Boyd"
   given-names: "Stephen"
 title: "SCS: Splitting Conic Solver"
-version: 3.2.8
+version: 3.2.10
 date-released: 2023
 url: "https://github.com/cvxgrp/scs"
 

data/vendor/scs/CMakeLists.txt

@@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5)
 project(
   scs
   LANGUAGES C
-  VERSION 3.2.8)
+  VERSION 3.2.10)
 
 # Defines the CMAKE_INSTALL_LIBDIR, CMAKE_INSTALL_BINDIR and many other useful
 # macros. See https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html

data/vendor/scs/README.md

@@ -4,11 +4,10 @@
 
 [![Build Status](https://github.com/cvxgrp/scs/actions/workflows/build.yml/badge.svg)](https://github.com/cvxgrp/scs/actions/workflows/build.yml)
 [![Documentation](https://img.shields.io/badge/docs-online-brightgreen?logo=read-the-docs&style=flat)](https://www.cvxgrp.org/scs/)
-[![Coverage Status](https://coveralls.io/repos/github/cvxgrp/scs/badge.svg?branch=master)](https://coveralls.io/github/cvxgrp/scs?branch=master)
 
 
 SCS (`splitting conic solver`) is a numerical optimization package for solving
-large-scale convex cone problems. The current version is `3.2.8`.
+large-scale convex cone problems. The current version is `3.2.10`.
 
 The full documentation is available [here](https://www.cvxgrp.org/scs/).
 

data/vendor/scs/include/cones.h

@@ -83,8 +83,8 @@ void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src);
 ScsConeWork *SCS(init_cone)(ScsCone *k, scs_int m);
 char *SCS(get_cone_header)(const ScsCone *k);
 scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k);
-scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c, ScsScaling *scal,
-                            scs_float *r_y);
+scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c,
+                            const ScsScaling *scal, scs_float *r_y);
 void SCS(finish_cone)(ScsConeWork *c);
 void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y);
 void SCS(enforce_cone_boundaries)(const ScsConeWork *c, scs_float *vec,

data/vendor/scs/include/glbopts.h

@@ -14,7 +14,7 @@ extern "C" {
 
 /* SCS VERSION NUMBER ----------------------------------------------     */
 /* string literals automatically null-terminated */
-#define SCS_VERSION ("3.2.8")
+#define SCS_VERSION ("3.2.10")
 
 /* verbosity level */
 #ifndef VERBOSITY
@@ -135,24 +135,18 @@ static inline void *scs_calloc(size_t count, size_t size) {
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #endif
 
-#ifndef ABS
-#define ABS(x) (((x) < 0) ? -(x) : (x))
-#endif
-
-#ifndef POWF
-#ifdef SFLOAT
-#define POWF powf
-#else
-#define POWF pow
-#endif
-#endif
-
-#ifndef SQRTF
 #ifdef SFLOAT
 #define SQRTF sqrtf
+#define EXPF expf
+#define LOGF logf
+#define ABS fabsf
+#define POWF powf
 #else
 #define SQRTF sqrt
-#endif
+#define EXPF exp
+#define LOGF log
+#define ABS fabs
+#define POWF pow
 #endif
 
 /* Force SCS to treat the problem as (non-homogeneous) feasible for this many */

data/vendor/scs/include/util.h

@@ -9,6 +9,7 @@ extern "C" {
 #include "scs.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 /* timing code courtesy of A. Domahidi */
 #if (defined NO_TIMER)

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

@@ -85,7 +85,7 @@ GLOBAL void AMD_1
 
     for (k = 0 ; k < n ; k++)
     {
-	AMD_DEBUG1 (("Construct row/column k= "ID" of A+A'\n", k))  ;
+	AMD_DEBUG1 (("Construct row/column k= " ID " of A+A'\n", k))  ;
 	p1 = Ap [k] ;
 	p2 = Ap [k+1] ;
 

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

@@ -604,7 +604,7 @@ GLOBAL void AMD_2
     }
     dense = MAX (16, dense) ;
     dense = MIN (n,  dense) ;
-    AMD_DEBUG1 (("\n\nAMD (debug), alpha %g, aggr. "ID"\n",
+    AMD_DEBUG1 (("\n\nAMD (debug), alpha %g, aggr. " ID "\n",
 	alpha, aggressive)) ;
 
     for (i = 0 ; i < n ; i++)
@@ -622,7 +622,7 @@ GLOBAL void AMD_2
     }
 
 #ifndef NDEBUG
-    AMD_DEBUG1 (("\n======Nel "ID" initial\n", nel)) ;
+    AMD_DEBUG1 (("\n======Nel " ID " initial\n", nel)) ;
     AMD_dump (n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last,
 		Head, Elen, Degree, W, -1) ;
 #endif
@@ -667,7 +667,7 @@ GLOBAL void AMD_2
 	     * version does not have this option.
 	     * ------------------------------------------------------------- */
 
-	    AMD_DEBUG1 (("Dense node "ID" degree "ID"\n", i, deg)) ;
+	    AMD_DEBUG1 (("Dense node " ID " degree " ID "\n", i, deg)) ;
 	    ndense++ ;
 	    Nv [i] = 0 ;		/* do not postorder this node */
 	    Elen [i] = EMPTY ;
@@ -699,7 +699,7 @@ GLOBAL void AMD_2
     {
 
 #ifndef NDEBUG
-	AMD_DEBUG1 (("\n======Nel "ID"\n", nel)) ;
+	AMD_DEBUG1 (("\n======Nel " ID "\n", nel)) ;
 	if (AMD_debug >= 2)
 	{
 	    AMD_dump (n, Pe, Iw, Len, iwlen, pfree, Nv, Next,
@@ -723,7 +723,7 @@ GLOBAL void AMD_2
 	}
 	mindeg = deg ;
 	ASSERT (me >= 0 && me < n) ;
-	AMD_DEBUG1 (("=================me: "ID"\n", me)) ;
+	AMD_DEBUG1 (("=================me: " ID "\n", me)) ;
 
 	/* ----------------------------------------------------------------- */
 	/* remove chosen variable from link list */
@@ -831,7 +831,7 @@ GLOBAL void AMD_2
 		    e = me ;
 		    pj = p ;
 		    ln = slenme ;
-		    AMD_DEBUG2 (("Search sv: "ID" "ID" "ID"\n", me,pj,ln)) ;
+		    AMD_DEBUG2 (("Search sv: " ID " " ID " " ID "\n", me,pj,ln)) ;
 		}
 		else
 		{
@@ -840,7 +840,7 @@ GLOBAL void AMD_2
 		    ASSERT (e >= 0 && e < n) ;
 		    pj = Pe [e] ;
 		    ln = Len [e] ;
-		    AMD_DEBUG2 (("Search element e "ID" in me "ID"\n", e,me)) ;
+		    AMD_DEBUG2 (("Search element e " ID " in me " ID "\n", e,me)) ;
 		    ASSERT (Elen [e] < EMPTY && W [e] > 0 && pj >= 0) ;
 		}
 		ASSERT (ln >= 0 && (ln == 0 || (pj >= 0 && pj < iwlen))) ;
@@ -857,7 +857,7 @@ GLOBAL void AMD_2
 		    i = Iw [pj++] ;
 		    ASSERT (i >= 0 && i < n && (i == me || Elen [i] >= EMPTY));
 		    nvi = Nv [i] ;
-		    AMD_DEBUG2 ((": "ID" "ID" "ID" "ID"\n",
+		    AMD_DEBUG2 ((": " ID " " ID " " ID " " ID "\n",
 				i, Elen [i], Nv [i], wflg)) ;
 
 		    if (nvi > 0)
@@ -912,7 +912,7 @@ GLOBAL void AMD_2
 				j = FLIP (Iw [psrc++]) ;
 				if (j >= 0)
 				{
-				    AMD_DEBUG2 (("Got object j: "ID"\n", j)) ;
+				    AMD_DEBUG2 (("Got object j: " ID "\n", j)) ;
 				    Iw [pdst] = Pe [j] ;
 				    Pe [j] = pdst++ ;
 				    lenj = Len [j] ;
@@ -946,7 +946,7 @@ GLOBAL void AMD_2
 			degme += nvi ;
 			Nv [i] = -nvi ;
 			Iw [pfree++] = i ;
-			AMD_DEBUG2 (("     s: "ID"     nv "ID"\n", i, Nv [i]));
+			AMD_DEBUG2 (("     s: " ID "     nv " ID "\n", i, Nv [i]));
 
 			/* ------------------------------------------------- */
 			/* remove variable i from degree link list */
@@ -974,7 +974,7 @@ GLOBAL void AMD_2
 		{
 		    /* set tree pointer and flag to indicate element e is
 		     * absorbed into new element me (the parent of e is me) */
-		    AMD_DEBUG1 ((" Element "ID" => "ID"\n", e, me)) ;
+		    AMD_DEBUG1 ((" Element " ID " => " ID "\n", e, me)) ;
 		    Pe [e] = FLIP (me) ;
 		    W [e] = 0 ;
 		}
@@ -998,8 +998,8 @@ GLOBAL void AMD_2
 	 * diagonal part). */
 
 #ifndef NDEBUG
-	AMD_DEBUG2 (("New element structure: length= "ID"\n", pme2-pme1+1)) ;
-	for (pme = pme1 ; pme <= pme2 ; pme++) AMD_DEBUG3 ((" "ID"", Iw[pme]));
+	AMD_DEBUG2 (("New element structure: length= " ID "\n", pme2-pme1+1)) ;
+	for (pme = pme1 ; pme <= pme2 ; pme++) AMD_DEBUG3 ((" " ID "", Iw[pme]));
 	AMD_DEBUG3 (("\n")) ;
 #endif
 
@@ -1036,7 +1036,7 @@ GLOBAL void AMD_2
 	    i = Iw [pme] ;
 	    ASSERT (i >= 0 && i < n) ;
 	    eln = Elen [i] ;
-	    AMD_DEBUG3 ((""ID" Elen "ID": \n", i, eln)) ;
+	    AMD_DEBUG3 (("" ID " Elen " ID ": \n", i, eln)) ;
 	    if (eln > 0)
 	    {
 		/* note that Nv [i] has been negated to denote i in Lme: */
@@ -1048,7 +1048,7 @@ GLOBAL void AMD_2
 		    e = Iw [p] ;
 		    ASSERT (e >= 0 && e < n) ;
 		    we = W [e] ;
-		    AMD_DEBUG4 (("    e "ID" we "ID" ", e, we)) ;
+		    AMD_DEBUG4 (("    e " ID " we " ID " ", e, we)) ;
 		    if (we >= wflg)
 		    {
 			/* unabsorbed element e has been seen in this loop */
@@ -1084,7 +1084,7 @@ GLOBAL void AMD_2
 	{
 	    i = Iw [pme] ;
 	    ASSERT (i >= 0 && i < n && Nv [i] < 0 && Elen [i] >= 0) ;
-	    AMD_DEBUG2 (("Updating: i "ID" "ID" "ID"\n", i, Elen[i], Len [i]));
+	    AMD_DEBUG2 (("Updating: i " ID " " ID " " ID "\n", i, Elen[i], Len [i]));
 	    p1 = Pe [i] ;
 	    p2 = p1 + Elen [i] - 1 ;
 	    pn = p1 ;
@@ -1114,12 +1114,12 @@ GLOBAL void AMD_2
 			    deg += dext ;
 			    Iw [pn++] = e ;
 			    hash += e ;
-			    AMD_DEBUG4 ((" e: "ID" hash = "ID"\n",e,hash)) ;
+			    AMD_DEBUG4 ((" e: " ID " hash = " ID "\n",e,hash)) ;
 			}
 			else
 			{
 			    /* external degree of e is zero, absorb e into me*/
-			    AMD_DEBUG1 ((" Element "ID" =>"ID" (aggressive)\n",
+			    AMD_DEBUG1 ((" Element " ID " =>" ID " (aggressive)\n",
 				e, me)) ;
 			    ASSERT (dext == 0) ;
 			    Pe [e] = FLIP (me) ;
@@ -1143,7 +1143,7 @@ GLOBAL void AMD_2
 			deg += dext ;
 			Iw [pn++] = e ;
 			hash += e ;
-			AMD_DEBUG4 (("	e: "ID" hash = "ID"\n",e,hash)) ;
+			AMD_DEBUG4 (("	e: " ID " hash = " ID "\n",e,hash)) ;
 		    }
 		}
 	    }
@@ -1172,7 +1172,7 @@ GLOBAL void AMD_2
 		    deg += nvj ;
 		    Iw [pn++] = j ;
 		    hash += j ;
-		    AMD_DEBUG4 (("  s: "ID" hash "ID" Nv[j]= "ID"\n",
+		    AMD_DEBUG4 (("  s: " ID " hash " ID " Nv[j]= " ID "\n",
 				j, hash, nvj)) ;
 		}
 	    }
@@ -1212,7 +1212,7 @@ GLOBAL void AMD_2
 		 * flop count analysis.  It also means that the post-ordering
 		 * is not an exact elimination tree post-ordering. */
 
-		AMD_DEBUG1 (("  MASS i "ID" => parent e "ID"\n", i, me)) ;
+		AMD_DEBUG1 (("  MASS i " ID " => parent e " ID "\n", i, me)) ;
 		Pe [i] = FLIP (me) ;
 		nvi = -Nv [i] ;
 		degme -= nvi ;
@@ -1304,7 +1304,7 @@ GLOBAL void AMD_2
 	{
 	    i = Iw [pme] ;
 	    ASSERT (i >= 0 && i < n) ;
-	    AMD_DEBUG2 (("Consider i "ID" nv "ID"\n", i, Nv [i])) ;
+	    AMD_DEBUG2 (("Consider i " ID " nv " ID "\n", i, Nv [i])) ;
 	    if (Nv [i] < 0)
 	    {
 		/* i is a principal variable in Lme */
@@ -1345,7 +1345,7 @@ GLOBAL void AMD_2
 		*/
 
 		ASSERT (i >= EMPTY && i < n) ;
-		AMD_DEBUG2 (("----i "ID" hash "ID"\n", i, hash)) ;
+		AMD_DEBUG2 (("----i " ID " hash " ID "\n", i, hash)) ;
 
 		while (i != EMPTY && Next [i] != EMPTY)
 		{
@@ -1381,7 +1381,7 @@ GLOBAL void AMD_2
 			/* check if j and i have identical nonzero pattern */
 			/* ------------------------------------------------- */
 
-			AMD_DEBUG3 (("compare i "ID" and j "ID"\n", i,j)) ;
+			AMD_DEBUG3 (("compare i " ID " and j " ID "\n", i,j)) ;
 
 			/* check if i and j have the same Len and Elen */
 			ASSERT (Len [j] >= 0 && Elen [j] >= 0) ;
@@ -1399,7 +1399,7 @@ GLOBAL void AMD_2
 			    /* found it!  j can be absorbed into i */
 			    /* --------------------------------------------- */
 
-			    AMD_DEBUG1 (("found it! j "ID" => i "ID"\n", j,i));
+			    AMD_DEBUG1 (("found it! j " ID " => i " ID "\n", j,i));
 			    Pe [j] = FLIP (i) ;
 			    /* both Nv [i] and Nv [j] are negated since they */
 			    /* are in Lme, and the absolute values of each */
@@ -1448,7 +1448,7 @@ GLOBAL void AMD_2
 	    i = Iw [pme] ;
 	    ASSERT (i >= 0 && i < n) ;
 	    nvi = -Nv [i] ;
-	    AMD_DEBUG3 (("Restore i "ID" "ID"\n", i, nvi)) ;
+	    AMD_DEBUG3 (("Restore i " ID " " ID "\n", i, nvi)) ;
 	    if (nvi > 0)
 	    {
 		/* i is a principal variable in Lme */
@@ -1495,7 +1495,7 @@ GLOBAL void AMD_2
 /* FINALIZE THE NEW ELEMENT */
 /* ========================================================================= */
 
-	AMD_DEBUG2 (("ME = "ID" DONE\n", me)) ;
+	AMD_DEBUG2 (("ME = " ID " DONE\n", me)) ;
 	Nv [me] = nvpiv ;
 	/* save the length of the list for the new element me */
 	Len [me] = p - pme1 ;
@@ -1542,10 +1542,10 @@ GLOBAL void AMD_2
 	}
 
 #ifndef NDEBUG
-	AMD_DEBUG2 (("finalize done nel "ID" n "ID"\n   ::::\n", nel, n)) ;
+	AMD_DEBUG2 (("finalize done nel " ID " n " ID "\n   ::::\n", nel, n)) ;
 	for (pme = Pe [me] ; pme <= Pe [me] + Len [me] - 1 ; pme++)
 	{
-	      AMD_DEBUG3 ((" "ID"", Iw [pme])) ;
+	      AMD_DEBUG3 ((" " ID "", Iw [pme])) ;
 	}
 	AMD_DEBUG3 (("\n")) ;
 #endif
@@ -1649,13 +1649,13 @@ GLOBAL void AMD_2
     AMD_DEBUG2 (("\nTree:\n")) ;
     for (i = 0 ; i < n ; i++)
     {
-	AMD_DEBUG2 ((" "ID" parent: "ID"   ", i, Pe [i])) ;
+	AMD_DEBUG2 ((" " ID " parent: " ID "   ", i, Pe [i])) ;
 	ASSERT (Pe [i] >= EMPTY && Pe [i] < n) ;
 	if (Nv [i] > 0)
 	{
 	    /* this is an element */
 	    e = i ;
-	    AMD_DEBUG2 ((" element, size is "ID"\n", Elen [i])) ;
+	    AMD_DEBUG2 ((" element, size is " ID "\n", Elen [i])) ;
 	    ASSERT (Elen [e] > 0) ;
 	}
 	AMD_DEBUG2 (("\n")) ;
@@ -1665,7 +1665,7 @@ GLOBAL void AMD_2
     {
 	if (Nv [e] > 0)
 	{
-	    AMD_DEBUG3 (("Element e= "ID" size "ID" nv "ID" \n", e,
+	    AMD_DEBUG3 (("Element e= " ID " size " ID " nv " ID " \n", e,
 		Elen [e], Nv [e])) ;
 	}
     }
@@ -1675,10 +1675,10 @@ GLOBAL void AMD_2
 	Int cnt ;
 	if (Nv [i] == 0)
 	{
-	    AMD_DEBUG3 (("i unordered: "ID"\n", i)) ;
+	    AMD_DEBUG3 (("i unordered: " ID "\n", i)) ;
 	    j = Pe [i] ;
 	    cnt = 0 ;
-	    AMD_DEBUG3 (("  j: "ID"\n", j)) ;
+	    AMD_DEBUG3 (("  j: " ID "\n", j)) ;
 	    if (j == EMPTY)
 	    {
 		AMD_DEBUG3 (("	i is a dense variable\n")) ;
@@ -1688,14 +1688,14 @@ GLOBAL void AMD_2
 		ASSERT (j >= 0 && j < n) ;
 		while (Nv [j] == 0)
 		{
-		    AMD_DEBUG3 (("	j : "ID"\n", j)) ;
+		    AMD_DEBUG3 (("	j : " ID "\n", j)) ;
 		    j = Pe [j] ;
-		    AMD_DEBUG3 (("	j:: "ID"\n", j)) ;
+		    AMD_DEBUG3 (("	j:: " ID "\n", j)) ;
 		    cnt++ ;
 		    if (cnt > n) break ;
 		}
 		e = j ;
-		AMD_DEBUG3 (("	got to e: "ID"\n", e)) ;
+		AMD_DEBUG3 (("	got to e: " ID "\n", e)) ;
 	    }
 	}
     }
@@ -1717,10 +1717,10 @@ GLOBAL void AMD_2
 	     * was selected as pivot.
 	     * ------------------------------------------------------------- */
 
-	    AMD_DEBUG1 (("Path compression, i unordered: "ID"\n", i)) ;
+	    AMD_DEBUG1 (("Path compression, i unordered: " ID "\n", i)) ;
 	    j = Pe [i] ;
 	    ASSERT (j >= EMPTY && j < n) ;
-	    AMD_DEBUG3 (("	j: "ID"\n", j)) ;
+	    AMD_DEBUG3 (("	j: " ID "\n", j)) ;
 	    if (j == EMPTY)
 	    {
 		/* Skip a dense variable.  It has no parent. */
@@ -1731,14 +1731,14 @@ GLOBAL void AMD_2
 	    /* while (j is a variable) */
 	    while (Nv [j] == 0)
 	    {
-		AMD_DEBUG3 (("		j : "ID"\n", j)) ;
+		AMD_DEBUG3 (("		j : " ID "\n", j)) ;
 		j = Pe [j] ;
-		AMD_DEBUG3 (("		j:: "ID"\n", j)) ;
+		AMD_DEBUG3 (("		j:: " ID "\n", j)) ;
 		ASSERT (j >= 0 && j < n) ;
 	    }
 	    /* got to an element e */
 	    e = j ;
-	    AMD_DEBUG3 (("got to e: "ID"\n", e)) ;
+	    AMD_DEBUG3 (("got to e: " ID "\n", e)) ;
 
 	    /* -------------------------------------------------------------
 	     * traverse the path again from i to e, and compress the path
@@ -1751,7 +1751,7 @@ GLOBAL void AMD_2
 	    while (Nv [j] == 0)
 	    {
 		jnext = Pe [j] ;
-		AMD_DEBUG3 (("j "ID" jnext "ID"\n", j, jnext)) ;
+		AMD_DEBUG3 (("j " ID " jnext " ID "\n", j, jnext)) ;
 		Pe [j] = e ;
 		j = jnext ;
 		ASSERT (j >= 0 && j < n) ;
@@ -1837,6 +1837,6 @@ GLOBAL void AMD_2
 	k = Next [i] ;
 	ASSERT (k >= 0 && k < n) ;
 	Last [k] = i ;
-	AMD_DEBUG2 (("   perm ["ID"] = "ID"\n", k, i)) ;
+	AMD_DEBUG2 (("   perm [" ID "] = " ID "\n", k, i)) ;
     }
 }

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

@@ -60,7 +60,7 @@ GLOBAL size_t AMD_aat	/* returns nz in A+A' */
     {
 	p1 = Ap [k] ;
 	p2 = Ap [k+1] ;
-	AMD_DEBUG2 (("\nAAT Column: "ID" p1: "ID" p2: "ID"\n", k, p1, p2)) ;
+	AMD_DEBUG2 (("\nAAT Column: " ID " p1: " ID " p2: " ID "\n", k, p1, p2)) ;
 
 	/* construct A+A' */
 	for (p = p1 ; p < p2 ; )
@@ -73,7 +73,7 @@ GLOBAL size_t AMD_aat	/* returns nz in A+A' */
 		 * add both A (j,k) and A (k,j) to the matrix A+A' */
 		Len [j]++ ;
 		Len [k]++ ;
-		AMD_DEBUG3 (("    upper ("ID","ID") ("ID","ID")\n", j,k, k,j));
+		AMD_DEBUG3 (("    upper (" ID "," ID ") (" ID "," ID ")\n", j,k, k,j));
 		p++ ;
 	    }
 	    else if (j == k)
@@ -102,7 +102,7 @@ GLOBAL size_t AMD_aat	/* returns nz in A+A' */
 		     * add both A (i,j) and A (j,i) to the matrix A+A' */
 		    Len [i]++ ;
 		    Len [j]++ ;
-		    AMD_DEBUG3 (("    lower ("ID","ID") ("ID","ID")\n",
+		    AMD_DEBUG3 (("    lower (" ID "," ID ") (" ID "," ID ")\n",
 			i,j, j,i)) ;
 		    pj++ ;
 		}
@@ -135,7 +135,7 @@ GLOBAL size_t AMD_aat	/* returns nz in A+A' */
 	     * add both A (i,j) and A (j,i) to the matrix A+A' */
 	    Len [i]++ ;
 	    Len [j]++ ;
-	    AMD_DEBUG3 (("    lower cleanup ("ID","ID") ("ID","ID")\n",
+	    AMD_DEBUG3 (("    lower cleanup (" ID "," ID ") (" ID "," ID ")\n",
 		i,j, j,i)) ;
 	}
     }
@@ -167,7 +167,7 @@ GLOBAL size_t AMD_aat	/* returns nz in A+A' */
 
     AMD_DEBUG1 (("AMD nz in A+A', excluding diagonal (nzaat) = %g\n",
 	(scs_float) nzaat)) ;
-    AMD_DEBUG1 (("   nzboth: "ID" nz: "ID" nzdiag: "ID" symmetry: %g\n",
+    AMD_DEBUG1 (("   nzboth: " ID " nz: " ID " nzdiag: " ID " symmetry: %g\n",
 		nzboth, nz, nzdiag, sym)) ;
 
     if (Info != (scs_float *) NULL)

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

@@ -41,7 +41,7 @@ GLOBAL void AMD_debug_init ( char *s )
     }
     if (AMD_debug >= 0)
     {
-	printf ("%s: AMD_debug_init, D= "ID"\n", s, AMD_debug) ;
+	printf ("%s: AMD_debug_init, D= " ID "\n", s, AMD_debug) ;
     }
 }
 
@@ -75,7 +75,7 @@ GLOBAL void AMD_dump (
 
     if (AMD_debug < 0) return ;
     ASSERT (pfree <= iwlen) ;
-    AMD_DEBUG3 (("\nAMD dump, pfree: "ID"\n", pfree)) ;
+    AMD_DEBUG3 (("\nAMD dump, pfree: " ID "\n", pfree)) ;
     for (i = 0 ; i < n ; i++)
     {
 	pe = Pe [i] ;
@@ -88,7 +88,7 @@ GLOBAL void AMD_dump (
 	{
 	    if (nv == 0)
 	    {
-		AMD_DEBUG3 (("\nI "ID": nonprincipal:    ", i)) ;
+		AMD_DEBUG3 (("\nI " ID ": nonprincipal:    ", i)) ;
 		ASSERT (elen == EMPTY) ;
 		if (pe == EMPTY)
 		{
@@ -98,13 +98,13 @@ GLOBAL void AMD_dump (
 		else
 		{
 		    ASSERT (pe < EMPTY) ;
-		    AMD_DEBUG3 ((" i "ID" -> parent "ID"\n", i, FLIP (Pe[i])));
+		    AMD_DEBUG3 ((" i " ID " -> parent " ID "\n", i, FLIP (Pe[i])));
 		}
 	    }
 	    else
 	    {
-		AMD_DEBUG3 (("\nI "ID": active principal supervariable:\n",i));
-		AMD_DEBUG3 (("   nv(i): "ID"  Flag: %d\n", nv, (nv < 0))) ;
+		AMD_DEBUG3 (("\nI " ID ": active principal supervariable:\n",i));
+		AMD_DEBUG3 (("   nv(i): " ID "  Flag: %d\n", nv, (nv < 0))) ;
 		ASSERT (elen >= 0) ;
 		ASSERT (nv > 0 && pe >= 0) ;
 		p = pe ;
@@ -114,7 +114,7 @@ GLOBAL void AMD_dump (
 		for (k = 0 ; k < len ; k++)
 		{
 		    j = Iw [p] ;
-		    AMD_DEBUG3 (("  "ID"", j)) ;
+		    AMD_DEBUG3 (("  " ID "", j)) ;
 		    ASSERT (j >= 0 && j < n) ;
 		    if (k == elen-1) AMD_DEBUG3 ((" : ")) ;
 		    p++ ;
@@ -127,13 +127,13 @@ GLOBAL void AMD_dump (
 	    e = i ;
 	    if (w == 0)
 	    {
-		AMD_DEBUG3 (("\nE "ID": absorbed element: w "ID"\n", e, w)) ;
+		AMD_DEBUG3 (("\nE " ID ": absorbed element: w " ID "\n", e, w)) ;
 		ASSERT (nv > 0 && pe < 0) ;
-		AMD_DEBUG3 ((" e "ID" -> parent "ID"\n", e, FLIP (Pe [e]))) ;
+		AMD_DEBUG3 ((" e " ID " -> parent " ID "\n", e, FLIP (Pe [e]))) ;
 	    }
 	    else
 	    {
-		AMD_DEBUG3 (("\nE "ID": unabsorbed element: w "ID"\n", e, w)) ;
+		AMD_DEBUG3 (("\nE " ID ": unabsorbed element: w " ID "\n", e, w)) ;
 		ASSERT (nv > 0 && pe >= 0) ;
 		p = pe ;
 		AMD_DEBUG3 ((" : ")) ;
@@ -141,7 +141,7 @@ GLOBAL void AMD_dump (
 		for (k = 0 ; k < len ; k++)
 		{
 		    j = Iw [p] ;
-		    AMD_DEBUG3 (("  "ID"", j)) ;
+		    AMD_DEBUG3 (("  " ID "", j)) ;
 		    ASSERT (j >= 0 && j < n) ;
 		    p++ ;
 		}
@@ -162,7 +162,7 @@ GLOBAL void AMD_dump (
 	    AMD_DEBUG3 ((ID": \n", deg)) ;
 	    for (i = Head [deg] ; i != EMPTY ; i = Next [i])
 	    {
-		AMD_DEBUG3 (("   "ID" : next "ID" last "ID" deg "ID"\n",
+		AMD_DEBUG3 (("   " ID " : next " ID " last " ID " deg " ID "\n",
 		    i, Next [i], Last [i], Degree [i])) ;
 		ASSERT (i >= 0 && i < n && ilast == Last [i] &&
 		    deg == Degree [i]) ;

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

@@ -64,7 +64,7 @@ GLOBAL Int AMD_post_tree
 	/* get head of stack */
 	ASSERT (head < nn) ;
 	i = Stack [head] ;
-	AMD_DEBUG1 (("head of stack "ID" \n", i)) ;
+	AMD_DEBUG1 (("head of stack " ID " \n", i)) ;
 	ASSERT (i >= 0 && i < nn) ;
 
 	if (Child [i] != EMPTY)
@@ -85,7 +85,7 @@ GLOBAL Int AMD_post_tree
 	    {
 		ASSERT (h > 0) ;
 		Stack [h--] = f ;
-		AMD_DEBUG1 (("push "ID" on stack\n", f)) ;
+		AMD_DEBUG1 (("push " ID " on stack\n", f)) ;
 		ASSERT (f >= 0 && f < nn) ;
 	    }
 	    ASSERT (Stack [h] == i) ;
@@ -98,7 +98,7 @@ GLOBAL Int AMD_post_tree
 	    /* the children of i (if there were any) are already ordered */
 	    /* remove i from the stack and order it.  Front i is kth front */
 	    head-- ;
-	    AMD_DEBUG1 (("pop "ID" order "ID"\n", i, k)) ;
+	    AMD_DEBUG1 (("pop " ID " order " ID "\n", i, k)) ;
 	    Order [i] = k++ ;
 	    ASSERT (k <= nn) ;
 	}