@smake/eigen 1.1.0 → 1.1.1

package/eigen/Eigen/src/OrderingMethods/Eigen_Colamd.h

@@ -43,12 +43,11 @@
 //
 //       http://www.suitesparse.com
 
-
 #ifndef EIGEN_COLAMD_H
 #define EIGEN_COLAMD_H
 
+namespace Eigen {
 namespace internal {
-
 namespace Colamd {
 
 /* Ensure that debugging is turned off: */
@@ -56,7 +55,6 @@ namespace Colamd {
 #define COLAMD_NDEBUG
 #endif /* NDEBUG */
 
-
 /* ========================================================================== */
 /* === Knob and statistics definitions ====================================== */
 /* ========================================================================== */
@@ -116,16 +114,10 @@ IndexType ones_complement(const IndexType r) {
 const int Empty = -1;
 
 /* Row and column status */
-enum RowColumnStatus {
-  Alive = 0,
-  Dead = -1
-};
+enum RowColumnStatus { Alive = 0, Dead = -1 };
 
 /* Column status */
-enum ColumnStatus {
-  DeadPrincipal = -1,
-  DeadNonPrincipal = -2
-};
+enum ColumnStatus { DeadPrincipal = -1, DeadNonPrincipal = -2 };
 
 /* ========================================================================== */
 /* === Colamd reporting mechanism =========================================== */
@@ -133,36 +125,31 @@ enum ColumnStatus {
 
 // == Row and Column structures ==
 template <typename IndexType>
-struct ColStructure
-{
-  IndexType start ;   /* index for A of first row in this column, or Dead */
+struct ColStructure {
+  IndexType start; /* index for A of first row in this column, or Dead */
   /* if column is dead */
-  IndexType length ;  /* number of rows in this column */
-  union
-  {
-    IndexType thickness ; /* number of original columns represented by this */
+  IndexType length; /* number of rows in this column */
+  union {
+    IndexType thickness; /* number of original columns represented by this */
     /* col, if the column is alive */
-    IndexType parent ;  /* parent in parent tree super-column structure, if */
+    IndexType parent; /* parent in parent tree super-column structure, if */
     /* the column is dead */
-  } shared1 ;
-  union
-  {
-    IndexType score ; /* the score used to maintain heap, if col is alive */
-    IndexType order ; /* pivot ordering of this column, if col is dead */
-  } shared2 ;
-  union
-  {
-    IndexType headhash ;  /* head of a hash bucket, if col is at the head of */
+  } shared1;
+  union {
+    IndexType score; /* the score used to maintain heap, if col is alive */
+    IndexType order; /* pivot ordering of this column, if col is dead */
+  } shared2;
+  union {
+    IndexType headhash; /* head of a hash bucket, if col is at the head of */
     /* a degree list */
-    IndexType hash ;  /* hash value, if col is not in a degree list */
-    IndexType prev ;  /* previous column in degree list, if col is in a */
+    IndexType hash; /* hash value, if col is not in a degree list */
+    IndexType prev; /* previous column in degree list, if col is in a */
     /* degree list (but not at the head of a degree list) */
-  } shared3 ;
-  union
-  {
-    IndexType degree_next ; /* next column, if col is in a degree list */
-    IndexType hash_next ;   /* next column, if col is in a hash list */
-  } shared4 ;
+  } shared3;
+  union {
+    IndexType degree_next; /* next column, if col is in a degree list */
+    IndexType hash_next;   /* next column, if col is in a hash list */
+  } shared4;
 
   inline bool is_dead() const { return start < Alive; }
 
@@ -173,31 +160,26 @@ struct ColStructure
   inline void kill_principal() { start = DeadPrincipal; }
 
   inline void kill_non_principal() { start = DeadNonPrincipal; }
-
 };
 
 template <typename IndexType>
-struct RowStructure
-{
-  IndexType start ;   /* index for A of first col in this row */
-  IndexType length ;  /* number of principal columns in this row */
-  union
-  {
-    IndexType degree ;  /* number of principal & non-principal columns in row */
-    IndexType p ;   /* used as a row pointer in init_rows_cols () */
-  } shared1 ;
-  union
-  {
-    IndexType mark ;  /* for computing set differences and marking dead rows*/
-    IndexType first_column ;/* first column in row (used in garbage collection) */
-  } shared2 ;
+struct RowStructure {
+  IndexType start;  /* index for A of first col in this row */
+  IndexType length; /* number of principal columns in this row */
+  union {
+    IndexType degree; /* number of principal & non-principal columns in row */
+    IndexType p;      /* used as a row pointer in init_rows_cols () */
+  } shared1;
+  union {
+    IndexType mark;         /* for computing set differences and marking dead rows*/
+    IndexType first_column; /* first column in row (used in garbage collection) */
+  } shared2;
 
   inline bool is_dead() const { return shared2.mark < Alive; }
 
   inline bool is_alive() const { return shared2.mark >= Alive; }
 
   inline void kill() { shared2.mark = Dead; }
-
 };
 
 /* ========================================================================== */
@@ -219,34 +201,43 @@ struct RowStructure
   gcc -pedantic warning messages.
 */
 template <typename IndexType>
-inline IndexType colamd_c(IndexType n_col)
-{ return IndexType( ((n_col) + 1) * sizeof (ColStructure<IndexType>) / sizeof (IndexType) ) ; }
+inline IndexType colamd_c(IndexType n_col) {
+  return IndexType(((n_col) + 1) * sizeof(ColStructure<IndexType>) / sizeof(IndexType));
+}
 
 template <typename IndexType>
-inline IndexType  colamd_r(IndexType n_row)
-{ return IndexType(((n_row) + 1) * sizeof (RowStructure<IndexType>) / sizeof (IndexType)); }
+inline IndexType colamd_r(IndexType n_row) {
+  return IndexType(((n_row) + 1) * sizeof(RowStructure<IndexType>) / sizeof(IndexType));
+}
 
 // Prototypes of non-user callable routines
 template <typename IndexType>
-static IndexType init_rows_cols (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> col [], IndexType A [], IndexType p [], IndexType stats[NStats] );
+static IndexType init_rows_cols(IndexType n_row, IndexType n_col, RowStructure<IndexType> Row[],
+                                ColStructure<IndexType> col[], IndexType A[], IndexType p[], IndexType stats[NStats]);
 
 template <typename IndexType>
-static void init_scoring (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType head [], double knobs[NKnobs], IndexType *p_n_row2, IndexType *p_n_col2, IndexType *p_max_deg);
+static void init_scoring(IndexType n_row, IndexType n_col, RowStructure<IndexType> Row[], ColStructure<IndexType> Col[],
+                         IndexType A[], IndexType head[], double knobs[NKnobs], IndexType *p_n_row2,
+                         IndexType *p_n_col2, IndexType *p_max_deg);
 
 template <typename IndexType>
-static IndexType find_ordering (IndexType n_row, IndexType n_col, IndexType Alen, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType head [], IndexType n_col2, IndexType max_deg, IndexType pfree);
+static IndexType find_ordering(IndexType n_row, IndexType n_col, IndexType Alen, RowStructure<IndexType> Row[],
+                               ColStructure<IndexType> Col[], IndexType A[], IndexType head[], IndexType n_col2,
+                               IndexType max_deg, IndexType pfree);
 
 template <typename IndexType>
-static void order_children (IndexType n_col, ColStructure<IndexType> Col [], IndexType p []);
+static void order_children(IndexType n_col, ColStructure<IndexType> Col[], IndexType p[]);
 
 template <typename IndexType>
-static void detect_super_cols (ColStructure<IndexType> Col [], IndexType A [], IndexType head [], IndexType row_start, IndexType row_length ) ;
+static void detect_super_cols(ColStructure<IndexType> Col[], IndexType A[], IndexType head[], IndexType row_start,
+                              IndexType row_length);
 
 template <typename IndexType>
-static IndexType garbage_collection (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType *pfree) ;
+static IndexType garbage_collection(IndexType n_row, IndexType n_col, RowStructure<IndexType> Row[],
+                                    ColStructure<IndexType> Col[], IndexType A[], IndexType *pfree);
 
 template <typename IndexType>
-static inline  IndexType clear_mark (IndexType n_row, RowStructure<IndexType> Row [] ) ;
+static inline IndexType clear_mark(IndexType n_row, RowStructure<IndexType> Row[]);
 
 /* === No debugging ========================================================= */
 
@@ -256,8 +247,7 @@ static inline  IndexType clear_mark (IndexType n_row, RowStructure<IndexType> Ro
 #define COLAMD_DEBUG3(params) ;
 #define COLAMD_DEBUG4(params) ;
 
-#define COLAMD_ASSERT(expression) ((void) 0)
-
+#define COLAMD_ASSERT(expression) ((void)0)
 
 /**
  * \brief Returns the recommended value of Alen
@@ -274,12 +264,11 @@ static inline  IndexType clear_mark (IndexType n_row, RowStructure<IndexType> Ro
  * \return recommended value of Alen for use by colamd
  */
 template <typename IndexType>
-inline IndexType recommended ( IndexType nnz, IndexType n_row, IndexType n_col)
-{
+inline IndexType recommended(IndexType nnz, IndexType n_row, IndexType n_col) {
   if ((nnz) < 0 || (n_row) < 0 || (n_col) < 0)
     return (-1);
   else
-    return (2 * (nnz) + colamd_c (n_col) + colamd_r (n_row) + (n_col) + ((nnz) / 5));
+    return (2 * (nnz) + colamd_c(n_col) + colamd_r(n_row) + (n_col) + ((nnz) / 5));
 }
 
 /**
@@ -303,22 +292,19 @@ inline IndexType recommended ( IndexType nnz, IndexType n_row, IndexType n_col)
  * \param knobs parameter settings for colamd
  */
 
-static inline void set_defaults(double knobs[NKnobs])
-{
+static inline void set_defaults(double knobs[NKnobs]) {
   /* === Local variables ================================================== */
 
-  int i ;
+  int i;
 
-  if (!knobs)
-  {
-    return ;      /* no knobs to initialize */
+  if (!knobs) {
+    return; /* no knobs to initialize */
   }
-  for (i = 0 ; i < NKnobs ; i++)
-  {
-    knobs [i] = 0 ;
+  for (i = 0; i < NKnobs; i++) {
+    knobs[i] = 0;
   }
-  knobs [Colamd::DenseRow] = 0.5 ;  /* ignore rows over 50% dense */
-  knobs [Colamd::DenseCol] = 0.5 ;  /* ignore columns over 50% dense */
+  knobs[Colamd::DenseRow] = 0.5; /* ignore rows over 50% dense */
+  knobs[Colamd::DenseCol] = 0.5; /* ignore columns over 50% dense */
 }
 
 /**
@@ -332,151 +318,142 @@ static inline void set_defaults(double knobs[NKnobs])
  *
  * \param n_row number of rows in A
  * \param n_col number of columns in A
- * \param Alen, size of the array A
+ * \param Alen size of the array A
  * \param A row indices of the matrix, of size ALen
  * \param p column pointers of A, of size n_col+1
  * \param knobs parameter settings for colamd
  * \param stats colamd output statistics and error codes
  */
 template <typename IndexType>
-static bool compute_ordering(IndexType n_row, IndexType n_col, IndexType Alen, IndexType *A, IndexType *p, double knobs[NKnobs], IndexType stats[NStats])
-{
+static bool compute_ordering(IndexType n_row, IndexType n_col, IndexType Alen, IndexType *A, IndexType *p,
+                             double knobs[NKnobs], IndexType stats[NStats]) {
   /* === Local variables ================================================== */
 
-  IndexType i ;     /* loop index */
-  IndexType nnz ;     /* nonzeros in A */
-  IndexType Row_size ;    /* size of Row [], in integers */
-  IndexType Col_size ;    /* size of Col [], in integers */
-  IndexType need ;      /* minimum required length of A */
-  Colamd::RowStructure<IndexType> *Row ;   /* pointer into A of Row [0..n_row] array */
-  Colamd::ColStructure<IndexType> *Col ;   /* pointer into A of Col [0..n_col] array */
-  IndexType n_col2 ;    /* number of non-dense, non-empty columns */
-  IndexType n_row2 ;    /* number of non-dense, non-empty rows */
-  IndexType ngarbage ;    /* number of garbage collections performed */
-  IndexType max_deg ;   /* maximum row degree */
-  double default_knobs [NKnobs] ; /* default knobs array */
-
+  IndexType i;                          /* loop index */
+  IndexType nnz;                        /* nonzeros in A */
+  IndexType Row_size;                   /* size of Row [], in integers */
+  IndexType Col_size;                   /* size of Col [], in integers */
+  IndexType need;                       /* minimum required length of A */
+  Colamd::RowStructure<IndexType> *Row; /* pointer into A of Row [0..n_row] array */
+  Colamd::ColStructure<IndexType> *Col; /* pointer into A of Col [0..n_col] array */
+  IndexType n_col2;                     /* number of non-dense, non-empty columns */
+  IndexType n_row2;                     /* number of non-dense, non-empty rows */
+  IndexType ngarbage;                   /* number of garbage collections performed */
+  IndexType max_deg;                    /* maximum row degree */
+  double default_knobs[NKnobs];         /* default knobs array */
 
   /* === Check the input arguments ======================================== */
 
-  if (!stats)
-  {
-    COLAMD_DEBUG0 (("colamd: stats not present\n")) ;
-    return (false) ;
+  if (!stats) {
+    COLAMD_DEBUG0(("colamd: stats not present\n"));
+    return (false);
   }
-  for (i = 0 ; i < NStats ; i++)
-  {
-    stats [i] = 0 ;
+  for (i = 0; i < NStats; i++) {
+    stats[i] = 0;
   }
-  stats [Colamd::Status] = Colamd::Ok ;
-  stats [Colamd::Info1] = -1 ;
-  stats [Colamd::Info2] = -1 ;
+  stats[Colamd::Status] = Colamd::Ok;
+  stats[Colamd::Info1] = -1;
+  stats[Colamd::Info2] = -1;
 
-  if (!A)   /* A is not present */
+  if (!A) /* A is not present */
   {
-    stats [Colamd::Status] = Colamd::ErrorANotPresent ;
-    COLAMD_DEBUG0 (("colamd: A not present\n")) ;
-    return (false) ;
+    stats[Colamd::Status] = Colamd::ErrorANotPresent;
+    COLAMD_DEBUG0(("colamd: A not present\n"));
+    return (false);
   }
 
-  if (!p)   /* p is not present */
+  if (!p) /* p is not present */
   {
-    stats [Colamd::Status] = Colamd::ErrorPNotPresent ;
-    COLAMD_DEBUG0 (("colamd: p not present\n")) ;
-    return (false) ;
+    stats[Colamd::Status] = Colamd::ErrorPNotPresent;
+    COLAMD_DEBUG0(("colamd: p not present\n"));
+    return (false);
   }
 
-  if (n_row < 0)  /* n_row must be >= 0 */
+  if (n_row < 0) /* n_row must be >= 0 */
   {
-    stats [Colamd::Status] = Colamd::ErrorNrowNegative ;
-    stats [Colamd::Info1] = n_row ;
-    COLAMD_DEBUG0 (("colamd: nrow negative %d\n", n_row)) ;
-    return (false) ;
+    stats[Colamd::Status] = Colamd::ErrorNrowNegative;
+    stats[Colamd::Info1] = n_row;
+    COLAMD_DEBUG0(("colamd: nrow negative %d\n", n_row));
+    return (false);
   }
 
-  if (n_col < 0)  /* n_col must be >= 0 */
+  if (n_col < 0) /* n_col must be >= 0 */
   {
-    stats [Colamd::Status] = Colamd::ErrorNcolNegative ;
-    stats [Colamd::Info1] = n_col ;
-    COLAMD_DEBUG0 (("colamd: ncol negative %d\n", n_col)) ;
-    return (false) ;
+    stats[Colamd::Status] = Colamd::ErrorNcolNegative;
+    stats[Colamd::Info1] = n_col;
+    COLAMD_DEBUG0(("colamd: ncol negative %d\n", n_col));
+    return (false);
   }
 
-  nnz = p [n_col] ;
-  if (nnz < 0)  /* nnz must be >= 0 */
+  nnz = p[n_col];
+  if (nnz < 0) /* nnz must be >= 0 */
   {
-    stats [Colamd::Status] = Colamd::ErrorNnzNegative ;
-    stats [Colamd::Info1] = nnz ;
-    COLAMD_DEBUG0 (("colamd: number of entries negative %d\n", nnz)) ;
-    return (false) ;
+    stats[Colamd::Status] = Colamd::ErrorNnzNegative;
+    stats[Colamd::Info1] = nnz;
+    COLAMD_DEBUG0(("colamd: number of entries negative %d\n", nnz));
+    return (false);
   }
 
-  if (p [0] != 0)
-  {
-    stats [Colamd::Status] = Colamd::ErrorP0Nonzero ;
-    stats [Colamd::Info1] = p [0] ;
-    COLAMD_DEBUG0 (("colamd: p[0] not zero %d\n", p [0])) ;
-    return (false) ;
+  if (p[0] != 0) {
+    stats[Colamd::Status] = Colamd::ErrorP0Nonzero;
+    stats[Colamd::Info1] = p[0];
+    COLAMD_DEBUG0(("colamd: p[0] not zero %d\n", p[0]));
+    return (false);
   }
 
   /* === If no knobs, set default knobs =================================== */
 
-  if (!knobs)
-  {
-    set_defaults (default_knobs) ;
-    knobs = default_knobs ;
+  if (!knobs) {
+    set_defaults(default_knobs);
+    knobs = default_knobs;
   }
 
   /* === Allocate the Row and Col arrays from array A ===================== */
 
-  Col_size = colamd_c (n_col) ;
-  Row_size = colamd_r (n_row) ;
-  need = 2*nnz + n_col + Col_size + Row_size ;
+  Col_size = colamd_c(n_col);
+  Row_size = colamd_r(n_row);
+  need = 2 * nnz + n_col + Col_size + Row_size;
 
-  if (need > Alen)
-  {
+  if (need > Alen) {
     /* not enough space in array A to perform the ordering */
-    stats [Colamd::Status] = Colamd::ErrorATooSmall ;
-    stats [Colamd::Info1] = need ;
-    stats [Colamd::Info2] = Alen ;
-    COLAMD_DEBUG0 (("colamd: Need Alen >= %d, given only Alen = %d\n", need,Alen));
-    return (false) ;
+    stats[Colamd::Status] = Colamd::ErrorATooSmall;
+    stats[Colamd::Info1] = need;
+    stats[Colamd::Info2] = Alen;
+    COLAMD_DEBUG0(("colamd: Need Alen >= %d, given only Alen = %d\n", need, Alen));
+    return (false);
   }
 
-  Alen -= Col_size + Row_size ;
-  Col = (ColStructure<IndexType> *) &A [Alen] ;
-  Row = (RowStructure<IndexType> *) &A [Alen + Col_size] ;
+  Alen -= Col_size + Row_size;
+  Col = (ColStructure<IndexType> *)&A[Alen];
+  Row = (RowStructure<IndexType> *)&A[Alen + Col_size];
 
   /* === Construct the row and column data structures ===================== */
 
-  if (!Colamd::init_rows_cols (n_row, n_col, Row, Col, A, p, stats))
-  {
+  if (!Colamd::init_rows_cols(n_row, n_col, Row, Col, A, p, stats)) {
     /* input matrix is invalid */
-    COLAMD_DEBUG0 (("colamd: Matrix invalid\n")) ;
-    return (false) ;
+    COLAMD_DEBUG0(("colamd: Matrix invalid\n"));
+    return (false);
   }
 
   /* === Initialize scores, kill dense rows/columns ======================= */
 
-  Colamd::init_scoring (n_row, n_col, Row, Col, A, p, knobs,
-		&n_row2, &n_col2, &max_deg) ;
+  Colamd::init_scoring(n_row, n_col, Row, Col, A, p, knobs, &n_row2, &n_col2, &max_deg);
 
   /* === Order the supercolumns =========================================== */
 
-  ngarbage = Colamd::find_ordering (n_row, n_col, Alen, Row, Col, A, p,
-			    n_col2, max_deg, 2*nnz) ;
+  ngarbage = Colamd::find_ordering(n_row, n_col, Alen, Row, Col, A, p, n_col2, max_deg, 2 * nnz);
 
   /* === Order the non-principal columns ================================== */
 
-  Colamd::order_children (n_col, Col, p) ;
+  Colamd::order_children(n_col, Col, p);
 
   /* === Return statistics in stats ======================================= */
 
-  stats [Colamd::DenseRow] = n_row - n_row2 ;
-  stats [Colamd::DenseCol] = n_col - n_col2 ;
-  stats [Colamd::DefragCount] = ngarbage ;
-  COLAMD_DEBUG0 (("colamd: done.\n")) ;
-  return (true) ;
+  stats[Colamd::DenseRow] = n_row - n_row2;
+  stats[Colamd::DenseCol] = n_col - n_col2;
+  stats[Colamd::DefragCount] = ngarbage;
+  COLAMD_DEBUG0(("colamd: done.\n"));
+  return (true);
 }
 
 /* ========================================================================== */
@@ -498,112 +475,102 @@ static bool compute_ordering(IndexType n_row, IndexType n_col, IndexType Alen, I
   true otherwise.  Not user-callable.
 */
 template <typename IndexType>
-static IndexType init_rows_cols  /* returns true if OK, or false otherwise */
-  (
-    /* === Parameters ======================================================= */
-
-    IndexType n_row,      /* number of rows of A */
-    IndexType n_col,      /* number of columns of A */
-    RowStructure<IndexType> Row [],    /* of size n_row+1 */
-    ColStructure<IndexType> Col [],    /* of size n_col+1 */
-    IndexType A [],     /* row indices of A, of size Alen */
-    IndexType p [],     /* pointers to columns in A, of size n_col+1 */
-    IndexType stats [NStats]  /* colamd statistics */
-    )
-{
+static IndexType init_rows_cols /* returns true if OK, or false otherwise */
+    (
+        /* === Parameters ======================================================= */
+
+        IndexType n_row,               /* number of rows of A */
+        IndexType n_col,               /* number of columns of A */
+        RowStructure<IndexType> Row[], /* of size n_row+1 */
+        ColStructure<IndexType> Col[], /* of size n_col+1 */
+        IndexType A[],                 /* row indices of A, of size Alen */
+        IndexType p[],                 /* pointers to columns in A, of size n_col+1 */
+        IndexType stats[NStats]        /* colamd statistics */
+    ) {
   /* === Local variables ================================================== */
 
-  IndexType col ;     /* a column index */
-  IndexType row ;     /* a row index */
-  IndexType *cp ;     /* a column pointer */
-  IndexType *cp_end ;   /* a pointer to the end of a column */
-  IndexType *rp ;     /* a row pointer */
-  IndexType *rp_end ;   /* a pointer to the end of a row */
-  IndexType last_row ;    /* previous row */
+  IndexType col;      /* a column index */
+  IndexType row;      /* a row index */
+  IndexType *cp;      /* a column pointer */
+  IndexType *cp_end;  /* a pointer to the end of a column */
+  IndexType *rp;      /* a row pointer */
+  IndexType *rp_end;  /* a pointer to the end of a row */
+  IndexType last_row; /* previous row */
 
   /* === Initialize columns, and check column pointers ==================== */
 
-  for (col = 0 ; col < n_col ; col++)
-  {
-    Col [col].start = p [col] ;
-    Col [col].length = p [col+1] - p [col] ;
+  for (col = 0; col < n_col; col++) {
+    Col[col].start = p[col];
+    Col[col].length = p[col + 1] - p[col];
 
-    if ((Col [col].length) < 0) // extra parentheses to work-around gcc bug 10200
+    if ((Col[col].length) < 0)  // extra parentheses to work-around gcc bug 10200
     {
       /* column pointers must be non-decreasing */
-      stats [Colamd::Status] = Colamd::ErrorColLengthNegative ;
-      stats [Colamd::Info1] = col ;
-      stats [Colamd::Info2] = Col [col].length ;
-      COLAMD_DEBUG0 (("colamd: col %d length %d < 0\n", col, Col [col].length)) ;
-      return (false) ;
+      stats[Colamd::Status] = Colamd::ErrorColLengthNegative;
+      stats[Colamd::Info1] = col;
+      stats[Colamd::Info2] = Col[col].length;
+      COLAMD_DEBUG0(("colamd: col %d length %d < 0\n", col, Col[col].length));
+      return (false);
     }
 
-    Col [col].shared1.thickness = 1 ;
-    Col [col].shared2.score = 0 ;
-    Col [col].shared3.prev = Empty ;
-    Col [col].shared4.degree_next = Empty ;
+    Col[col].shared1.thickness = 1;
+    Col[col].shared2.score = 0;
+    Col[col].shared3.prev = Empty;
+    Col[col].shared4.degree_next = Empty;
   }
 
   /* p [0..n_col] no longer needed, used as "head" in subsequent routines */
 
   /* === Scan columns, compute row degrees, and check row indices ========= */
 
-  stats [Info3] = 0 ;  /* number of duplicate or unsorted row indices*/
+  stats[Info3] = 0; /* number of duplicate or unsorted row indices*/
 
-  for (row = 0 ; row < n_row ; row++)
-  {
-    Row [row].length = 0 ;
-    Row [row].shared2.mark = -1 ;
+  for (row = 0; row < n_row; row++) {
+    Row[row].length = 0;
+    Row[row].shared2.mark = -1;
   }
 
-  for (col = 0 ; col < n_col ; col++)
-  {
-    last_row = -1 ;
+  for (col = 0; col < n_col; col++) {
+    last_row = -1;
 
-    cp = &A [p [col]] ;
-    cp_end = &A [p [col+1]] ;
+    cp = &A[p[col]];
+    cp_end = &A[p[col + 1]];
 
-    while (cp < cp_end)
-    {
-      row = *cp++ ;
+    while (cp < cp_end) {
+      row = *cp++;
 
       /* make sure row indices within range */
-      if (row < 0 || row >= n_row)
-      {
-	stats [Colamd::Status] = Colamd::ErrorRowIndexOutOfBounds ;
-	stats [Colamd::Info1] = col ;
-	stats [Colamd::Info2] = row ;
-	stats [Colamd::Info3] = n_row ;
-	COLAMD_DEBUG0 (("colamd: row %d col %d out of bounds\n", row, col)) ;
-	return (false) ;
+      if (row < 0 || row >= n_row) {
+        stats[Colamd::Status] = Colamd::ErrorRowIndexOutOfBounds;
+        stats[Colamd::Info1] = col;
+        stats[Colamd::Info2] = row;
+        stats[Colamd::Info3] = n_row;
+        COLAMD_DEBUG0(("colamd: row %d col %d out of bounds\n", row, col));
+        return (false);
       }
 
-      if (row <= last_row || Row [row].shared2.mark == col)
-      {
-	/* row index are unsorted or repeated (or both), thus col */
-	/* is jumbled.  This is a notice, not an error condition. */
-	stats [Colamd::Status] = Colamd::OkButJumbled ;
-	stats [Colamd::Info1] = col ;
-	stats [Colamd::Info2] = row ;
-	(stats [Colamd::Info3]) ++ ;
-	COLAMD_DEBUG1 (("colamd: row %d col %d unsorted/duplicate\n",row,col));
+      if (row <= last_row || Row[row].shared2.mark == col) {
+        /* row index are unsorted or repeated (or both), thus col */
+        /* is jumbled.  This is a notice, not an error condition. */
+        stats[Colamd::Status] = Colamd::OkButJumbled;
+        stats[Colamd::Info1] = col;
+        stats[Colamd::Info2] = row;
+        (stats[Colamd::Info3])++;
+        COLAMD_DEBUG1(("colamd: row %d col %d unsorted/duplicate\n", row, col));
       }
 
-      if (Row [row].shared2.mark != col)
-      {
-	Row [row].length++ ;
-      }
-      else
-      {
-	/* this is a repeated entry in the column, */
-	/* it will be removed */
-	Col [col].length-- ;
+      if (Row[row].shared2.mark != col) {
+        Row[row].length++;
+      } else {
+        /* this is a repeated entry in the column, */
+        /* it will be removed */
+        Col[col].length--;
       }
 
       /* mark the row as having been seen in this column */
-      Row [row].shared2.mark = col ;
+      Row[row].shared2.mark = col;
 
-      last_row = row ;
+      last_row = row;
     }
   }
 
@@ -611,64 +578,52 @@ static IndexType init_rows_cols  /* returns true if OK, or false otherwise */
 
   /* row form of the matrix starts directly after the column */
   /* form of matrix in A */
-  Row [0].start = p [n_col] ;
-  Row [0].shared1.p = Row [0].start ;
-  Row [0].shared2.mark = -1 ;
-  for (row = 1 ; row < n_row ; row++)
-  {
-    Row [row].start = Row [row-1].start + Row [row-1].length ;
-    Row [row].shared1.p = Row [row].start ;
-    Row [row].shared2.mark = -1 ;
+  Row[0].start = p[n_col];
+  Row[0].shared1.p = Row[0].start;
+  Row[0].shared2.mark = -1;
+  for (row = 1; row < n_row; row++) {
+    Row[row].start = Row[row - 1].start + Row[row - 1].length;
+    Row[row].shared1.p = Row[row].start;
+    Row[row].shared2.mark = -1;
   }
 
   /* === Create row form ================================================== */
 
-  if (stats [Status] == OkButJumbled)
-  {
+  if (stats[Status] == OkButJumbled) {
     /* if cols jumbled, watch for repeated row indices */
-    for (col = 0 ; col < n_col ; col++)
-    {
-      cp = &A [p [col]] ;
-      cp_end = &A [p [col+1]] ;
-      while (cp < cp_end)
-      {
-	row = *cp++ ;
-	if (Row [row].shared2.mark != col)
-	{
-	  A [(Row [row].shared1.p)++] = col ;
-	  Row [row].shared2.mark = col ;
-	}
+    for (col = 0; col < n_col; col++) {
+      cp = &A[p[col]];
+      cp_end = &A[p[col + 1]];
+      while (cp < cp_end) {
+        row = *cp++;
+        if (Row[row].shared2.mark != col) {
+          A[(Row[row].shared1.p)++] = col;
+          Row[row].shared2.mark = col;
+        }
       }
     }
-  }
-  else
-  {
+  } else {
     /* if cols not jumbled, we don't need the mark (this is faster) */
-    for (col = 0 ; col < n_col ; col++)
-    {
-      cp = &A [p [col]] ;
-      cp_end = &A [p [col+1]] ;
-      while (cp < cp_end)
-      {
-	A [(Row [*cp++].shared1.p)++] = col ;
+    for (col = 0; col < n_col; col++) {
+      cp = &A[p[col]];
+      cp_end = &A[p[col + 1]];
+      while (cp < cp_end) {
+        A[(Row[*cp++].shared1.p)++] = col;
       }
     }
   }
 
   /* === Clear the row marks and set row degrees ========================== */
 
-  for (row = 0 ; row < n_row ; row++)
-  {
-    Row [row].shared2.mark = 0 ;
-    Row [row].shared1.degree = Row [row].length ;
+  for (row = 0; row < n_row; row++) {
+    Row[row].shared2.mark = 0;
+    Row[row].shared1.degree = Row[row].length;
   }
 
   /* === See if we need to re-create columns ============================== */
 
-  if (stats [Status] == OkButJumbled)
-  {
-    COLAMD_DEBUG0 (("colamd: reconstructing column form, matrix jumbled\n")) ;
-
+  if (stats[Status] == OkButJumbled) {
+    COLAMD_DEBUG0(("colamd: reconstructing column form, matrix jumbled\n"));
 
     /* === Compute col pointers ========================================= */
 
@@ -676,35 +631,31 @@ static IndexType init_rows_cols  /* returns true if OK, or false otherwise */
     /* Note, we may have a gap between the col form and the row */
     /* form if there were duplicate entries, if so, it will be */
     /* removed upon the first garbage collection */
-    Col [0].start = 0 ;
-    p [0] = Col [0].start ;
-    for (col = 1 ; col < n_col ; col++)
-    {
+    Col[0].start = 0;
+    p[0] = Col[0].start;
+    for (col = 1; col < n_col; col++) {
       /* note that the lengths here are for pruned columns, i.e. */
       /* no duplicate row indices will exist for these columns */
-      Col [col].start = Col [col-1].start + Col [col-1].length ;
-      p [col] = Col [col].start ;
+      Col[col].start = Col[col - 1].start + Col[col - 1].length;
+      p[col] = Col[col].start;
     }
 
     /* === Re-create col form =========================================== */
 
-    for (row = 0 ; row < n_row ; row++)
-    {
-      rp = &A [Row [row].start] ;
-      rp_end = rp + Row [row].length ;
-      while (rp < rp_end)
-      {
-	A [(p [*rp++])++] = row ;
+    for (row = 0; row < n_row; row++) {
+      rp = &A[Row[row].start];
+      rp_end = rp + Row[row].length;
+      while (rp < rp_end) {
+        A[(p[*rp++])++] = row;
       }
     }
   }
 
   /* === Done.  Matrix is not (or no longer) jumbled ====================== */
 
-  return (true) ;
+  return (true);
 }
 
-
 /* ========================================================================== */
 /* === init_scoring ========================================================= */
 /* ========================================================================== */
@@ -714,112 +665,99 @@ static IndexType init_rows_cols  /* returns true if OK, or false otherwise */
   each column, and places all columns in the degree lists.  Not user-callable.
 */
 template <typename IndexType>
-static void init_scoring
-  (
+static void init_scoring(
     /* === Parameters ======================================================= */
 
-    IndexType n_row,      /* number of rows of A */
-    IndexType n_col,      /* number of columns of A */
-    RowStructure<IndexType> Row [],    /* of size n_row+1 */
-    ColStructure<IndexType> Col [],    /* of size n_col+1 */
-    IndexType A [],     /* column form and row form of A */
-    IndexType head [],    /* of size n_col+1 */
-    double knobs [NKnobs],/* parameters */
-    IndexType *p_n_row2,    /* number of non-dense, non-empty rows */
-    IndexType *p_n_col2,    /* number of non-dense, non-empty columns */
-    IndexType *p_max_deg    /* maximum row degree */
-    )
-{
+    IndexType n_row,               /* number of rows of A */
+    IndexType n_col,               /* number of columns of A */
+    RowStructure<IndexType> Row[], /* of size n_row+1 */
+    ColStructure<IndexType> Col[], /* of size n_col+1 */
+    IndexType A[],                 /* column form and row form of A */
+    IndexType head[],              /* of size n_col+1 */
+    double knobs[NKnobs],          /* parameters */
+    IndexType *p_n_row2,           /* number of non-dense, non-empty rows */
+    IndexType *p_n_col2,           /* number of non-dense, non-empty columns */
+    IndexType *p_max_deg           /* maximum row degree */
+) {
   /* === Local variables ================================================== */
 
-  IndexType c ;     /* a column index */
-  IndexType r, row ;    /* a row index */
-  IndexType *cp ;     /* a column pointer */
-  IndexType deg ;     /* degree of a row or column */
-  IndexType *cp_end ;   /* a pointer to the end of a column */
-  IndexType *new_cp ;   /* new column pointer */
-  IndexType col_length ;    /* length of pruned column */
-  IndexType score ;     /* current column score */
-  IndexType n_col2 ;    /* number of non-dense, non-empty columns */
-  IndexType n_row2 ;    /* number of non-dense, non-empty rows */
-  IndexType dense_row_count ; /* remove rows with more entries than this */
-  IndexType dense_col_count ; /* remove cols with more entries than this */
-  IndexType min_score ;   /* smallest column score */
-  IndexType max_deg ;   /* maximum row degree */
-  IndexType next_col ;    /* Used to add to degree list.*/
-
+  IndexType c;               /* a column index */
+  IndexType r, row;          /* a row index */
+  IndexType *cp;             /* a column pointer */
+  IndexType deg;             /* degree of a row or column */
+  IndexType *cp_end;         /* a pointer to the end of a column */
+  IndexType *new_cp;         /* new column pointer */
+  IndexType col_length;      /* length of pruned column */
+  IndexType score;           /* current column score */
+  IndexType n_col2;          /* number of non-dense, non-empty columns */
+  IndexType n_row2;          /* number of non-dense, non-empty rows */
+  IndexType dense_row_count; /* remove rows with more entries than this */
+  IndexType dense_col_count; /* remove cols with more entries than this */
+  IndexType min_score;       /* smallest column score */
+  IndexType max_deg;         /* maximum row degree */
+  IndexType next_col;        /* Used to add to degree list.*/
 
   /* === Extract knobs ==================================================== */
 
-  dense_row_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs [Colamd::DenseRow] * n_col), n_col)) ;
-  dense_col_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs [Colamd::DenseCol] * n_row), n_row)) ;
-  COLAMD_DEBUG1 (("colamd: densecount: %d %d\n", dense_row_count, dense_col_count)) ;
-  max_deg = 0 ;
-  n_col2 = n_col ;
-  n_row2 = n_row ;
+  dense_row_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs[Colamd::DenseRow] * n_col), n_col));
+  dense_col_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs[Colamd::DenseCol] * n_row), n_row));
+  COLAMD_DEBUG1(("colamd: densecount: %d %d\n", dense_row_count, dense_col_count));
+  max_deg = 0;
+  n_col2 = n_col;
+  n_row2 = n_row;
 
   /* === Kill empty columns =============================================== */
 
   /* Put the empty columns at the end in their natural order, so that LU */
   /* factorization can proceed as far as possible. */
-  for (c = n_col-1 ; c >= 0 ; c--)
-  {
-    deg = Col [c].length ;
-    if (deg == 0)
-    {
+  for (c = n_col - 1; c >= 0; c--) {
+    deg = Col[c].length;
+    if (deg == 0) {
       /* this is a empty column, kill and order it last */
-      Col [c].shared2.order = --n_col2 ;
-      Col[c].kill_principal() ;
+      Col[c].shared2.order = --n_col2;
+      Col[c].kill_principal();
     }
   }
-  COLAMD_DEBUG1 (("colamd: null columns killed: %d\n", n_col - n_col2)) ;
+  COLAMD_DEBUG1(("colamd: null columns killed: %d\n", n_col - n_col2));
 
   /* === Kill dense columns =============================================== */
 
   /* Put the dense columns at the end, in their natural order */
-  for (c = n_col-1 ; c >= 0 ; c--)
-  {
+  for (c = n_col - 1; c >= 0; c--) {
     /* skip any dead columns */
-    if (Col[c].is_dead())
-    {
-      continue ;
+    if (Col[c].is_dead()) {
+      continue;
     }
-    deg = Col [c].length ;
-    if (deg > dense_col_count)
-    {
+    deg = Col[c].length;
+    if (deg > dense_col_count) {
       /* this is a dense column, kill and order it last */
-      Col [c].shared2.order = --n_col2 ;
+      Col[c].shared2.order = --n_col2;
       /* decrement the row degrees */
-      cp = &A [Col [c].start] ;
-      cp_end = cp + Col [c].length ;
-      while (cp < cp_end)
-      {
-	Row [*cp++].shared1.degree-- ;
+      cp = &A[Col[c].start];
+      cp_end = cp + Col[c].length;
+      while (cp < cp_end) {
+        Row[*cp++].shared1.degree--;
       }
-      Col[c].kill_principal() ;
+      Col[c].kill_principal();
     }
   }
-  COLAMD_DEBUG1 (("colamd: Dense and null columns killed: %d\n", n_col - n_col2)) ;
+  COLAMD_DEBUG1(("colamd: Dense and null columns killed: %d\n", n_col - n_col2));
 
   /* === Kill dense and empty rows ======================================== */
 
-  for (r = 0 ; r < n_row ; r++)
-  {
-    deg = Row [r].shared1.degree ;
-    COLAMD_ASSERT (deg >= 0 && deg <= n_col) ;
-    if (deg > dense_row_count || deg == 0)
-    {
+  for (r = 0; r < n_row; r++) {
+    deg = Row[r].shared1.degree;
+    COLAMD_ASSERT(deg >= 0 && deg <= n_col);
+    if (deg > dense_row_count || deg == 0) {
       /* kill a dense or empty row */
-      Row[r].kill() ;
-      --n_row2 ;
-    }
-    else
-    {
+      Row[r].kill();
+      --n_row2;
+    } else {
       /* keep track of max degree of remaining rows */
-      max_deg = numext::maxi(max_deg, deg) ;
+      max_deg = numext::maxi(max_deg, deg);
     }
   }
-  COLAMD_DEBUG1 (("colamd: Dense and null rows killed: %d\n", n_row - n_row2)) ;
+  COLAMD_DEBUG1(("colamd: Dense and null rows killed: %d\n", n_row - n_row2));
 
   /* === Compute initial column scores ==================================== */
 
@@ -829,54 +767,46 @@ static void init_scoring
   /* pruned in the code below. */
 
   /* now find the initial matlab score for each column */
-  for (c = n_col-1 ; c >= 0 ; c--)
-  {
+  for (c = n_col - 1; c >= 0; c--) {
     /* skip dead column */
-    if (Col[c].is_dead())
-    {
-      continue ;
+    if (Col[c].is_dead()) {
+      continue;
     }
-    score = 0 ;
-    cp = &A [Col [c].start] ;
-    new_cp = cp ;
-    cp_end = cp + Col [c].length ;
-    while (cp < cp_end)
-    {
+    score = 0;
+    cp = &A[Col[c].start];
+    new_cp = cp;
+    cp_end = cp + Col[c].length;
+    while (cp < cp_end) {
       /* get a row */
-      row = *cp++ ;
+      row = *cp++;
       /* skip if dead */
-      if (Row[row].is_dead())
-      {
-	continue ;
+      if (Row[row].is_dead()) {
+        continue;
       }
       /* compact the column */
-      *new_cp++ = row ;
+      *new_cp++ = row;
       /* add row's external degree */
-      score += Row [row].shared1.degree - 1 ;
+      score += Row[row].shared1.degree - 1;
       /* guard against integer overflow */
-      score = numext::mini(score, n_col) ;
+      score = numext::mini(score, n_col);
     }
     /* determine pruned column length */
-    col_length = (IndexType) (new_cp - &A [Col [c].start]) ;
-    if (col_length == 0)
-    {
+    col_length = (IndexType)(new_cp - &A[Col[c].start]);
+    if (col_length == 0) {
       /* a newly-made null column (all rows in this col are "dense" */
       /* and have already been killed) */
-      COLAMD_DEBUG2 (("Newly null killed: %d\n", c)) ;
-      Col [c].shared2.order = --n_col2 ;
-      Col[c].kill_principal() ;
-    }
-    else
-    {
+      COLAMD_DEBUG2(("Newly null killed: %d\n", c));
+      Col[c].shared2.order = --n_col2;
+      Col[c].kill_principal();
+    } else {
       /* set column length and set score */
-      COLAMD_ASSERT (score >= 0) ;
-      COLAMD_ASSERT (score <= n_col) ;
-      Col [c].length = col_length ;
-      Col [c].shared2.score = score ;
+      COLAMD_ASSERT(score >= 0);
+      COLAMD_ASSERT(score <= n_col);
+      Col[c].length = col_length;
+      Col[c].shared2.score = score;
     }
   }
-  COLAMD_DEBUG1 (("colamd: Dense, null, and newly-null columns killed: %d\n",
-		  n_col-n_col2)) ;
+  COLAMD_DEBUG1(("colamd: Dense, null, and newly-null columns killed: %d\n", n_col - n_col2));
 
   /* At this point, all empty rows and columns are dead.  All live columns */
   /* are "clean" (containing no dead rows) and simplicial (no supercolumns */
@@ -885,62 +815,52 @@ static void init_scoring
 
   /* === Initialize degree lists ========================================== */
 
-
   /* clear the hash buckets */
-  for (c = 0 ; c <= n_col ; c++)
-  {
-    head [c] = Empty ;
+  for (c = 0; c <= n_col; c++) {
+    head[c] = Empty;
   }
-  min_score = n_col ;
+  min_score = n_col;
   /* place in reverse order, so low column indices are at the front */
   /* of the lists.  This is to encourage natural tie-breaking */
-  for (c = n_col-1 ; c >= 0 ; c--)
-  {
+  for (c = n_col - 1; c >= 0; c--) {
     /* only add principal columns to degree lists */
-    if (Col[c].is_alive())
-    {
-      COLAMD_DEBUG4 (("place %d score %d minscore %d ncol %d\n",
-		      c, Col [c].shared2.score, min_score, n_col)) ;
+    if (Col[c].is_alive()) {
+      COLAMD_DEBUG4(("place %d score %d minscore %d ncol %d\n", c, Col[c].shared2.score, min_score, n_col));
 
       /* === Add columns score to DList =============================== */
 
-      score = Col [c].shared2.score ;
+      score = Col[c].shared2.score;
 
-      COLAMD_ASSERT (min_score >= 0) ;
-      COLAMD_ASSERT (min_score <= n_col) ;
-      COLAMD_ASSERT (score >= 0) ;
-      COLAMD_ASSERT (score <= n_col) ;
-      COLAMD_ASSERT (head [score] >= Empty) ;
+      COLAMD_ASSERT(min_score >= 0);
+      COLAMD_ASSERT(min_score <= n_col);
+      COLAMD_ASSERT(score >= 0);
+      COLAMD_ASSERT(score <= n_col);
+      COLAMD_ASSERT(head[score] >= Empty);
 
       /* now add this column to dList at proper score location */
-      next_col = head [score] ;
-      Col [c].shared3.prev = Empty ;
-      Col [c].shared4.degree_next = next_col ;
+      next_col = head[score];
+      Col[c].shared3.prev = Empty;
+      Col[c].shared4.degree_next = next_col;
 
       /* if there already was a column with the same score, set its */
       /* previous pointer to this new column */
-      if (next_col != Empty)
-      {
-	Col [next_col].shared3.prev = c ;
+      if (next_col != Empty) {
+        Col[next_col].shared3.prev = c;
       }
-      head [score] = c ;
+      head[score] = c;
 
       /* see if this score is less than current min */
-      min_score = numext::mini(min_score, score) ;
-
-
+      min_score = numext::mini(min_score, score);
     }
   }
 
-
   /* === Return number of remaining columns, and max row degree =========== */
 
-  *p_n_col2 = n_col2 ;
-  *p_n_row2 = n_row2 ;
-  *p_max_deg = max_deg ;
+  *p_n_col2 = n_col2;
+  *p_n_row2 = n_row2;
+  *p_max_deg = max_deg;
 }
 
-
 /* ========================================================================== */
 /* === find_ordering ======================================================== */
 /* ========================================================================== */
@@ -952,197 +872,180 @@ static void init_scoring
 */
 template <typename IndexType>
 static IndexType find_ordering /* return the number of garbage collections */
-  (
-    /* === Parameters ======================================================= */
-
-    IndexType n_row,      /* number of rows of A */
-    IndexType n_col,      /* number of columns of A */
-    IndexType Alen,     /* size of A, 2*nnz + n_col or larger */
-    RowStructure<IndexType> Row [],    /* of size n_row+1 */
-    ColStructure<IndexType> Col [],    /* of size n_col+1 */
-    IndexType A [],     /* column form and row form of A */
-    IndexType head [],    /* of size n_col+1 */
-    IndexType n_col2,     /* Remaining columns to order */
-    IndexType max_deg,    /* Maximum row degree */
-    IndexType pfree     /* index of first free slot (2*nnz on entry) */
-    )
-{
+    (
+        /* === Parameters ======================================================= */
+
+        IndexType n_row,               /* number of rows of A */
+        IndexType n_col,               /* number of columns of A */
+        IndexType Alen,                /* size of A, 2*nnz + n_col or larger */
+        RowStructure<IndexType> Row[], /* of size n_row+1 */
+        ColStructure<IndexType> Col[], /* of size n_col+1 */
+        IndexType A[],                 /* column form and row form of A */
+        IndexType head[],              /* of size n_col+1 */
+        IndexType n_col2,              /* Remaining columns to order */
+        IndexType max_deg,             /* Maximum row degree */
+        IndexType pfree                /* index of first free slot (2*nnz on entry) */
+    ) {
   /* === Local variables ================================================== */
 
-  IndexType k ;     /* current pivot ordering step */
-  IndexType pivot_col ;   /* current pivot column */
-  IndexType *cp ;     /* a column pointer */
-  IndexType *rp ;     /* a row pointer */
-  IndexType pivot_row ;   /* current pivot row */
-  IndexType *new_cp ;   /* modified column pointer */
-  IndexType *new_rp ;   /* modified row pointer */
-  IndexType pivot_row_start ; /* pointer to start of pivot row */
-  IndexType pivot_row_degree ;  /* number of columns in pivot row */
-  IndexType pivot_row_length ;  /* number of supercolumns in pivot row */
-  IndexType pivot_col_score ; /* score of pivot column */
-  IndexType needed_memory ;   /* free space needed for pivot row */
-  IndexType *cp_end ;   /* pointer to the end of a column */
-  IndexType *rp_end ;   /* pointer to the end of a row */
-  IndexType row ;     /* a row index */
-  IndexType col ;     /* a column index */
-  IndexType max_score ;   /* maximum possible score */
-  IndexType cur_score ;   /* score of current column */
-  unsigned int hash ;   /* hash value for supernode detection */
-  IndexType head_column ;   /* head of hash bucket */
-  IndexType first_col ;   /* first column in hash bucket */
-  IndexType tag_mark ;    /* marker value for mark array */
-  IndexType row_mark ;    /* Row [row].shared2.mark */
-  IndexType set_difference ;  /* set difference size of row with pivot row */
-  IndexType min_score ;   /* smallest column score */
-  IndexType col_thickness ;   /* "thickness" (no. of columns in a supercol) */
-  IndexType max_mark ;    /* maximum value of tag_mark */
-  IndexType pivot_col_thickness ; /* number of columns represented by pivot col */
-  IndexType prev_col ;    /* Used by Dlist operations. */
-  IndexType next_col ;    /* Used by Dlist operations. */
-  IndexType ngarbage ;    /* number of garbage collections performed */
-
+  IndexType k;                   /* current pivot ordering step */
+  IndexType pivot_col;           /* current pivot column */
+  IndexType *cp;                 /* a column pointer */
+  IndexType *rp;                 /* a row pointer */
+  IndexType pivot_row;           /* current pivot row */
+  IndexType *new_cp;             /* modified column pointer */
+  IndexType *new_rp;             /* modified row pointer */
+  IndexType pivot_row_start;     /* pointer to start of pivot row */
+  IndexType pivot_row_degree;    /* number of columns in pivot row */
+  IndexType pivot_row_length;    /* number of supercolumns in pivot row */
+  IndexType pivot_col_score;     /* score of pivot column */
+  IndexType needed_memory;       /* free space needed for pivot row */
+  IndexType *cp_end;             /* pointer to the end of a column */
+  IndexType *rp_end;             /* pointer to the end of a row */
+  IndexType row;                 /* a row index */
+  IndexType col;                 /* a column index */
+  IndexType max_score;           /* maximum possible score */
+  IndexType cur_score;           /* score of current column */
+  unsigned int hash;             /* hash value for supernode detection */
+  IndexType head_column;         /* head of hash bucket */
+  IndexType first_col;           /* first column in hash bucket */
+  IndexType tag_mark;            /* marker value for mark array */
+  IndexType row_mark;            /* Row [row].shared2.mark */
+  IndexType set_difference;      /* set difference size of row with pivot row */
+  IndexType min_score;           /* smallest column score */
+  IndexType col_thickness;       /* "thickness" (no. of columns in a supercol) */
+  IndexType max_mark;            /* maximum value of tag_mark */
+  IndexType pivot_col_thickness; /* number of columns represented by pivot col */
+  IndexType prev_col;            /* Used by Dlist operations. */
+  IndexType next_col;            /* Used by Dlist operations. */
+  IndexType ngarbage;            /* number of garbage collections performed */
 
   /* === Initialization and clear mark ==================================== */
 
-  max_mark = INT_MAX - n_col ;  /* INT_MAX defined in <limits.h> */
-  tag_mark = Colamd::clear_mark (n_row, Row) ;
-  min_score = 0 ;
-  ngarbage = 0 ;
-  COLAMD_DEBUG1 (("colamd: Ordering, n_col2=%d\n", n_col2)) ;
+  max_mark = INT_MAX - n_col; /* INT_MAX defined in <limits.h> */
+  tag_mark = Colamd::clear_mark(n_row, Row);
+  min_score = 0;
+  ngarbage = 0;
+  COLAMD_DEBUG1(("colamd: Ordering, n_col2=%d\n", n_col2));
 
   /* === Order the columns ================================================ */
 
-  for (k = 0 ; k < n_col2 ; /* 'k' is incremented below */)
-  {
-
+  for (k = 0; k < n_col2; /* 'k' is incremented below */) {
     /* === Select pivot column, and order it ============================ */
 
     /* make sure degree list isn't empty */
-    COLAMD_ASSERT (min_score >= 0) ;
-    COLAMD_ASSERT (min_score <= n_col) ;
-    COLAMD_ASSERT (head [min_score] >= Empty) ;
+    COLAMD_ASSERT(min_score >= 0);
+    COLAMD_ASSERT(min_score <= n_col);
+    COLAMD_ASSERT(head[min_score] >= Empty);
 
     /* get pivot column from head of minimum degree list */
-    while (min_score < n_col && head [min_score] == Empty)
-    {
-      min_score++ ;
+    while (min_score < n_col && head[min_score] == Empty) {
+      min_score++;
     }
-    pivot_col = head [min_score] ;
-    COLAMD_ASSERT (pivot_col >= 0 && pivot_col <= n_col) ;
-    next_col = Col [pivot_col].shared4.degree_next ;
-    head [min_score] = next_col ;
-    if (next_col != Empty)
-    {
-      Col [next_col].shared3.prev = Empty ;
+    pivot_col = head[min_score];
+    COLAMD_ASSERT(pivot_col >= 0 && pivot_col <= n_col);
+    next_col = Col[pivot_col].shared4.degree_next;
+    head[min_score] = next_col;
+    if (next_col != Empty) {
+      Col[next_col].shared3.prev = Empty;
     }
 
-    COLAMD_ASSERT (Col[pivot_col].is_alive()) ;
-    COLAMD_DEBUG3 (("Pivot col: %d\n", pivot_col)) ;
+    COLAMD_ASSERT(Col[pivot_col].is_alive());
+    COLAMD_DEBUG3(("Pivot col: %d\n", pivot_col));
 
     /* remember score for defrag check */
-    pivot_col_score = Col [pivot_col].shared2.score ;
+    pivot_col_score = Col[pivot_col].shared2.score;
 
     /* the pivot column is the kth column in the pivot order */
-    Col [pivot_col].shared2.order = k ;
+    Col[pivot_col].shared2.order = k;
 
     /* increment order count by column thickness */
-    pivot_col_thickness = Col [pivot_col].shared1.thickness ;
-    k += pivot_col_thickness ;
-    COLAMD_ASSERT (pivot_col_thickness > 0) ;
+    pivot_col_thickness = Col[pivot_col].shared1.thickness;
+    k += pivot_col_thickness;
+    COLAMD_ASSERT(pivot_col_thickness > 0);
 
     /* === Garbage_collection, if necessary ============================= */
 
-    needed_memory = numext::mini(pivot_col_score, n_col - k) ;
-    if (pfree + needed_memory >= Alen)
-    {
-      pfree = Colamd::garbage_collection (n_row, n_col, Row, Col, A, &A [pfree]) ;
-      ngarbage++ ;
+    needed_memory = numext::mini(pivot_col_score, n_col - k);
+    if (pfree + needed_memory >= Alen) {
+      pfree = Colamd::garbage_collection(n_row, n_col, Row, Col, A, &A[pfree]);
+      ngarbage++;
       /* after garbage collection we will have enough */
-      COLAMD_ASSERT (pfree + needed_memory < Alen) ;
+      COLAMD_ASSERT(pfree + needed_memory < Alen);
       /* garbage collection has wiped out the Row[].shared2.mark array */
-      tag_mark = Colamd::clear_mark (n_row, Row) ;
-
+      tag_mark = Colamd::clear_mark(n_row, Row);
     }
 
     /* === Compute pivot row pattern ==================================== */
 
     /* get starting location for this new merged row */
-    pivot_row_start = pfree ;
+    pivot_row_start = pfree;
 
     /* initialize new row counts to zero */
-    pivot_row_degree = 0 ;
+    pivot_row_degree = 0;
 
     /* tag pivot column as having been visited so it isn't included */
     /* in merged pivot row */
-    Col [pivot_col].shared1.thickness = -pivot_col_thickness ;
+    Col[pivot_col].shared1.thickness = -pivot_col_thickness;
 
     /* pivot row is the union of all rows in the pivot column pattern */
-    cp = &A [Col [pivot_col].start] ;
-    cp_end = cp + Col [pivot_col].length ;
-    while (cp < cp_end)
-    {
+    cp = &A[Col[pivot_col].start];
+    cp_end = cp + Col[pivot_col].length;
+    while (cp < cp_end) {
       /* get a row */
-      row = *cp++ ;
-      COLAMD_DEBUG4 (("Pivot col pattern %d %d\n", Row[row].is_alive(), row)) ;
+      row = *cp++;
+      COLAMD_DEBUG4(("Pivot col pattern %d %d\n", Row[row].is_alive(), row));
       /* skip if row is dead */
-      if (Row[row].is_dead())
-      {
-	continue ;
+      if (Row[row].is_dead()) {
+        continue;
       }
-      rp = &A [Row [row].start] ;
-      rp_end = rp + Row [row].length ;
-      while (rp < rp_end)
-      {
-	/* get a column */
-	col = *rp++ ;
-	/* add the column, if alive and untagged */
-	col_thickness = Col [col].shared1.thickness ;
-	if (col_thickness > 0 && Col[col].is_alive())
-	{
-	  /* tag column in pivot row */
-	  Col [col].shared1.thickness = -col_thickness ;
-	  COLAMD_ASSERT (pfree < Alen) ;
-	  /* place column in pivot row */
-	  A [pfree++] = col ;
-	  pivot_row_degree += col_thickness ;
-	}
+      rp = &A[Row[row].start];
+      rp_end = rp + Row[row].length;
+      while (rp < rp_end) {
+        /* get a column */
+        col = *rp++;
+        /* add the column, if alive and untagged */
+        col_thickness = Col[col].shared1.thickness;
+        if (col_thickness > 0 && Col[col].is_alive()) {
+          /* tag column in pivot row */
+          Col[col].shared1.thickness = -col_thickness;
+          COLAMD_ASSERT(pfree < Alen);
+          /* place column in pivot row */
+          A[pfree++] = col;
+          pivot_row_degree += col_thickness;
+        }
       }
     }
 
     /* clear tag on pivot column */
-    Col [pivot_col].shared1.thickness = pivot_col_thickness ;
-    max_deg = numext::maxi(max_deg, pivot_row_degree) ;
-
+    Col[pivot_col].shared1.thickness = pivot_col_thickness;
+    max_deg = numext::maxi(max_deg, pivot_row_degree);
 
     /* === Kill all rows used to construct pivot row ==================== */
 
     /* also kill pivot row, temporarily */
-    cp = &A [Col [pivot_col].start] ;
-    cp_end = cp + Col [pivot_col].length ;
-    while (cp < cp_end)
-    {
+    cp = &A[Col[pivot_col].start];
+    cp_end = cp + Col[pivot_col].length;
+    while (cp < cp_end) {
       /* may be killing an already dead row */
-      row = *cp++ ;
-      COLAMD_DEBUG3 (("Kill row in pivot col: %d\n", row)) ;
-      Row[row].kill() ;
+      row = *cp++;
+      COLAMD_DEBUG3(("Kill row in pivot col: %d\n", row));
+      Row[row].kill();
     }
 
     /* === Select a row index to use as the new pivot row =============== */
 
-    pivot_row_length = pfree - pivot_row_start ;
-    if (pivot_row_length > 0)
-    {
+    pivot_row_length = pfree - pivot_row_start;
+    if (pivot_row_length > 0) {
       /* pick the "pivot" row arbitrarily (first row in col) */
-      pivot_row = A [Col [pivot_col].start] ;
-      COLAMD_DEBUG3 (("Pivotal row is %d\n", pivot_row)) ;
-    }
-    else
-    {
+      pivot_row = A[Col[pivot_col].start];
+      COLAMD_DEBUG3(("Pivotal row is %d\n", pivot_row));
+    } else {
       /* there is no pivot row, since it is of zero length */
-      pivot_row = Empty ;
-      COLAMD_ASSERT (pivot_row_length == 0) ;
+      pivot_row = Empty;
+      COLAMD_ASSERT(pivot_row_length == 0);
     }
-    COLAMD_ASSERT (Col [pivot_col].length > 0 || pivot_row_length == 0) ;
+    COLAMD_ASSERT(Col[pivot_col].length > 0 || pivot_row_length == 0);
 
     /* === Approximate degree computation =============================== */
 
@@ -1165,180 +1068,159 @@ static IndexType find_ordering /* return the number of garbage collections */
 
     /* === Compute set differences ====================================== */
 
-    COLAMD_DEBUG3 (("** Computing set differences phase. **\n")) ;
+    COLAMD_DEBUG3(("** Computing set differences phase. **\n"));
 
     /* pivot row is currently dead - it will be revived later. */
 
-    COLAMD_DEBUG3 (("Pivot row: ")) ;
+    COLAMD_DEBUG3(("Pivot row: "));
     /* for each column in pivot row */
-    rp = &A [pivot_row_start] ;
-    rp_end = rp + pivot_row_length ;
-    while (rp < rp_end)
-    {
-      col = *rp++ ;
-      COLAMD_ASSERT (Col[col].is_alive() && col != pivot_col) ;
-      COLAMD_DEBUG3 (("Col: %d\n", col)) ;
+    rp = &A[pivot_row_start];
+    rp_end = rp + pivot_row_length;
+    while (rp < rp_end) {
+      col = *rp++;
+      COLAMD_ASSERT(Col[col].is_alive() && col != pivot_col);
+      COLAMD_DEBUG3(("Col: %d\n", col));
 
       /* clear tags used to construct pivot row pattern */
-      col_thickness = -Col [col].shared1.thickness ;
-      COLAMD_ASSERT (col_thickness > 0) ;
-      Col [col].shared1.thickness = col_thickness ;
+      col_thickness = -Col[col].shared1.thickness;
+      COLAMD_ASSERT(col_thickness > 0);
+      Col[col].shared1.thickness = col_thickness;
 
       /* === Remove column from degree list =========================== */
 
-      cur_score = Col [col].shared2.score ;
-      prev_col = Col [col].shared3.prev ;
-      next_col = Col [col].shared4.degree_next ;
-      COLAMD_ASSERT (cur_score >= 0) ;
-      COLAMD_ASSERT (cur_score <= n_col) ;
-      COLAMD_ASSERT (cur_score >= Empty) ;
-      if (prev_col == Empty)
-      {
-	head [cur_score] = next_col ;
-      }
-      else
-      {
-	Col [prev_col].shared4.degree_next = next_col ;
+      cur_score = Col[col].shared2.score;
+      prev_col = Col[col].shared3.prev;
+      next_col = Col[col].shared4.degree_next;
+      COLAMD_ASSERT(cur_score >= 0);
+      COLAMD_ASSERT(cur_score <= n_col);
+      COLAMD_ASSERT(cur_score >= Empty);
+      if (prev_col == Empty) {
+        head[cur_score] = next_col;
+      } else {
+        Col[prev_col].shared4.degree_next = next_col;
       }
-      if (next_col != Empty)
-      {
-	Col [next_col].shared3.prev = prev_col ;
+      if (next_col != Empty) {
+        Col[next_col].shared3.prev = prev_col;
       }
 
       /* === Scan the column ========================================== */
 
-      cp = &A [Col [col].start] ;
-      cp_end = cp + Col [col].length ;
-      while (cp < cp_end)
-      {
-	/* get a row */
-	row = *cp++ ;
-	/* skip if dead */
-	if (Row[row].is_dead())
-	{
-	  continue ;
-	}
-  row_mark = Row [row].shared2.mark ;
-	COLAMD_ASSERT (row != pivot_row) ;
-	set_difference = row_mark - tag_mark ;
-	/* check if the row has been seen yet */
-	if (set_difference < 0)
-	{
-	  COLAMD_ASSERT (Row [row].shared1.degree <= max_deg) ;
-	  set_difference = Row [row].shared1.degree ;
-	}
-	/* subtract column thickness from this row's set difference */
-	set_difference -= col_thickness ;
-	COLAMD_ASSERT (set_difference >= 0) ;
-	/* absorb this row if the set difference becomes zero */
-	if (set_difference == 0)
-	{
-	  COLAMD_DEBUG3 (("aggressive absorption. Row: %d\n", row)) ;
-	  Row[row].kill() ;
-	}
-	else
-	{
-	  /* save the new mark */
-	  Row [row].shared2.mark = set_difference + tag_mark ;
-	}
+      cp = &A[Col[col].start];
+      cp_end = cp + Col[col].length;
+      while (cp < cp_end) {
+        /* get a row */
+        row = *cp++;
+        /* skip if dead */
+        if (Row[row].is_dead()) {
+          continue;
+        }
+        row_mark = Row[row].shared2.mark;
+        COLAMD_ASSERT(row != pivot_row);
+        set_difference = row_mark - tag_mark;
+        /* check if the row has been seen yet */
+        if (set_difference < 0) {
+          COLAMD_ASSERT(Row[row].shared1.degree <= max_deg);
+          set_difference = Row[row].shared1.degree;
+        }
+        /* subtract column thickness from this row's set difference */
+        set_difference -= col_thickness;
+        COLAMD_ASSERT(set_difference >= 0);
+        /* absorb this row if the set difference becomes zero */
+        if (set_difference == 0) {
+          COLAMD_DEBUG3(("aggressive absorption. Row: %d\n", row));
+          Row[row].kill();
+        } else {
+          /* save the new mark */
+          Row[row].shared2.mark = set_difference + tag_mark;
+        }
       }
     }
 
-
     /* === Add up set differences for each column ======================= */
 
-    COLAMD_DEBUG3 (("** Adding set differences phase. **\n")) ;
+    COLAMD_DEBUG3(("** Adding set differences phase. **\n"));
 
     /* for each column in pivot row */
-    rp = &A [pivot_row_start] ;
-    rp_end = rp + pivot_row_length ;
-    while (rp < rp_end)
-    {
+    rp = &A[pivot_row_start];
+    rp_end = rp + pivot_row_length;
+    while (rp < rp_end) {
       /* get a column */
-      col = *rp++ ;
-      COLAMD_ASSERT (Col[col].is_alive() && col != pivot_col) ;
-      hash = 0 ;
-      cur_score = 0 ;
-      cp = &A [Col [col].start] ;
+      col = *rp++;
+      COLAMD_ASSERT(Col[col].is_alive() && col != pivot_col);
+      hash = 0;
+      cur_score = 0;
+      cp = &A[Col[col].start];
       /* compact the column */
-      new_cp = cp ;
-      cp_end = cp + Col [col].length ;
-
-      COLAMD_DEBUG4 (("Adding set diffs for Col: %d.\n", col)) ;
-
-      while (cp < cp_end)
-      {
-	/* get a row */
-	row = *cp++ ;
-	COLAMD_ASSERT(row >= 0 && row < n_row) ;
-	/* skip if dead */
-	if (Row [row].is_dead())
-	{
-	  continue ;
-	}
-  row_mark = Row [row].shared2.mark ;
-	COLAMD_ASSERT (row_mark > tag_mark) ;
-	/* compact the column */
-	*new_cp++ = row ;
-	/* compute hash function */
-	hash += row ;
-	/* add set difference */
-	cur_score += row_mark - tag_mark ;
-	/* integer overflow... */
-	cur_score = numext::mini(cur_score, n_col) ;
+      new_cp = cp;
+      cp_end = cp + Col[col].length;
+
+      COLAMD_DEBUG4(("Adding set diffs for Col: %d.\n", col));
+
+      while (cp < cp_end) {
+        /* get a row */
+        row = *cp++;
+        COLAMD_ASSERT(row >= 0 && row < n_row);
+        /* skip if dead */
+        if (Row[row].is_dead()) {
+          continue;
+        }
+        row_mark = Row[row].shared2.mark;
+        COLAMD_ASSERT(row_mark > tag_mark);
+        /* compact the column */
+        *new_cp++ = row;
+        /* compute hash function */
+        hash += row;
+        /* add set difference */
+        cur_score += row_mark - tag_mark;
+        /* integer overflow... */
+        cur_score = numext::mini(cur_score, n_col);
       }
 
       /* recompute the column's length */
-      Col [col].length = (IndexType) (new_cp - &A [Col [col].start]) ;
+      Col[col].length = (IndexType)(new_cp - &A[Col[col].start]);
 
       /* === Further mass elimination ================================= */
 
-      if (Col [col].length == 0)
-      {
-	COLAMD_DEBUG4 (("further mass elimination. Col: %d\n", col)) ;
-	/* nothing left but the pivot row in this column */
-	Col[col].kill_principal() ;
-	pivot_row_degree -= Col [col].shared1.thickness ;
-	COLAMD_ASSERT (pivot_row_degree >= 0) ;
-	/* order it */
-	Col [col].shared2.order = k ;
-	/* increment order count by column thickness */
-	k += Col [col].shared1.thickness ;
-      }
-      else
-      {
-	/* === Prepare for supercolumn detection ==================== */
-
-	COLAMD_DEBUG4 (("Preparing supercol detection for Col: %d.\n", col)) ;
-
-	/* save score so far */
-	Col [col].shared2.score = cur_score ;
-
-	/* add column to hash table, for supercolumn detection */
-	hash %= n_col + 1 ;
-
-	COLAMD_DEBUG4 ((" Hash = %d, n_col = %d.\n", hash, n_col)) ;
-	COLAMD_ASSERT (hash <= n_col) ;
-
-	head_column = head [hash] ;
-	if (head_column > Empty)
-	{
-	  /* degree list "hash" is non-empty, use prev (shared3) of */
-	  /* first column in degree list as head of hash bucket */
-	  first_col = Col [head_column].shared3.headhash ;
-	  Col [head_column].shared3.headhash = col ;
-	}
-	else
-	{
-	  /* degree list "hash" is empty, use head as hash bucket */
-	  first_col = - (head_column + 2) ;
-	  head [hash] = - (col + 2) ;
-	}
-	Col [col].shared4.hash_next = first_col ;
-
-	/* save hash function in Col [col].shared3.hash */
-	Col [col].shared3.hash = (IndexType) hash ;
-	COLAMD_ASSERT (Col[col].is_alive()) ;
+      if (Col[col].length == 0) {
+        COLAMD_DEBUG4(("further mass elimination. Col: %d\n", col));
+        /* nothing left but the pivot row in this column */
+        Col[col].kill_principal();
+        pivot_row_degree -= Col[col].shared1.thickness;
+        COLAMD_ASSERT(pivot_row_degree >= 0);
+        /* order it */
+        Col[col].shared2.order = k;
+        /* increment order count by column thickness */
+        k += Col[col].shared1.thickness;
+      } else {
+        /* === Prepare for supercolumn detection ==================== */
+
+        COLAMD_DEBUG4(("Preparing supercol detection for Col: %d.\n", col));
+
+        /* save score so far */
+        Col[col].shared2.score = cur_score;
+
+        /* add column to hash table, for supercolumn detection */
+        hash %= n_col + 1;
+
+        COLAMD_DEBUG4((" Hash = %d, n_col = %d.\n", hash, n_col));
+        COLAMD_ASSERT(hash <= n_col);
+
+        head_column = head[hash];
+        if (head_column > Empty) {
+          /* degree list "hash" is non-empty, use prev (shared3) of */
+          /* first column in degree list as head of hash bucket */
+          first_col = Col[head_column].shared3.headhash;
+          Col[head_column].shared3.headhash = col;
+        } else {
+          /* degree list "hash" is empty, use head as hash bucket */
+          first_col = -(head_column + 2);
+          head[hash] = -(col + 2);
+        }
+        Col[col].shared4.hash_next = first_col;
+
+        /* save hash function in Col [col].shared3.hash */
+        Col[col].shared3.hash = (IndexType)hash;
+        COLAMD_ASSERT(Col[col].is_alive());
       }
     }
 
@@ -1346,105 +1228,98 @@ static IndexType find_ordering /* return the number of garbage collections */
 
     /* === Supercolumn detection ======================================== */
 
-    COLAMD_DEBUG3 (("** Supercolumn detection phase. **\n")) ;
+    COLAMD_DEBUG3(("** Supercolumn detection phase. **\n"));
 
-    Colamd::detect_super_cols (Col, A, head, pivot_row_start, pivot_row_length) ;
+    Colamd::detect_super_cols(Col, A, head, pivot_row_start, pivot_row_length);
 
     /* === Kill the pivotal column ====================================== */
 
-    Col[pivot_col].kill_principal() ;
+    Col[pivot_col].kill_principal();
 
     /* === Clear mark =================================================== */
 
-    tag_mark += (max_deg + 1) ;
-    if (tag_mark >= max_mark)
-    {
-      COLAMD_DEBUG2 (("clearing tag_mark\n")) ;
-      tag_mark = Colamd::clear_mark (n_row, Row) ;
+    tag_mark += (max_deg + 1);
+    if (tag_mark >= max_mark) {
+      COLAMD_DEBUG2(("clearing tag_mark\n"));
+      tag_mark = Colamd::clear_mark(n_row, Row);
     }
 
     /* === Finalize the new pivot row, and column scores ================ */
 
-    COLAMD_DEBUG3 (("** Finalize scores phase. **\n")) ;
+    COLAMD_DEBUG3(("** Finalize scores phase. **\n"));
 
     /* for each column in pivot row */
-    rp = &A [pivot_row_start] ;
+    rp = &A[pivot_row_start];
     /* compact the pivot row */
-    new_rp = rp ;
-    rp_end = rp + pivot_row_length ;
-    while (rp < rp_end)
-    {
-      col = *rp++ ;
+    new_rp = rp;
+    rp_end = rp + pivot_row_length;
+    while (rp < rp_end) {
+      col = *rp++;
       /* skip dead columns */
-      if (Col[col].is_dead())
-      {
-	continue ;
+      if (Col[col].is_dead()) {
+        continue;
       }
-      *new_rp++ = col ;
+      *new_rp++ = col;
       /* add new pivot row to column */
-      A [Col [col].start + (Col [col].length++)] = pivot_row ;
+      A[Col[col].start + (Col[col].length++)] = pivot_row;
 
       /* retrieve score so far and add on pivot row's degree. */
       /* (we wait until here for this in case the pivot */
       /* row's degree was reduced due to mass elimination). */
-      cur_score = Col [col].shared2.score + pivot_row_degree ;
+      cur_score = Col[col].shared2.score + pivot_row_degree;
 
       /* calculate the max possible score as the number of */
       /* external columns minus the 'k' value minus the */
       /* columns thickness */
-      max_score = n_col - k - Col [col].shared1.thickness ;
+      max_score = n_col - k - Col[col].shared1.thickness;
 
       /* make the score the external degree of the union-of-rows */
-      cur_score -= Col [col].shared1.thickness ;
+      cur_score -= Col[col].shared1.thickness;
 
       /* make sure score is less or equal than the max score */
-      cur_score = numext::mini(cur_score, max_score) ;
-      COLAMD_ASSERT (cur_score >= 0) ;
+      cur_score = numext::mini(cur_score, max_score);
+      COLAMD_ASSERT(cur_score >= 0);
 
       /* store updated score */
-      Col [col].shared2.score = cur_score ;
+      Col[col].shared2.score = cur_score;
 
       /* === Place column back in degree list ========================= */
 
-      COLAMD_ASSERT (min_score >= 0) ;
-      COLAMD_ASSERT (min_score <= n_col) ;
-      COLAMD_ASSERT (cur_score >= 0) ;
-      COLAMD_ASSERT (cur_score <= n_col) ;
-      COLAMD_ASSERT (head [cur_score] >= Empty) ;
-      next_col = head [cur_score] ;
-      Col [col].shared4.degree_next = next_col ;
-      Col [col].shared3.prev = Empty ;
-      if (next_col != Empty)
-      {
-	Col [next_col].shared3.prev = col ;
+      COLAMD_ASSERT(min_score >= 0);
+      COLAMD_ASSERT(min_score <= n_col);
+      COLAMD_ASSERT(cur_score >= 0);
+      COLAMD_ASSERT(cur_score <= n_col);
+      COLAMD_ASSERT(head[cur_score] >= Empty);
+      next_col = head[cur_score];
+      Col[col].shared4.degree_next = next_col;
+      Col[col].shared3.prev = Empty;
+      if (next_col != Empty) {
+        Col[next_col].shared3.prev = col;
       }
-      head [cur_score] = col ;
+      head[cur_score] = col;
 
       /* see if this score is less than current min */
-      min_score = numext::mini(min_score, cur_score) ;
-
+      min_score = numext::mini(min_score, cur_score);
     }
 
     /* === Resurrect the new pivot row ================================== */
 
-    if (pivot_row_degree > 0)
-    {
+    if (pivot_row_degree > 0) {
       /* update pivot row length to reflect any cols that were killed */
       /* during super-col detection and mass elimination */
-      Row [pivot_row].start  = pivot_row_start ;
-      Row [pivot_row].length = (IndexType) (new_rp - &A[pivot_row_start]) ;
-      Row [pivot_row].shared1.degree = pivot_row_degree ;
-      Row [pivot_row].shared2.mark = 0 ;
+      Row[pivot_row].start = pivot_row_start;
+      Row[pivot_row].length = (IndexType)(new_rp - &A[pivot_row_start]);
+      Row[pivot_row].shared1.degree = pivot_row_degree;
+      Row[pivot_row].shared2.mark = 0;
       /* pivot row is no longer dead */
     }
   }
 
   /* === All principal columns have now been ordered ====================== */
 
-  return (ngarbage) ;
+  return (ngarbage);
 }
 
-
 /* ========================================================================== */
 /* === order_children ======================================================= */
 /* ========================================================================== */
@@ -1462,74 +1337,66 @@ static IndexType find_ordering /* return the number of garbage collections */
   columns.  Not user-callable.
 */
 template <typename IndexType>
-static inline  void order_children
-(
-  /* === Parameters ======================================================= */
-
-  IndexType n_col,      /* number of columns of A */
-  ColStructure<IndexType> Col [],    /* of size n_col+1 */
-  IndexType p []      /* p [0 ... n_col-1] is the column permutation*/
-  )
-{
+static inline void order_children(
+    /* === Parameters ======================================================= */
+
+    IndexType n_col,               /* number of columns of A */
+    ColStructure<IndexType> Col[], /* of size n_col+1 */
+    IndexType p[]                  /* p [0 ... n_col-1] is the column permutation*/
+) {
   /* === Local variables ================================================== */
 
-  IndexType i ;     /* loop counter for all columns */
-  IndexType c ;     /* column index */
-  IndexType parent ;    /* index of column's parent */
-  IndexType order ;     /* column's order */
+  IndexType i;      /* loop counter for all columns */
+  IndexType c;      /* column index */
+  IndexType parent; /* index of column's parent */
+  IndexType order;  /* column's order */
 
   /* === Order each non-principal column ================================== */
 
-  for (i = 0 ; i < n_col ; i++)
-  {
+  for (i = 0; i < n_col; i++) {
     /* find an un-ordered non-principal column */
-    COLAMD_ASSERT (col_is_dead(Col, i)) ;
-    if (!Col[i].is_dead_principal() && Col [i].shared2.order == Empty)
-    {
-      parent = i ;
+    COLAMD_ASSERT(col_is_dead(Col, i));
+    if (!Col[i].is_dead_principal() && Col[i].shared2.order == Empty) {
+      parent = i;
       /* once found, find its principal parent */
-      do
-      {
-	parent = Col [parent].shared1.parent ;
-      } while (!Col[parent].is_dead_principal()) ;
+      do {
+        parent = Col[parent].shared1.parent;
+      } while (!Col[parent].is_dead_principal());
 
       /* now, order all un-ordered non-principal columns along path */
       /* to this parent.  collapse tree at the same time */
-      c = i ;
+      c = i;
       /* get order of parent */
-      order = Col [parent].shared2.order ;
+      order = Col[parent].shared2.order;
 
-      do
-      {
-	COLAMD_ASSERT (Col [c].shared2.order == Empty) ;
+      do {
+        COLAMD_ASSERT(Col[c].shared2.order == Empty);
 
-	/* order this column */
-	Col [c].shared2.order = order++ ;
-	/* collaps tree */
-	Col [c].shared1.parent = parent ;
+        /* order this column */
+        Col[c].shared2.order = order++;
+        /* collapse tree */
+        Col[c].shared1.parent = parent;
 
-	/* get immediate parent of this column */
-	c = Col [c].shared1.parent ;
+        /* get immediate parent of this column */
+        c = Col[c].shared1.parent;
 
-	/* continue until we hit an ordered column.  There are */
-	/* guaranteed not to be anymore unordered columns */
-	/* above an ordered column */
-      } while (Col [c].shared2.order == Empty) ;
+        /* continue until we hit an ordered column.  There are */
+        /* guaranteed not to be anymore unordered columns */
+        /* above an ordered column */
+      } while (Col[c].shared2.order == Empty);
 
       /* re-order the super_col parent to largest order for this group */
-      Col [parent].shared2.order = order ;
+      Col[parent].shared2.order = order;
     }
   }
 
   /* === Generate the permutation ========================================= */
 
-  for (c = 0 ; c < n_col ; c++)
-  {
-    p [Col [c].shared2.order] = c ;
+  for (c = 0; c < n_col; c++) {
+    p[Col[c].shared2.order] = c;
   }
 }
 
-
 /* ========================================================================== */
 /* === detect_super_cols ==================================================== */
 /* ========================================================================== */
@@ -1563,144 +1430,124 @@ static inline  void order_children
   Not user-callable.
 */
 template <typename IndexType>
-static void detect_super_cols
-(
-  /* === Parameters ======================================================= */
-
-  ColStructure<IndexType> Col [],    /* of size n_col+1 */
-  IndexType A [],     /* row indices of A */
-  IndexType head [],    /* head of degree lists and hash buckets */
-  IndexType row_start,    /* pointer to set of columns to check */
-  IndexType row_length    /* number of columns to check */
-)
-{
+static void detect_super_cols(
+    /* === Parameters ======================================================= */
+
+    ColStructure<IndexType> Col[], /* of size n_col+1 */
+    IndexType A[],                 /* row indices of A */
+    IndexType head[],              /* head of degree lists and hash buckets */
+    IndexType row_start,           /* pointer to set of columns to check */
+    IndexType row_length           /* number of columns to check */
+) {
   /* === Local variables ================================================== */
 
-  IndexType hash ;      /* hash value for a column */
-  IndexType *rp ;     /* pointer to a row */
-  IndexType c ;     /* a column index */
-  IndexType super_c ;   /* column index of the column to absorb into */
-  IndexType *cp1 ;      /* column pointer for column super_c */
-  IndexType *cp2 ;      /* column pointer for column c */
-  IndexType length ;    /* length of column super_c */
-  IndexType prev_c ;    /* column preceding c in hash bucket */
-  IndexType i ;     /* loop counter */
-  IndexType *rp_end ;   /* pointer to the end of the row */
-  IndexType col ;     /* a column index in the row to check */
-  IndexType head_column ;   /* first column in hash bucket or degree list */
-  IndexType first_col ;   /* first column in hash bucket */
+  IndexType hash;        /* hash value for a column */
+  IndexType *rp;         /* pointer to a row */
+  IndexType c;           /* a column index */
+  IndexType super_c;     /* column index of the column to absorb into */
+  IndexType *cp1;        /* column pointer for column super_c */
+  IndexType *cp2;        /* column pointer for column c */
+  IndexType length;      /* length of column super_c */
+  IndexType prev_c;      /* column preceding c in hash bucket */
+  IndexType i;           /* loop counter */
+  IndexType *rp_end;     /* pointer to the end of the row */
+  IndexType col;         /* a column index in the row to check */
+  IndexType head_column; /* first column in hash bucket or degree list */
+  IndexType first_col;   /* first column in hash bucket */
 
   /* === Consider each column in the row ================================== */
 
-  rp = &A [row_start] ;
-  rp_end = rp + row_length ;
-  while (rp < rp_end)
-  {
-    col = *rp++ ;
-    if (Col[col].is_dead())
-    {
-      continue ;
+  rp = &A[row_start];
+  rp_end = rp + row_length;
+  while (rp < rp_end) {
+    col = *rp++;
+    if (Col[col].is_dead()) {
+      continue;
     }
 
     /* get hash number for this column */
-    hash = Col [col].shared3.hash ;
-    COLAMD_ASSERT (hash <= n_col) ;
+    hash = Col[col].shared3.hash;
+    COLAMD_ASSERT(hash <= n_col);
 
     /* === Get the first column in this hash bucket ===================== */
 
-    head_column = head [hash] ;
-    if (head_column > Empty)
-    {
-      first_col = Col [head_column].shared3.headhash ;
-    }
-    else
-    {
-      first_col = - (head_column + 2) ;
+    head_column = head[hash];
+    if (head_column > Empty) {
+      first_col = Col[head_column].shared3.headhash;
+    } else {
+      first_col = -(head_column + 2);
     }
 
     /* === Consider each column in the hash bucket ====================== */
 
-    for (super_c = first_col ; super_c != Empty ;
-	 super_c = Col [super_c].shared4.hash_next)
-    {
-      COLAMD_ASSERT (Col [super_c].is_alive()) ;
-      COLAMD_ASSERT (Col [super_c].shared3.hash == hash) ;
-      length = Col [super_c].length ;
+    for (super_c = first_col; super_c != Empty; super_c = Col[super_c].shared4.hash_next) {
+      COLAMD_ASSERT(Col[super_c].is_alive());
+      COLAMD_ASSERT(Col[super_c].shared3.hash == hash);
+      length = Col[super_c].length;
 
       /* prev_c is the column preceding column c in the hash bucket */
-      prev_c = super_c ;
+      prev_c = super_c;
 
       /* === Compare super_c with all columns after it ================ */
 
-      for (c = Col [super_c].shared4.hash_next ;
-	   c != Empty ; c = Col [c].shared4.hash_next)
-      {
-	COLAMD_ASSERT (c != super_c) ;
-	COLAMD_ASSERT (Col[c].is_alive()) ;
-	COLAMD_ASSERT (Col [c].shared3.hash == hash) ;
-
-	/* not identical if lengths or scores are different */
-	if (Col [c].length != length ||
-	    Col [c].shared2.score != Col [super_c].shared2.score)
-	{
-	  prev_c = c ;
-	  continue ;
-	}
-
-	/* compare the two columns */
-	cp1 = &A [Col [super_c].start] ;
-	cp2 = &A [Col [c].start] ;
-
-	for (i = 0 ; i < length ; i++)
-	{
-	  /* the columns are "clean" (no dead rows) */
-	  COLAMD_ASSERT ( cp1->is_alive() );
-	  COLAMD_ASSERT ( cp2->is_alive() );
-	  /* row indices will same order for both supercols, */
-	  /* no gather scatter necessary */
-	  if (*cp1++ != *cp2++)
-	  {
-	    break ;
-	  }
-	}
-
-	/* the two columns are different if the for-loop "broke" */
-	if (i != length)
-	{
-	  prev_c = c ;
-	  continue ;
-	}
-
-	/* === Got it!  two columns are identical =================== */
-
-	COLAMD_ASSERT (Col [c].shared2.score == Col [super_c].shared2.score) ;
-
-	Col [super_c].shared1.thickness += Col [c].shared1.thickness ;
-	Col [c].shared1.parent = super_c ;
-	Col[c].kill_non_principal() ;
-	/* order c later, in order_children() */
-	Col [c].shared2.order = Empty ;
-	/* remove c from hash bucket */
-	Col [prev_c].shared4.hash_next = Col [c].shared4.hash_next ;
+      for (c = Col[super_c].shared4.hash_next; c != Empty; c = Col[c].shared4.hash_next) {
+        COLAMD_ASSERT(c != super_c);
+        COLAMD_ASSERT(Col[c].is_alive());
+        COLAMD_ASSERT(Col[c].shared3.hash == hash);
+
+        /* not identical if lengths or scores are different */
+        if (Col[c].length != length || Col[c].shared2.score != Col[super_c].shared2.score) {
+          prev_c = c;
+          continue;
+        }
+
+        /* compare the two columns */
+        cp1 = &A[Col[super_c].start];
+        cp2 = &A[Col[c].start];
+
+        for (i = 0; i < length; i++) {
+          /* the columns are "clean" (no dead rows) */
+          COLAMD_ASSERT(cp1->is_alive());
+          COLAMD_ASSERT(cp2->is_alive());
+          /* row indices will same order for both supercols, */
+          /* no gather scatter necessary */
+          if (*cp1++ != *cp2++) {
+            break;
+          }
+        }
+
+        /* the two columns are different if the for-loop "broke" */
+        if (i != length) {
+          prev_c = c;
+          continue;
+        }
+
+        /* === Got it!  two columns are identical =================== */
+
+        COLAMD_ASSERT(Col[c].shared2.score == Col[super_c].shared2.score);
+
+        Col[super_c].shared1.thickness += Col[c].shared1.thickness;
+        Col[c].shared1.parent = super_c;
+        Col[c].kill_non_principal();
+        /* order c later, in order_children() */
+        Col[c].shared2.order = Empty;
+        /* remove c from hash bucket */
+        Col[prev_c].shared4.hash_next = Col[c].shared4.hash_next;
       }
     }
 
     /* === Empty this hash bucket ======================================= */
 
-    if (head_column > Empty)
-    {
+    if (head_column > Empty) {
       /* corresponding degree list "hash" is not empty */
-      Col [head_column].shared3.headhash = Empty ;
-    }
-    else
-    {
+      Col[head_column].shared3.headhash = Empty;
+    } else {
       /* corresponding degree list "hash" is empty */
-      head [hash] = Empty ;
+      head[hash] = Empty;
     }
   }
 }
 
-
 /* ========================================================================== */
 /* === garbage_collection =================================================== */
 /* ========================================================================== */
@@ -1714,118 +1561,101 @@ static void detect_super_cols
   Not user-callable.
 */
 template <typename IndexType>
-static IndexType garbage_collection  /* returns the new value of pfree */
-  (
-    /* === Parameters ======================================================= */
-
-    IndexType n_row,      /* number of rows */
-    IndexType n_col,      /* number of columns */
-    RowStructure<IndexType> Row [],    /* row info */
-    ColStructure<IndexType> Col [],    /* column info */
-    IndexType A [],     /* A [0 ... Alen-1] holds the matrix */
-    IndexType *pfree      /* &A [0] ... pfree is in use */
-    )
-{
+static IndexType garbage_collection /* returns the new value of pfree */
+    (
+        /* === Parameters ======================================================= */
+
+        IndexType n_row,               /* number of rows */
+        IndexType n_col,               /* number of columns */
+        RowStructure<IndexType> Row[], /* row info */
+        ColStructure<IndexType> Col[], /* column info */
+        IndexType A[],                 /* A [0 ... Alen-1] holds the matrix */
+        IndexType *pfree               /* &A [0] ... pfree is in use */
+    ) {
   /* === Local variables ================================================== */
 
-  IndexType *psrc ;     /* source pointer */
-  IndexType *pdest ;    /* destination pointer */
-  IndexType j ;     /* counter */
-  IndexType r ;     /* a row index */
-  IndexType c ;     /* a column index */
-  IndexType length ;    /* length of a row or column */
+  IndexType *psrc;  /* source pointer */
+  IndexType *pdest; /* destination pointer */
+  IndexType j;      /* counter */
+  IndexType r;      /* a row index */
+  IndexType c;      /* a column index */
+  IndexType length; /* length of a row or column */
 
   /* === Defragment the columns =========================================== */
 
-  pdest = &A[0] ;
-  for (c = 0 ; c < n_col ; c++)
-  {
-    if (Col[c].is_alive())
-    {
-      psrc = &A [Col [c].start] ;
+  pdest = &A[0];
+  for (c = 0; c < n_col; c++) {
+    if (Col[c].is_alive()) {
+      psrc = &A[Col[c].start];
 
       /* move and compact the column */
-      COLAMD_ASSERT (pdest <= psrc) ;
-      Col [c].start = (IndexType) (pdest - &A [0]) ;
-      length = Col [c].length ;
-      for (j = 0 ; j < length ; j++)
-      {
-	r = *psrc++ ;
-	if (Row[r].is_alive())
-	{
-	  *pdest++ = r ;
-	}
+      COLAMD_ASSERT(pdest <= psrc);
+      Col[c].start = (IndexType)(pdest - &A[0]);
+      length = Col[c].length;
+      for (j = 0; j < length; j++) {
+        r = *psrc++;
+        if (Row[r].is_alive()) {
+          *pdest++ = r;
+        }
       }
-      Col [c].length = (IndexType) (pdest - &A [Col [c].start]) ;
+      Col[c].length = (IndexType)(pdest - &A[Col[c].start]);
     }
   }
 
   /* === Prepare to defragment the rows =================================== */
 
-  for (r = 0 ; r < n_row ; r++)
-  {
-    if (Row[r].is_alive())
-    {
-      if (Row [r].length == 0)
-      {
+  for (r = 0; r < n_row; r++) {
+    if (Row[r].is_alive()) {
+      if (Row[r].length == 0) {
         /* this row is of zero length.  cannot compact it, so kill it */
-        COLAMD_DEBUG3 (("Defrag row kill\n")) ;
-        Row[r].kill() ;
-      }
-      else
-      {
+        COLAMD_DEBUG3(("Defrag row kill\n"));
+        Row[r].kill();
+      } else {
         /* save first column index in Row [r].shared2.first_column */
-        psrc = &A [Row [r].start] ;
-        Row [r].shared2.first_column = *psrc ;
-        COLAMD_ASSERT (Row[r].is_alive()) ;
+        psrc = &A[Row[r].start];
+        Row[r].shared2.first_column = *psrc;
+        COLAMD_ASSERT(Row[r].is_alive());
         /* flag the start of the row with the one's complement of row */
-        *psrc = ones_complement(r) ;
-
+        *psrc = ones_complement(r);
       }
     }
   }
 
   /* === Defragment the rows ============================================== */
 
-  psrc = pdest ;
-  while (psrc < pfree)
-  {
+  psrc = pdest;
+  while (psrc < pfree) {
     /* find a negative number ... the start of a row */
-    if (*psrc++ < 0)
-    {
-      psrc-- ;
+    if (*psrc++ < 0) {
+      psrc--;
       /* get the row index */
-      r = ones_complement(*psrc) ;
-      COLAMD_ASSERT (r >= 0 && r < n_row) ;
+      r = ones_complement(*psrc);
+      COLAMD_ASSERT(r >= 0 && r < n_row);
       /* restore first column index */
-      *psrc = Row [r].shared2.first_column ;
-      COLAMD_ASSERT (Row[r].is_alive()) ;
+      *psrc = Row[r].shared2.first_column;
+      COLAMD_ASSERT(Row[r].is_alive());
 
       /* move and compact the row */
-      COLAMD_ASSERT (pdest <= psrc) ;
-      Row [r].start = (IndexType) (pdest - &A [0]) ;
-      length = Row [r].length ;
-      for (j = 0 ; j < length ; j++)
-      {
-	c = *psrc++ ;
-	if (Col[c].is_alive())
-	{
-	  *pdest++ = c ;
-	}
+      COLAMD_ASSERT(pdest <= psrc);
+      Row[r].start = (IndexType)(pdest - &A[0]);
+      length = Row[r].length;
+      for (j = 0; j < length; j++) {
+        c = *psrc++;
+        if (Col[c].is_alive()) {
+          *pdest++ = c;
+        }
       }
-      Row [r].length = (IndexType) (pdest - &A [Row [r].start]) ;
-
+      Row[r].length = (IndexType)(pdest - &A[Row[r].start]);
     }
   }
   /* ensure we found all the rows */
-  COLAMD_ASSERT (debug_rows == 0) ;
+  COLAMD_ASSERT(debug_rows == 0);
 
   /* === Return the new value of pfree ==================================== */
 
-  return ((IndexType) (pdest - &A [0])) ;
+  return ((IndexType)(pdest - &A[0]));
 }
 
-
 /* ========================================================================== */
 /* === clear_mark =========================================================== */
 /* ========================================================================== */
@@ -1835,29 +1665,26 @@ static IndexType garbage_collection  /* returns the new value of pfree */
   Return value is the new tag_mark.  Not user-callable.
 */
 template <typename IndexType>
-static inline  IndexType clear_mark  /* return the new value for tag_mark */
-  (
-      /* === Parameters ======================================================= */
-
-    IndexType n_row,    /* number of rows in A */
-    RowStructure<IndexType> Row [] /* Row [0 ... n_row-1].shared2.mark is set to zero */
-    )
-{
+static inline IndexType clear_mark /* return the new value for tag_mark */
+    (
+        /* === Parameters ======================================================= */
+
+        IndexType n_row,              /* number of rows in A */
+        RowStructure<IndexType> Row[] /* Row [0 ... n_row-1].shared2.mark is set to zero */
+    ) {
   /* === Local variables ================================================== */
 
-  IndexType r ;
+  IndexType r;
 
-  for (r = 0 ; r < n_row ; r++)
-  {
-    if (Row[r].is_alive())
-    {
-      Row [r].shared2.mark = 0 ;
+  for (r = 0; r < n_row; r++) {
+    if (Row[r].is_alive()) {
+      Row[r].shared2.mark = 0;
     }
   }
-  return (1) ;
+  return (1);
 }
 
-} // namespace Colamd
-
-} // namespace internal
+}  // namespace Colamd
+}  // namespace internal
+}  // namespace Eigen
 #endif