Avoid conflict with amd and rcm api

filikat · filikat · commit 06f31a58d4c5 · 2026-02-09T13:10:02.000Z
diff --git a/extern/amd/SuiteSparse_config.c b/extern/amd/SuiteSparse_config.c
@@ -13,7 +13,7 @@
 
 #include "SuiteSparse_config.h"
 
-void *SuiteSparse_malloc    /* pointer to allocated block of memory */
+void *Highs_SuiteSparse_malloc    /* pointer to allocated block of memory */
 (
     size_t nitems,          /* number of items to malloc */
     size_t size_of_item     /* sizeof each item */
@@ -41,7 +41,7 @@ void *SuiteSparse_malloc    /* pointer to allocated block of memory */
 /* SuiteSparse_free: free wrapper */
 /* -------------------------------------------------------------------------- */
 
-void *SuiteSparse_free      /* always returns NULL */
+void *Highs_SuiteSparse_free      /* always returns NULL */
 (
     void *p                 /* block to free */
 )
diff --git a/extern/amd/SuiteSparse_config.h b/extern/amd/SuiteSparse_config.h
@@ -36,25 +36,17 @@
 #include <stdarg.h>
 #include <ctype.h>
 
-void *SuiteSparse_malloc    // pointer to allocated block of memory
+void *Highs_SuiteSparse_malloc    // pointer to allocated block of memory
 (
     size_t nitems,          // number of items to malloc (>=1 is enforced)
     size_t size_of_item     // sizeof each item
 ) ;
 
-void *SuiteSparse_free      // always returns NULL
+void *Highs_SuiteSparse_free      // always returns NULL
 (
     void *p                 // block to free
 ) ;
 
-// SuiteSparse printf macro
-#define SUITESPARSE_PRINTF(params)                          \
-{                                                           \
-                                                            \
-         printf params ;                                    \
-                                                            \
-}
-
 #define SUITESPARSE_DATE "Nov 4, 2025"
 #define SUITESPARSE_MAIN_VERSION    7
 #define SUITESPARSE_SUB_VERSION     12
diff --git a/extern/amd/amd.h b/extern/amd/amd.h
@@ -53,7 +53,7 @@ typedef unsigned int amd_uint;
 extern "C" {
 #endif
 
-int amd_order  /* returns AMD_OK, AMD_OK_BUT_JUMBLED,
+int Highs_amd_order  /* returns AMD_OK, AMD_OK_BUT_JUMBLED,
                                     * AMD_INVALID, or AMD_OUT_OF_MEMORY */
 (
     amd_int n,                         /* A is n-by-n.  n must be >= 0. */
@@ -232,7 +232,7 @@ int amd_order  /* returns AMD_OK, AMD_OK_BUT_JUMBLED,
  * of the matrix for AMD to destroy).  Refer to AMD/Source/amd_2.c for a
  * description of each parameter. */
 
-void amd_2
+void Highs_amd_2
 (
     amd_int n,
     amd_int Pe [ ],
@@ -263,7 +263,7 @@ void amd_2
  * of columns of the matrix.  For its use in AMD, these must both equal n.
  */
 
-int amd_valid
+int Highs_amd_valid
 (
     amd_int n_row,                 /* # of rows */
     amd_int n_col,                 /* # of columns */
@@ -276,13 +276,13 @@ int amd_valid
 /* ------------------------------------------------------------------------- */
 
 /* amd_defaults:  sets the default control settings */
-void amd_defaults   (double Control [ ]) ;
+void Highs_amd_defaults   (double Control [ ]) ;
 
 /* amd_control: prints the control settings */
-void amd_control    (double Control [ ]) ;
+void Highs_amd_control    (double Control [ ]) ;
 
 /* amd_info: prints the statistics */
-void amd_info       (double Info [ ]) ;
+void Highs_amd_info       (double Info [ ]) ;
 
 #ifdef __cplusplus
 }
diff --git a/extern/amd/amd_1.c b/extern/amd/amd_1.c
@@ -167,6 +167,6 @@ void amd_1
     /* order the matrix */
     /* --------------------------------------------------------------------- */
 
-    amd_2 (n, Pe, Iw, Len, iwlen, pfree,
+    Highs_amd_2 (n, Pe, Iw, Len, iwlen, pfree,
 	Nv, Pinv, P, Head, Elen, Degree, W, Control, Info) ;
 }
diff --git a/extern/amd/amd_2.c b/extern/amd/amd_2.c
@@ -39,7 +39,7 @@ static amd_int clear_flag (amd_int wflg, amd_int wbig, amd_int W [ ], amd_int n)
 /* === AMD_2 =============================================================== */
 /* ========================================================================= */
 
-void amd_2
+void Highs_amd_2
 (
     amd_int n,		/* A is n-by-n, where n > 0 */
     amd_int Pe [ ],		/* Pe [0..n-1]: index in Iw of row i on input */
diff --git a/extern/amd/amd_control.c b/extern/amd/amd_control.c
@@ -15,7 +15,7 @@
 
 #include "amd_internal.h"
 
-void amd_control
+void Highs_amd_control
 (
     double Control [ ]
 )
@@ -34,31 +34,31 @@ void amd_control
 	aggressive = AMD_DEFAULT_AGGRESSIVE ;
     }
 
-    SUITESPARSE_PRINTF ((
+    printf (
         "\nAMD version %d.%d.%d, %s: approximate minimum degree ordering\n"
 	"    dense row parameter: %g\n", AMD_MAIN_VERSION, AMD_SUB_VERSION,
-	AMD_SUBSUB_VERSION, AMD_DATE, alpha)) ;
+	AMD_SUBSUB_VERSION, AMD_DATE, alpha) ;
 
     if (alpha < 0)
     {
-	SUITESPARSE_PRINTF (("    no rows treated as dense\n")) ;
+	printf ("    no rows treated as dense\n") ;
     }
     else
     {
-	SUITESPARSE_PRINTF ((
+	printf (
 	"    (rows with more than max (%g * sqrt (n), 16) entries are\n"
 	"    considered \"dense\", and placed last in output permutation)\n",
-	alpha)) ;
+	alpha) ;
     }
 
     if (aggressive)
     {
-	SUITESPARSE_PRINTF (("    aggressive absorption:  yes\n")) ;
+	printf ("    aggressive absorption:  yes\n") ;
     }
     else
     {
-	SUITESPARSE_PRINTF (("    aggressive absorption:  no\n")) ;
+	printf ("    aggressive absorption:  no\n") ;
     }
 
-    SUITESPARSE_PRINTF (("    size of AMD integer: %lu\n\n", sizeof (amd_int))) ;
+    printf ("    size of AMD integer: %lu\n\n", sizeof (amd_int)) ;
 }
diff --git a/extern/amd/amd_defaults.c b/extern/amd/amd_defaults.c
@@ -18,7 +18,7 @@
 /* === AMD defaults ======================================================== */
 /* ========================================================================= */
 
-void amd_defaults
+void Highs_amd_defaults
 (
     double Control [ ]
 )
diff --git a/extern/amd/amd_info.c b/extern/amd/amd_info.c
@@ -14,17 +14,17 @@
 
 #include "amd_internal.h"
 
-#define PRI(format,x) { if (x >= 0) { SUITESPARSE_PRINTF ((format, x)) ; }}
+#define PRI(format,x) { if (x >= 0) { printf (format, x) ; }}
 
-void amd_info
+void Highs_amd_info
 (
     double Info [ ]
 )
 {
     double n, ndiv, nmultsubs_ldl, nmultsubs_lu, lnz, lnzd ;
 
-    SUITESPARSE_PRINTF (("\nAMD version %d.%d.%d, %s, results:\n",
-	AMD_MAIN_VERSION, AMD_SUB_VERSION, AMD_SUBSUB_VERSION, AMD_DATE)) ;
+    printf ("\nAMD version %d.%d.%d, %s, results:\n",
+	AMD_MAIN_VERSION, AMD_SUB_VERSION, AMD_SUBSUB_VERSION, AMD_DATE) ;
 
     if (!Info)
     {
@@ -39,26 +39,26 @@ void amd_info
     lnzd = (n >= 0 && lnz >= 0) ? (n + lnz) : (-1) ;
 
     /* AMD return status */
-    SUITESPARSE_PRINTF (("    status: ")) ;
+    printf ("    status: ") ;
     if (Info [AMD_STATUS] == AMD_OK)
     {
-	SUITESPARSE_PRINTF (("OK\n")) ;
+	printf ("OK\n") ;
     }
     else if (Info [AMD_STATUS] == AMD_OUT_OF_MEMORY)
     {
-	SUITESPARSE_PRINTF (("out of memory\n")) ;
+	printf ("out of memory\n") ;
     }
     else if (Info [AMD_STATUS] == AMD_INVALID)
     {
-	SUITESPARSE_PRINTF (("invalid matrix\n")) ;
+	printf ("invalid matrix\n") ;
     }
     else if (Info [AMD_STATUS] == AMD_OK_BUT_JUMBLED)
     {
-	SUITESPARSE_PRINTF (("OK, but jumbled\n")) ;
+	printf ("OK, but jumbled\n") ;
     }
     else
     {
-	SUITESPARSE_PRINTF (("unknown\n")) ;
+	printf ("unknown\n") ;
     }
 
     /* statistics about the input matrix */
@@ -81,11 +81,11 @@ void amd_info
 	Info [AMD_NCMPA]) ;
 
     /* statistics about the ordering quality */
-    SUITESPARSE_PRINTF (("\n"
+    printf ("\n"
 	"    The following approximate statistics are for a subsequent\n"
 	"    factorization of A(P,P) + A(P,P)'.  They are slight upper\n"
 	"    bounds if there are no dense rows/columns in A+A', and become\n"
-	"    looser if dense rows/columns exist.\n\n")) ;
+	"    looser if dense rows/columns exist.\n\n") ;
 
     PRI ("    nonzeros in L (excluding diagonal):                 %.20g\n",
 	lnz) ;
@@ -104,7 +104,7 @@ void amd_info
 
     if (n >= 0 && ndiv >= 0 && nmultsubs_ldl >= 0 && nmultsubs_lu >= 0)
     {
-	SUITESPARSE_PRINTF (("\n"
+	printf ("\n"
 	"    chol flop count for real A, sqrt counted as 1 flop: %.20g\n"
 	"    LDL' flop count for real A:                         %.20g\n"
 	"    LDL' flop count for complex A:                      %.20g\n"
@@ -114,6 +114,6 @@ void amd_info
 	    ndiv + 2*nmultsubs_ldl,
 	  9*ndiv + 8*nmultsubs_ldl,
 	    ndiv + 2*nmultsubs_lu,
-	  9*ndiv + 8*nmultsubs_lu)) ;
+	  9*ndiv + 8*nmultsubs_lu) ;
     }
 }
diff --git a/extern/amd/amd_order.c b/extern/amd/amd_order.c
@@ -18,7 +18,7 @@
 /* === AMD_order =========================================================== */
 /* ========================================================================= */
 
-int amd_order
+int Highs_amd_order
 (
     amd_int n,
     const amd_int Ap [ ],
@@ -76,7 +76,7 @@ int amd_order
     }
 
     /* check the input matrix:	AMD_OK, AMD_INVALID, or AMD_OK_BUT_JUMBLED */
-    status = amd_valid (n, n, Ap, Ai) ;
+    status = Highs_amd_valid (n, n, Ap, Ai) ;
 
     if (status == AMD_INVALID)
     {
@@ -86,15 +86,15 @@ int amd_order
 
     /* allocate two size-n integer workspaces */
     size_t nn = (size_t) n ;
-    Len  = SuiteSparse_malloc (nn, sizeof (amd_int)) ;
-    Pinv = SuiteSparse_malloc (nn, sizeof (amd_int)) ;
+    Len  = Highs_SuiteSparse_malloc (nn, sizeof (amd_int)) ;
+    Pinv = Highs_SuiteSparse_malloc (nn, sizeof (amd_int)) ;
     mem += n ;
     mem += n ;
     if (!Len || !Pinv)
     {
 	/* :: out of memory :: */
-	SuiteSparse_free (Len) ;
-	SuiteSparse_free (Pinv) ;
+	Highs_SuiteSparse_free (Len) ;
+	Highs_SuiteSparse_free (Pinv) ;
 	if (info) Info [AMD_STATUS] = AMD_OUT_OF_MEMORY ;
 	return (AMD_OUT_OF_MEMORY) ;
     }
@@ -103,17 +103,17 @@ int amd_order
     {
 	/* sort the input matrix and remove duplicate entries */
 	
-	Rp = SuiteSparse_malloc (nn+1, sizeof (amd_int)) ;
-	Ri = SuiteSparse_malloc (nz,  sizeof (amd_int)) ;
+	Rp = Highs_SuiteSparse_malloc (nn+1, sizeof (amd_int)) ;
+	Ri = Highs_SuiteSparse_malloc (nz,  sizeof (amd_int)) ;
 	mem += (n+1) ;
 	mem += MAX (nz,1) ;
 	if (!Rp || !Ri)
 	{
 	    /* :: out of memory :: */
-	    SuiteSparse_free (Rp) ;
-	    SuiteSparse_free (Ri) ;
-	    SuiteSparse_free (Len) ;
-	    SuiteSparse_free (Pinv) ;
+	    Highs_SuiteSparse_free (Rp) ;
+	    Highs_SuiteSparse_free (Ri) ;
+	    Highs_SuiteSparse_free (Len) ;
+	    Highs_SuiteSparse_free (Pinv) ;
 	    if (info) Info [AMD_STATUS] = AMD_OUT_OF_MEMORY ;
 	    return (AMD_OUT_OF_MEMORY) ;
 	}
@@ -156,16 +156,16 @@ int amd_order
     ok = ok && (slen < SIZE_T_MAX / sizeof (amd_int)) ; /* check for overflow */
     if (ok)
     {
-	S = SuiteSparse_malloc (slen, sizeof (amd_int)) ;
+	S = Highs_SuiteSparse_malloc (slen, sizeof (amd_int)) ;
     }
     
     if (!S)
     {
 	/* :: out of memory :: (or problem too large) */
-	SuiteSparse_free (Rp) ;
-	SuiteSparse_free (Ri) ;
-	SuiteSparse_free (Len) ;
-	SuiteSparse_free (Pinv) ;
+	Highs_SuiteSparse_free (Rp) ;
+	Highs_SuiteSparse_free (Ri) ;
+	Highs_SuiteSparse_free (Len) ;
+	Highs_SuiteSparse_free (Pinv) ;
 	if (info) Info [AMD_STATUS] = AMD_OUT_OF_MEMORY ;
 	return (AMD_OUT_OF_MEMORY) ;
     }
@@ -185,11 +185,11 @@ int amd_order
     /* free the workspace */
     /* --------------------------------------------------------------------- */
 
-    SuiteSparse_free (Rp) ;
-    SuiteSparse_free (Ri) ;
-    SuiteSparse_free (Len) ;
-    SuiteSparse_free (Pinv) ;
-    SuiteSparse_free (S) ;
+    Highs_SuiteSparse_free (Rp) ;
+    Highs_SuiteSparse_free (Ri) ;
+    Highs_SuiteSparse_free (Len) ;
+    Highs_SuiteSparse_free (Pinv) ;
+    Highs_SuiteSparse_free (S) ;
     if (info) Info [AMD_STATUS] = status ;
     return (status) ;	    /* successful ordering */
 }
diff --git a/extern/amd/amd_valid.c b/extern/amd/amd_valid.c
@@ -35,7 +35,7 @@
 
 #include "amd_internal.h"
 
-int amd_valid
+int Highs_amd_valid
 (
     /* inputs, not modified on output: */
     amd_int n_row,		/* A is n_row-by-n_col */
diff --git a/extern/rcm/rcm.cpp b/extern/rcm/rcm.cpp
@@ -745,8 +745,9 @@ void root_find(HighsInt* root, HighsInt adj_num, const HighsInt adj_row[],
 }
 //****************************************************************************80
 
-HighsInt genrcm(HighsInt node_num, HighsInt adj_num, const HighsInt adj_row[],
-                const HighsInt adj[], HighsInt perm[])
+HighsInt Highs_genrcm(HighsInt node_num, HighsInt adj_num,
+                      const HighsInt adj_row[], const HighsInt adj[],
+                      HighsInt perm[])
 
 //****************************************************************************80
 //
diff --git a/extern/rcm/rcm.h b/extern/rcm/rcm.h
@@ -15,7 +15,8 @@
 // - Input matrix provided with zero-base numbering.
 //
 
-HighsInt genrcm(HighsInt node_num, HighsInt adj_num, const HighsInt adj_row[],
-                const HighsInt adj[], HighsInt perm[]);
+HighsInt Highs_genrcm(HighsInt node_num, HighsInt adj_num,
+                      const HighsInt adj_row[], const HighsInt adj[],
+                      HighsInt perm[]);
 
 #endif
diff --git a/highs/ipm/hipo/factorhighs/Analyse.cpp b/highs/ipm/hipo/factorhighs/Analyse.cpp

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`
`14`	`14`	`#include "SuiteSparse_config.h"`
`15`	`15`
`16`		`-void SuiteSparse_malloc / pointer to allocated block of memory */`
	`16`	`+void Highs_SuiteSparse_malloc / pointer to allocated block of memory */`
`17`	`17`	`(`
`18`	`18`	`size_t nitems, /* number of items to malloc */`
`19`	`19`	`size_t size_of_item /* sizeof each item */`
`@@ -41,7 +41,7 @@ void SuiteSparse_malloc / pointer to allocated block of memory */`
`41`	`41`	`/* SuiteSparse_free: free wrapper */`
`42`	`42`	`/* -------------------------------------------------------------------------- */`
`43`	`43`
`44`		`-void SuiteSparse_free / always returns NULL */`
	`44`	`+void Highs_SuiteSparse_free / always returns NULL */`
`45`	`45`	`(`
`46`	`46`	`void p / block to free */`
`47`	`47`	`)`
Original file line number	Diff line number	Diff line change
`@@ -167,6 +167,6 @@ void amd_1`
`167`	`167`	`/* order the matrix */`
`168`	`168`	`/* --------------------------------------------------------------------- */`
`169`	`169`
`170`		`- amd_2 (n, Pe, Iw, Len, iwlen, pfree,`
	`170`	`+ Highs_amd_2 (n, Pe, Iw, Len, iwlen, pfree,`
`171`	`171`	`Nv, Pinv, P, Head, Elen, Degree, W, Control, Info) ;`
`172`	`172`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ static amd_int clear_flag (amd_int wflg, amd_int wbig, amd_int W [ ], amd_int n)`
`39`	`39`	`/* === AMD_2 =============================================================== */`
`40`	`40`	`/* ========================================================================= */`
`41`	`41`
`42`		`-void amd_2`
	`42`	`+void Highs_amd_2`
`43`	`43`	`(`
`44`	`44`	`amd_int n, /* A is n-by-n, where n > 0 */`
`45`	`45`	`amd_int Pe [ ], /* Pe [0..n-1]: index in Iw of row i on input */`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@`
`15`	`15`
`16`	`16`	`#include "amd_internal.h"`
`17`	`17`
`18`		`-void amd_control`
	`18`	`+void Highs_amd_control`
`19`	`19`	`(`
`20`	`20`	`double Control [ ]`
`21`	`21`	`)`
`@@ -34,31 +34,31 @@ void amd_control`
`34`	`34`	`aggressive = AMD_DEFAULT_AGGRESSIVE ;`
`35`	`35`	`}`
`36`	`36`
`37`		`- SUITESPARSE_PRINTF ((`
	`37`	`+ printf (`
`38`	`38`	`"\nAMD version %d.%d.%d, %s: approximate minimum degree ordering\n"`
`39`	`39`	`" dense row parameter: %g\n", AMD_MAIN_VERSION, AMD_SUB_VERSION,`
`40`		`- AMD_SUBSUB_VERSION, AMD_DATE, alpha)) ;`
	`40`	`+ AMD_SUBSUB_VERSION, AMD_DATE, alpha) ;`
`41`	`41`
`42`	`42`	`if (alpha < 0)`
`43`	`43`	`{`
`44`		`- SUITESPARSE_PRINTF ((" no rows treated as dense\n")) ;`
	`44`	`+ printf (" no rows treated as dense\n") ;`
`45`	`45`	`}`
`46`	`46`	`else`
`47`	`47`	`{`
`48`		`- SUITESPARSE_PRINTF ((`
	`48`	`+ printf (`
`49`	`49`	`" (rows with more than max (%g * sqrt (n), 16) entries are\n"`
`50`	`50`	`" considered \"dense\", and placed last in output permutation)\n",`
`51`		`- alpha)) ;`
	`51`	`+ alpha) ;`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`if (aggressive)`
`55`	`55`	`{`
`56`		`- SUITESPARSE_PRINTF ((" aggressive absorption: yes\n")) ;`
	`56`	`+ printf (" aggressive absorption: yes\n") ;`
`57`	`57`	`}`
`58`	`58`	`else`
`59`	`59`	`{`
`60`		`- SUITESPARSE_PRINTF ((" aggressive absorption: no\n")) ;`
	`60`	`+ printf (" aggressive absorption: no\n") ;`
`61`	`61`	`}`
`62`	`62`
`63`		`- SUITESPARSE_PRINTF ((" size of AMD integer: %lu\n\n", sizeof (amd_int))) ;`
	`63`	`+ printf (" size of AMD integer: %lu\n\n", sizeof (amd_int)) ;`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@`
`18`	`18`	`/* === AMD defaults ======================================================== */`
`19`	`19`	`/* ========================================================================= */`
`20`	`20`
`21`		`-void amd_defaults`
	`21`	`+void Highs_amd_defaults`
`22`	`22`	`(`
`23`	`23`	`double Control [ ]`
`24`	`24`	`)`
Original file line number	Diff line number	Diff line change
`@@ -14,17 +14,17 @@`
`14`	`14`
`15`	`15`	`#include "amd_internal.h"`
`16`	`16`
`17`		`-#define PRI(format,x) { if (x >= 0) { SUITESPARSE_PRINTF ((format, x)) ; }}`
	`17`	`+#define PRI(format,x) { if (x >= 0) { printf (format, x) ; }}`
`18`	`18`
`19`		`-void amd_info`
	`19`	`+void Highs_amd_info`
`20`	`20`	`(`
`21`	`21`	`double Info [ ]`
`22`	`22`	`)`
`23`	`23`	`{`
`24`	`24`	`double n, ndiv, nmultsubs_ldl, nmultsubs_lu, lnz, lnzd ;`
`25`	`25`
`26`		`- SUITESPARSE_PRINTF (("\nAMD version %d.%d.%d, %s, results:\n",`
`27`		`- AMD_MAIN_VERSION, AMD_SUB_VERSION, AMD_SUBSUB_VERSION, AMD_DATE)) ;`
	`26`	`+ printf ("\nAMD version %d.%d.%d, %s, results:\n",`
	`27`	`+ AMD_MAIN_VERSION, AMD_SUB_VERSION, AMD_SUBSUB_VERSION, AMD_DATE) ;`
`28`	`28`
`29`	`29`	`if (!Info)`
`30`	`30`	`{`
`@@ -39,26 +39,26 @@ void amd_info`
`39`	`39`	`lnzd = (n >= 0 && lnz >= 0) ? (n + lnz) : (-1) ;`
`40`	`40`
`41`	`41`	`/* AMD return status */`
`42`		`- SUITESPARSE_PRINTF ((" status: ")) ;`
	`42`	`+ printf (" status: ") ;`
`43`	`43`	`if (Info [AMD_STATUS] == AMD_OK)`
`44`	`44`	`{`
`45`		`- SUITESPARSE_PRINTF (("OK\n")) ;`
	`45`	`+ printf ("OK\n") ;`
`46`	`46`	`}`
`47`	`47`	`else if (Info [AMD_STATUS] == AMD_OUT_OF_MEMORY)`
`48`	`48`	`{`
`49`		`- SUITESPARSE_PRINTF (("out of memory\n")) ;`
	`49`	`+ printf ("out of memory\n") ;`
`50`	`50`	`}`
`51`	`51`	`else if (Info [AMD_STATUS] == AMD_INVALID)`
`52`	`52`	`{`
`53`		`- SUITESPARSE_PRINTF (("invalid matrix\n")) ;`
	`53`	`+ printf ("invalid matrix\n") ;`
`54`	`54`	`}`
`55`	`55`	`else if (Info [AMD_STATUS] == AMD_OK_BUT_JUMBLED)`
`56`	`56`	`{`
`57`		`- SUITESPARSE_PRINTF (("OK, but jumbled\n")) ;`
	`57`	`+ printf ("OK, but jumbled\n") ;`
`58`	`58`	`}`
`59`	`59`	`else`
`60`	`60`	`{`
`61`		`- SUITESPARSE_PRINTF (("unknown\n")) ;`
	`61`	`+ printf ("unknown\n") ;`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`/* statistics about the input matrix */`
`@@ -81,11 +81,11 @@ void amd_info`
`81`	`81`	`Info [AMD_NCMPA]) ;`
`82`	`82`
`83`	`83`	`/* statistics about the ordering quality */`
`84`		`- SUITESPARSE_PRINTF (("\n"`
	`84`	`+ printf ("\n"`
`85`	`85`	`" The following approximate statistics are for a subsequent\n"`
`86`	`86`	`" factorization of A(P,P) + A(P,P)'. They are slight upper\n"`
`87`	`87`	`" bounds if there are no dense rows/columns in A+A', and become\n"`
`88`		`- " looser if dense rows/columns exist.\n\n")) ;`
	`88`	`+ " looser if dense rows/columns exist.\n\n") ;`
`89`	`89`
`90`	`90`	`PRI (" nonzeros in L (excluding diagonal): %.20g\n",`
`91`	`91`	`lnz) ;`
`@@ -104,7 +104,7 @@ void amd_info`
`104`	`104`
`105`	`105`	`if (n >= 0 && ndiv >= 0 && nmultsubs_ldl >= 0 && nmultsubs_lu >= 0)`
`106`	`106`	`{`
`107`		`- SUITESPARSE_PRINTF (("\n"`
	`107`	`+ printf ("\n"`
`108`	`108`	`" chol flop count for real A, sqrt counted as 1 flop: %.20g\n"`
`109`	`109`	`" LDL' flop count for real A: %.20g\n"`
`110`	`110`	`" LDL' flop count for complex A: %.20g\n"`
`@@ -114,6 +114,6 @@ void amd_info`
`114`	`114`	`ndiv + 2*nmultsubs_ldl,`
`115`	`115`	`9ndiv + 8nmultsubs_ldl,`
`116`	`116`	`ndiv + 2*nmultsubs_lu,`
`117`		`- 9ndiv + 8nmultsubs_lu)) ;`
	`117`	`+ 9ndiv + 8nmultsubs_lu) ;`
`118`	`118`	`}`
`119`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@`
`35`	`35`
`36`	`36`	`#include "amd_internal.h"`
`37`	`37`
`38`		`-int amd_valid`
	`38`	`+int Highs_amd_valid`
`39`	`39`	`(`
`40`	`40`	`/* inputs, not modified on output: */`
`41`	`41`	`amd_int n_row, /* A is n_row-by-n_col */`