[packages/CHOLMOD.git] / CHOLMOD-metis.patch

--- CHOLMOD/Partition/cholmod_metis.c.orig	2012-05-29 17:02:05.000000000 +0200
+++ CHOLMOD/Partition/cholmod_metis.c	2012-06-27 18:05:33.131952214 +0200
@@ -75,7 +75,7 @@
 #ifdef DUMP_GRAPH
 #include <stdio.h>
 /* After dumping the graph with this routine, run "onmetis metisgraph" */
-static void dumpgraph (idxtype *Mp, idxtype *Mi, SuiteSparse_long n,
+static void dumpgraph (idx_t *Mp, idx_t *Mi, SuiteSparse_long n,
     cholmod_common *Common)
 {
     SuiteSparse_long i, j, p, nz ;
@@ -161,7 +161,7 @@
     s = GUESS ((double) nz, (double) n) ;
     s *= Common->metis_memory ;
 
-    if (s * sizeof (idxtype) >= ((double) Size_max))
+    if (s * sizeof (idx_t) >= ((double) Size_max))
     {
 	/* don't even attempt to malloc such a large block */
 	return (FALSE) ;
@@ -172,7 +172,7 @@
     metis_guard *= Common->metis_memory ;
 
     /* attempt to malloc the block */
-    p = CHOLMOD(malloc) (metis_guard, sizeof (idxtype), Common) ;
+    p = CHOLMOD(malloc) (metis_guard, sizeof (idx_t), Common) ;
     if (p == NULL)
     {
 	/* failure - return out-of-memory condition */
@@ -180,7 +180,7 @@
     }
 
     /* success - free the block */
-    CHOLMOD(free) (metis_guard, sizeof (idxtype), p, Common) ;
+    CHOLMOD(free) (metis_guard, sizeof (idx_t), p, Common) ;
     return (TRUE) ;
 }
 
@@ -210,7 +210,7 @@
 )
 {
     Int *Ap, *Ai ;
-    idxtype *Mp, *Mi, *Mnw, *Mew, *Mpart ;
+    idx_t *Mp, *Mi, *Mnw, *Mew, *Mpart ;
     Int n, nleft, nright, j, p, csep, total_weight, lightest, nz ;
     int Opt [8], nn, csp ;
     size_t n1 ;
@@ -259,7 +259,7 @@
     /* ---------------------------------------------------------------------- */
 
 #ifdef LONG
-    if (sizeof (Int) > sizeof (idxtype) && MAX (n,nz) > INT_MAX / sizeof (int))
+    if (sizeof (Int) > sizeof (idx_t) && MAX (n,nz) > INT_MAX / sizeof (int))
     {
 	/* CHOLMOD's matrix is too large for METIS */
 	return (EMPTY) ;
@@ -282,34 +282,34 @@
     DEBUG (for (j = 0 ; j < n ; j++) ASSERT (Anw [j] > 0)) ;
 
     /* ---------------------------------------------------------------------- */
-    /* copy Int to METIS idxtype, if necessary */
+    /* copy Int to METIS idx_t, if necessary */
     /* ---------------------------------------------------------------------- */
 
     DEBUG (for (j = 0 ; j < nz ; j++) ASSERT (Aew [j] > 0)) ;
-    if (sizeof (Int) == sizeof (idxtype))
+    if (sizeof (Int) == sizeof (idx_t))
     {
 	/* this is the typical case */
-	Mi    = (idxtype *) Ai ;
-	Mew   = (idxtype *) Aew ;
-	Mp    = (idxtype *) Ap ;
-	Mnw   = (idxtype *) Anw ;
-	Mpart = (idxtype *) Partition ;
+	Mi    = (idx_t *) Ai ;
+	Mew   = (idx_t *) Aew ;
+	Mp    = (idx_t *) Ap ;
+	Mnw   = (idx_t *) Anw ;
+	Mpart = (idx_t *) Partition ;
     }
     else
     {
-	/* idxtype and Int differ; copy the graph into the METIS idxtype */
-	Mi    = CHOLMOD(malloc) (nz, sizeof (idxtype), Common) ;
-	Mew   = CHOLMOD(malloc) (nz, sizeof (idxtype), Common) ;
-	Mp    = CHOLMOD(malloc) (n1, sizeof (idxtype), Common) ;
-	Mnw   = CHOLMOD(malloc) (n,  sizeof (idxtype), Common) ;
-	Mpart = CHOLMOD(malloc) (n,  sizeof (idxtype), Common) ;
+	/* idx_t and Int differ; copy the graph into the METIS idx_t */
+	Mi    = CHOLMOD(malloc) (nz, sizeof (idx_t), Common) ;
+	Mew   = CHOLMOD(malloc) (nz, sizeof (idx_t), Common) ;
+	Mp    = CHOLMOD(malloc) (n1, sizeof (idx_t), Common) ;
+	Mnw   = CHOLMOD(malloc) (n,  sizeof (idx_t), Common) ;
+	Mpart = CHOLMOD(malloc) (n,  sizeof (idx_t), Common) ;
 	if (Common->status < CHOLMOD_OK)
 	{
-	    CHOLMOD(free) (nz, sizeof (idxtype), Mi,    Common) ;
-	    CHOLMOD(free) (nz, sizeof (idxtype), Mew,   Common) ;
-	    CHOLMOD(free) (n1, sizeof (idxtype), Mp,    Common) ;
-	    CHOLMOD(free) (n,  sizeof (idxtype), Mnw,   Common) ;
-	    CHOLMOD(free) (n,  sizeof (idxtype), Mpart, Common) ;
+	    CHOLMOD(free) (nz, sizeof (idx_t), Mi,    Common) ;
+	    CHOLMOD(free) (nz, sizeof (idx_t), Mew,   Common) ;
+	    CHOLMOD(free) (n1, sizeof (idx_t), Mp,    Common) ;
+	    CHOLMOD(free) (n,  sizeof (idx_t), Mnw,   Common) ;
+	    CHOLMOD(free) (n,  sizeof (idx_t), Mpart, Common) ;
 	    return (EMPTY) ;
 	}
 	for (p = 0 ; p < nz ; p++)
@@ -337,13 +337,13 @@
     if (!metis_memory_ok (n, nz, Common))
     {
 	/* METIS might ask for too much memory and thus terminate the program */
-	if (sizeof (Int) != sizeof (idxtype))
+	if (sizeof (Int) != sizeof (idx_t))
 	{
-	    CHOLMOD(free) (nz, sizeof (idxtype), Mi,    Common) ;
-	    CHOLMOD(free) (nz, sizeof (idxtype), Mew,   Common) ;
-	    CHOLMOD(free) (n1, sizeof (idxtype), Mp,    Common) ;
-	    CHOLMOD(free) (n,  sizeof (idxtype), Mnw,   Common) ;
-	    CHOLMOD(free) (n,  sizeof (idxtype), Mpart, Common) ;
+	    CHOLMOD(free) (nz, sizeof (idx_t), Mi,    Common) ;
+	    CHOLMOD(free) (nz, sizeof (idx_t), Mew,   Common) ;
+	    CHOLMOD(free) (n1, sizeof (idx_t), Mp,    Common) ;
+	    CHOLMOD(free) (n,  sizeof (idx_t), Mnw,   Common) ;
+	    CHOLMOD(free) (n,  sizeof (idx_t), Mpart, Common) ;
 	}
 	return (EMPTY) ;
     }
@@ -369,27 +369,27 @@
 #endif
 
     nn = n ;
-    METIS_NodeComputeSeparator (&nn, Mp, Mi, Mnw, Mew, Opt, &csp, Mpart) ;
+    METIS_ComputeVertexSeparator (&nn, Mp, Mi, Mnw, Opt, &csp, Mpart) ;
     n = nn ;
     csep = csp ;
 
     PRINT1 (("METIS csep "ID"\n", csep)) ;
 
     /* ---------------------------------------------------------------------- */
-    /* copy the results back from idxtype, if required */
+    /* copy the results back from idx_t, if required */
     /* ---------------------------------------------------------------------- */
 
-    if (sizeof (Int) != sizeof (idxtype))
+    if (sizeof (Int) != sizeof (idx_t))
     {
 	for (j = 0 ; j < n ; j++)
 	{
 	    Partition [j] = Mpart [j] ;
 	}
-	CHOLMOD(free) (nz, sizeof (idxtype), Mi,    Common) ;
-	CHOLMOD(free) (nz, sizeof (idxtype), Mew,   Common) ;
-	CHOLMOD(free) (n1, sizeof (idxtype), Mp,    Common) ;
-	CHOLMOD(free) (n,  sizeof (idxtype), Mnw,   Common) ;
-	CHOLMOD(free) (n,  sizeof (idxtype), Mpart, Common) ;
+	CHOLMOD(free) (nz, sizeof (idx_t), Mi,    Common) ;
+	CHOLMOD(free) (nz, sizeof (idx_t), Mew,   Common) ;
+	CHOLMOD(free) (n1, sizeof (idx_t), Mp,    Common) ;
+	CHOLMOD(free) (n,  sizeof (idx_t), Mnw,   Common) ;
+	CHOLMOD(free) (n,  sizeof (idx_t), Mpart, Common) ;
     }
 
     /* ---------------------------------------------------------------------- */
@@ -507,7 +507,7 @@
 {
     double d ;
     Int *Iperm, *Iwork, *Bp, *Bi ;
-    idxtype *Mp, *Mi, *Mperm, *Miperm ;
+    idx_t *Mp, *Mi, *Mperm, *Miperm ;
     cholmod_sparse *B ;
     Int i, j, n, nz, p, identity, uncol ;
     int Opt [8], nn, zero = 0 ;
@@ -600,7 +600,7 @@
     /* ---------------------------------------------------------------------- */
 
 #ifdef LONG
-    if (sizeof (Int) > sizeof (idxtype) && MAX (n,nz) > INT_MAX / sizeof (int))
+    if (sizeof (Int) > sizeof (idx_t) && MAX (n,nz) > INT_MAX / sizeof (int))
     {
 	/* CHOLMOD's matrix is too large for METIS */
 	CHOLMOD(free_sparse) (&B, Common) ;
@@ -629,29 +629,29 @@
     /* allocate the METIS input arrays, if needed */
     /* ---------------------------------------------------------------------- */
 
-    if (sizeof (Int) == sizeof (idxtype))
+    if (sizeof (Int) == sizeof (idx_t))
     {
 	/* This is the typical case. */
-	Miperm = (idxtype *) Iperm ;
-	Mperm  = (idxtype *) Perm ;
-	Mp     = (idxtype *) Bp ;
-	Mi     = (idxtype *) Bi ;
+	Miperm = (idx_t *) Iperm ;
+	Mperm  = (idx_t *) Perm ;
+	Mp     = (idx_t *) Bp ;
+	Mi     = (idx_t *) Bi ;
     }
     else
     {
-	/* allocate graph for METIS only if Int and idxtype differ */
-	Miperm = CHOLMOD(malloc) (n,  sizeof (idxtype), Common) ;
-	Mperm  = CHOLMOD(malloc) (n,  sizeof (idxtype), Common) ;
-	Mp     = CHOLMOD(malloc) (n1, sizeof (idxtype), Common) ;
-	Mi     = CHOLMOD(malloc) (nz, sizeof (idxtype), Common) ;
+	/* allocate graph for METIS only if Int and idx_t differ */
+	Miperm = CHOLMOD(malloc) (n,  sizeof (idx_t), Common) ;
+	Mperm  = CHOLMOD(malloc) (n,  sizeof (idx_t), Common) ;
+	Mp     = CHOLMOD(malloc) (n1, sizeof (idx_t), Common) ;
+	Mi     = CHOLMOD(malloc) (nz, sizeof (idx_t), Common) ;
 	if (Common->status < CHOLMOD_OK)
 	{
 	    /* out of memory */
 	    CHOLMOD(free_sparse) (&B, Common) ;
-	    CHOLMOD(free) (n,  sizeof (idxtype), Miperm, Common) ;
-	    CHOLMOD(free) (n,  sizeof (idxtype), Mperm, Common) ;
-	    CHOLMOD(free) (n1, sizeof (idxtype), Mp, Common) ;
-	    CHOLMOD(free) (nz, sizeof (idxtype), Mi, Common) ;
+	    CHOLMOD(free) (n,  sizeof (idx_t), Miperm, Common) ;
+	    CHOLMOD(free) (n,  sizeof (idx_t), Mperm, Common) ;
+	    CHOLMOD(free) (n1, sizeof (idx_t), Mp, Common) ;
+	    CHOLMOD(free) (nz, sizeof (idx_t), Mi, Common) ;
 	    return (FALSE) ;
 	}
 	for (j = 0 ; j <= n ; j++)
@@ -740,16 +740,16 @@
     /* free the METIS input arrays */
     /* ---------------------------------------------------------------------- */
 
-    if (sizeof (Int) != sizeof (idxtype))
+    if (sizeof (Int) != sizeof (idx_t))
     {
 	for (i = 0 ; i < n ; i++)
 	{
 	    Perm [i] = (Int) (Mperm [i]) ;
 	}
-	CHOLMOD(free) (n,   sizeof (idxtype), Miperm, Common) ;
-	CHOLMOD(free) (n,   sizeof (idxtype), Mperm, Common) ;
-	CHOLMOD(free) (n+1, sizeof (idxtype), Mp, Common) ;
-	CHOLMOD(free) (nz,  sizeof (idxtype), Mi, Common) ;
+	CHOLMOD(free) (n,   sizeof (idx_t), Miperm, Common) ;
+	CHOLMOD(free) (n,   sizeof (idx_t), Mperm, Common) ;
+	CHOLMOD(free) (n+1, sizeof (idx_t), Mp, Common) ;
+	CHOLMOD(free) (nz,  sizeof (idx_t), Mi, Common) ;
     }
 
     CHOLMOD(free_sparse) (&B, Common) ;
Commit	Line	Data
fe7d741a JB	1	--- CHOLMOD/Partition/cholmod_metis.c.orig 2012-05-29 17:02:05.000000000 +0200
	2	+++ CHOLMOD/Partition/cholmod_metis.c 2012-06-27 18:05:33.131952214 +0200
	3	@@ -75,7 +75,7 @@
9f39e7e6 JB	4	#ifdef DUMP_GRAPH
	5	#include <stdio.h>
	6	/* After dumping the graph with this routine, run "onmetis metisgraph" */
fe7d741a JB	7	-static void dumpgraph (idxtype Mp, idxtype Mi, SuiteSparse_long n,
fe7d741a JB	8	+static void dumpgraph (idx_t Mp, idx_t Mi, SuiteSparse_long n,
9f39e7e6 JB	9	cholmod_common *Common)
9f39e7e6 JB	10	{
fe7d741a JB	11	SuiteSparse_long i, j, p, nz ;
fe7d741a JB	12	@@ -161,7 +161,7 @@
9f39e7e6 JB	13	s = GUESS ((double) nz, (double) n) ;
	14	s *= Common->metis_memory ;
	15
	16	- if (s * sizeof (idxtype) >= ((double) Size_max))
	17	+ if (s * sizeof (idx_t) >= ((double) Size_max))
	18	{
	19	/* don't even attempt to malloc such a large block */
	20	return (FALSE) ;
fe7d741a	21	@@ -172,7 +172,7 @@
9f39e7e6 JB	22	metis_guard *= Common->metis_memory ;
	23
	24	/* attempt to malloc the block */
	25	- p = CHOLMOD(malloc) (metis_guard, sizeof (idxtype), Common) ;
	26	+ p = CHOLMOD(malloc) (metis_guard, sizeof (idx_t), Common) ;
	27	if (p == NULL)
	28	{
	29	/* failure - return out-of-memory condition */
fe7d741a	30	@@ -180,7 +180,7 @@
9f39e7e6 JB	31	}
	32
	33	/* success - free the block */
	34	- CHOLMOD(free) (metis_guard, sizeof (idxtype), p, Common) ;
	35	+ CHOLMOD(free) (metis_guard, sizeof (idx_t), p, Common) ;
	36	return (TRUE) ;
	37	}
	38
fe7d741a	39	@@ -210,7 +210,7 @@
9f39e7e6 JB	40	)
	41	{
	42	Int Ap, Ai ;
	43	- idxtype Mp, Mi, Mnw, Mew, *Mpart ;
	44	+ idx_t Mp, Mi, Mnw, Mew, *Mpart ;
	45	Int n, nleft, nright, j, p, csep, total_weight, lightest, nz ;
	46	int Opt [8], nn, csp ;
	47	size_t n1 ;
fe7d741a	48	@@ -259,7 +259,7 @@
9f39e7e6 JB	49	/* ---------------------------------------------------------------------- */
	50
	51	#ifdef LONG
	52	- if (sizeof (Int) > sizeof (idxtype) && MAX (n,nz) > INT_MAX / sizeof (int))
	53	+ if (sizeof (Int) > sizeof (idx_t) && MAX (n,nz) > INT_MAX / sizeof (int))
	54	{
	55	/* CHOLMOD's matrix is too large for METIS */
	56	return (EMPTY) ;
fe7d741a	57	@@ -282,34 +282,34 @@
9f39e7e6 JB	58	DEBUG (for (j = 0 ; j < n ; j++) ASSERT (Anw [j] > 0)) ;
	59
	60	/* ---------------------------------------------------------------------- */
	61	- /* copy Int to METIS idxtype, if necessary */
	62	+ /* copy Int to METIS idx_t, if necessary */
	63	/* ---------------------------------------------------------------------- */
	64
	65	DEBUG (for (j = 0 ; j < nz ; j++) ASSERT (Aew [j] > 0)) ;
	66	- if (sizeof (Int) == sizeof (idxtype))
	67	+ if (sizeof (Int) == sizeof (idx_t))
	68	{
	69	/* this is the typical case */
	70	- Mi = (idxtype *) Ai ;
	71	- Mew = (idxtype *) Aew ;
	72	- Mp = (idxtype *) Ap ;
	73	- Mnw = (idxtype *) Anw ;
	74	- Mpart = (idxtype *) Partition ;
	75	+ Mi = (idx_t *) Ai ;
	76	+ Mew = (idx_t *) Aew ;
	77	+ Mp = (idx_t *) Ap ;
	78	+ Mnw = (idx_t *) Anw ;
	79	+ Mpart = (idx_t *) Partition ;
	80	}
	81	else
	82	{
	83	- /* idxtype and Int differ; copy the graph into the METIS idxtype */
	84	- Mi = CHOLMOD(malloc) (nz, sizeof (idxtype), Common) ;
	85	- Mew = CHOLMOD(malloc) (nz, sizeof (idxtype), Common) ;
	86	- Mp = CHOLMOD(malloc) (n1, sizeof (idxtype), Common) ;
	87	- Mnw = CHOLMOD(malloc) (n, sizeof (idxtype), Common) ;
	88	- Mpart = CHOLMOD(malloc) (n, sizeof (idxtype), Common) ;
	89	+ /* idx_t and Int differ; copy the graph into the METIS idx_t */
	90	+ Mi = CHOLMOD(malloc) (nz, sizeof (idx_t), Common) ;
	91	+ Mew = CHOLMOD(malloc) (nz, sizeof (idx_t), Common) ;
	92	+ Mp = CHOLMOD(malloc) (n1, sizeof (idx_t), Common) ;
	93	+ Mnw = CHOLMOD(malloc) (n, sizeof (idx_t), Common) ;
	94	+ Mpart = CHOLMOD(malloc) (n, sizeof (idx_t), Common) ;
	95	if (Common->status < CHOLMOD_OK)
	96	{
	97	- CHOLMOD(free) (nz, sizeof (idxtype), Mi, Common) ;
	98	- CHOLMOD(free) (nz, sizeof (idxtype), Mew, Common) ;
	99	- CHOLMOD(free) (n1, sizeof (idxtype), Mp, Common) ;
	100	- CHOLMOD(free) (n, sizeof (idxtype), Mnw, Common) ;
	101	- CHOLMOD(free) (n, sizeof (idxtype), Mpart, Common) ;
	102	+ CHOLMOD(free) (nz, sizeof (idx_t), Mi, Common) ;
	103	+ CHOLMOD(free) (nz, sizeof (idx_t), Mew, Common) ;
	104	+ CHOLMOD(free) (n1, sizeof (idx_t), Mp, Common) ;
	105	+ CHOLMOD(free) (n, sizeof (idx_t), Mnw, Common) ;
	106	+ CHOLMOD(free) (n, sizeof (idx_t), Mpart, Common) ;
	107	return (EMPTY) ;
	108	}
	109	for (p = 0 ; p < nz ; p++)
fe7d741a	110	@@ -337,13 +337,13 @@
9f39e7e6 JB	111	if (!metis_memory_ok (n, nz, Common))
	112	{
	113	/* METIS might ask for too much memory and thus terminate the program */
	114	- if (sizeof (Int) != sizeof (idxtype))
	115	+ if (sizeof (Int) != sizeof (idx_t))
	116	{
	117	- CHOLMOD(free) (nz, sizeof (idxtype), Mi, Common) ;
	118	- CHOLMOD(free) (nz, sizeof (idxtype), Mew, Common) ;
	119	- CHOLMOD(free) (n1, sizeof (idxtype), Mp, Common) ;
	120	- CHOLMOD(free) (n, sizeof (idxtype), Mnw, Common) ;
	121	- CHOLMOD(free) (n, sizeof (idxtype), Mpart, Common) ;
	122	+ CHOLMOD(free) (nz, sizeof (idx_t), Mi, Common) ;
	123	+ CHOLMOD(free) (nz, sizeof (idx_t), Mew, Common) ;
	124	+ CHOLMOD(free) (n1, sizeof (idx_t), Mp, Common) ;
	125	+ CHOLMOD(free) (n, sizeof (idx_t), Mnw, Common) ;
	126	+ CHOLMOD(free) (n, sizeof (idx_t), Mpart, Common) ;
	127	}
	128	return (EMPTY) ;
	129	}
fe7d741a	130	@@ -369,27 +369,27 @@
9f39e7e6 JB	131	#endif
	132
	133	nn = n ;
	134	- METIS_NodeComputeSeparator (&nn, Mp, Mi, Mnw, Mew, Opt, &csp, Mpart) ;
	135	+ METIS_ComputeVertexSeparator (&nn, Mp, Mi, Mnw, Opt, &csp, Mpart) ;
	136	n = nn ;
	137	csep = csp ;
	138
	139	PRINT1 (("METIS csep "ID"\n", csep)) ;
	140
	141	/* ---------------------------------------------------------------------- */
	142	- /* copy the results back from idxtype, if required */
	143	+ /* copy the results back from idx_t, if required */
	144	/* ---------------------------------------------------------------------- */
	145
	146	- if (sizeof (Int) != sizeof (idxtype))
	147	+ if (sizeof (Int) != sizeof (idx_t))
	148	{
	149	for (j = 0 ; j < n ; j++)
	150	{
	151	Partition [j] = Mpart [j] ;
	152	}
	153	- CHOLMOD(free) (nz, sizeof (idxtype), Mi, Common) ;
	154	- CHOLMOD(free) (nz, sizeof (idxtype), Mew, Common) ;
	155	- CHOLMOD(free) (n1, sizeof (idxtype), Mp, Common) ;
	156	- CHOLMOD(free) (n, sizeof (idxtype), Mnw, Common) ;
	157	- CHOLMOD(free) (n, sizeof (idxtype), Mpart, Common) ;
	158	+ CHOLMOD(free) (nz, sizeof (idx_t), Mi, Common) ;
	159	+ CHOLMOD(free) (nz, sizeof (idx_t), Mew, Common) ;
	160	+ CHOLMOD(free) (n1, sizeof (idx_t), Mp, Common) ;
	161	+ CHOLMOD(free) (n, sizeof (idx_t), Mnw, Common) ;
	162	+ CHOLMOD(free) (n, sizeof (idx_t), Mpart, Common) ;
	163	}
	164
	165	/* ---------------------------------------------------------------------- */
fe7d741a	166	@@ -507,7 +507,7 @@
9f39e7e6 JB	167	{
	168	double d ;
	169	Int Iperm, Iwork, Bp, Bi ;
	170	- idxtype Mp, Mi, Mperm, Miperm ;
	171	+ idx_t Mp, Mi, Mperm, Miperm ;
	172	cholmod_sparse *B ;
	173	Int i, j, n, nz, p, identity, uncol ;
	174	int Opt [8], nn, zero = 0 ;
fe7d741a	175	@@ -600,7 +600,7 @@
9f39e7e6 JB	176	/* ---------------------------------------------------------------------- */
	177
	178	#ifdef LONG
	179	- if (sizeof (Int) > sizeof (idxtype) && MAX (n,nz) > INT_MAX / sizeof (int))
	180	+ if (sizeof (Int) > sizeof (idx_t) && MAX (n,nz) > INT_MAX / sizeof (int))
	181	{
	182	/* CHOLMOD's matrix is too large for METIS */
	183	CHOLMOD(free_sparse) (&B, Common) ;
fe7d741a	184	@@ -629,29 +629,29 @@
9f39e7e6 JB	185	/* allocate the METIS input arrays, if needed */
	186	/* ---------------------------------------------------------------------- */
	187
	188	- if (sizeof (Int) == sizeof (idxtype))
	189	+ if (sizeof (Int) == sizeof (idx_t))
	190	{
	191	/* This is the typical case. */
	192	- Miperm = (idxtype *) Iperm ;
	193	- Mperm = (idxtype *) Perm ;
	194	- Mp = (idxtype *) Bp ;
	195	- Mi = (idxtype *) Bi ;
	196	+ Miperm = (idx_t *) Iperm ;
	197	+ Mperm = (idx_t *) Perm ;
	198	+ Mp = (idx_t *) Bp ;
	199	+ Mi = (idx_t *) Bi ;
	200	}
	201	else
	202	{
	203	- /* allocate graph for METIS only if Int and idxtype differ */
	204	- Miperm = CHOLMOD(malloc) (n, sizeof (idxtype), Common) ;
	205	- Mperm = CHOLMOD(malloc) (n, sizeof (idxtype), Common) ;
	206	- Mp = CHOLMOD(malloc) (n1, sizeof (idxtype), Common) ;
	207	- Mi = CHOLMOD(malloc) (nz, sizeof (idxtype), Common) ;
	208	+ /* allocate graph for METIS only if Int and idx_t differ */
	209	+ Miperm = CHOLMOD(malloc) (n, sizeof (idx_t), Common) ;
	210	+ Mperm = CHOLMOD(malloc) (n, sizeof (idx_t), Common) ;
	211	+ Mp = CHOLMOD(malloc) (n1, sizeof (idx_t), Common) ;
	212	+ Mi = CHOLMOD(malloc) (nz, sizeof (idx_t), Common) ;
	213	if (Common->status < CHOLMOD_OK)
	214	{
	215	/* out of memory */
	216	CHOLMOD(free_sparse) (&B, Common) ;
	217	- CHOLMOD(free) (n, sizeof (idxtype), Miperm, Common) ;
	218	- CHOLMOD(free) (n, sizeof (idxtype), Mperm, Common) ;
	219	- CHOLMOD(free) (n1, sizeof (idxtype), Mp, Common) ;
	220	- CHOLMOD(free) (nz, sizeof (idxtype), Mi, Common) ;
	221	+ CHOLMOD(free) (n, sizeof (idx_t), Miperm, Common) ;
	222	+ CHOLMOD(free) (n, sizeof (idx_t), Mperm, Common) ;
	223	+ CHOLMOD(free) (n1, sizeof (idx_t), Mp, Common) ;
	224	+ CHOLMOD(free) (nz, sizeof (idx_t), Mi, Common) ;
	225	return (FALSE) ;
	226	}
	227	for (j = 0 ; j <= n ; j++)
fe7d741a	228	@@ -740,16 +740,16 @@
9f39e7e6 JB	229	/* free the METIS input arrays */
	230	/* ---------------------------------------------------------------------- */
	231
	232	- if (sizeof (Int) != sizeof (idxtype))
	233	+ if (sizeof (Int) != sizeof (idx_t))
	234	{
	235	for (i = 0 ; i < n ; i++)
	236	{
	237	Perm [i] = (Int) (Mperm [i]) ;
	238	}
	239	- CHOLMOD(free) (n, sizeof (idxtype), Miperm, Common) ;
	240	- CHOLMOD(free) (n, sizeof (idxtype), Mperm, Common) ;
	241	- CHOLMOD(free) (n+1, sizeof (idxtype), Mp, Common) ;
	242	- CHOLMOD(free) (nz, sizeof (idxtype), Mi, Common) ;
	243	+ CHOLMOD(free) (n, sizeof (idx_t), Miperm, Common) ;
	244	+ CHOLMOD(free) (n, sizeof (idx_t), Mperm, Common) ;
	245	+ CHOLMOD(free) (n+1, sizeof (idx_t), Mp, Common) ;
	246	+ CHOLMOD(free) (nz, sizeof (idx_t), Mi, Common) ;
	247	}
	248
	249	CHOLMOD(free_sparse) (&B, Common) ;