@smake/eigen 1.1.0 → 1.1.1

package/eigen/Eigen/src/SparseLU/SparseLUImpl.h

@@ -9,58 +9,71 @@
 #ifndef SPARSELU_IMPL_H
 #define SPARSELU_IMPL_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
-  
+
 /** \ingroup SparseLU_Module
-  * \class SparseLUImpl
-  * Base class for sparseLU
-  */
+ * \class SparseLUImpl
+ * Base class for sparseLU
+ */
 template <typename Scalar, typename StorageIndex>
-class SparseLUImpl
-{
-  public:
-    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
-    typedef Matrix<StorageIndex,Dynamic,1> IndexVector; 
-    typedef Matrix<Scalar,Dynamic,Dynamic,ColMajor> ScalarMatrix;
-    typedef Map<ScalarMatrix, 0,  OuterStride<> > MappedMatrixBlock;
-    typedef typename ScalarVector::RealScalar RealScalar; 
-    typedef Ref<Matrix<Scalar,Dynamic,1> > BlockScalarVector;
-    typedef Ref<Matrix<StorageIndex,Dynamic,1> > BlockIndexVector;
-    typedef LU_GlobalLU_t<IndexVector, ScalarVector> GlobalLU_t; 
-    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> MatrixType; 
-    
-  protected:
-     template <typename VectorType>
-     Index expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions);
-     Index memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size,  GlobalLU_t& glu); 
-     template <typename VectorType>
-     Index memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions);
-     void heap_relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end); 
-     void relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end); 
-     Index snode_dfs(const Index jcol, const Index kcol,const MatrixType& mat,  IndexVector& xprune, IndexVector& marker, GlobalLU_t& glu); 
-     Index snode_bmod (const Index jcol, const Index fsupc, ScalarVector& dense, GlobalLU_t& glu);
-     Index pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow, GlobalLU_t& glu);
-     template <typename Traits>
-     void dfs_kernel(const StorageIndex jj, IndexVector& perm_r,
-                    Index& nseg, IndexVector& panel_lsub, IndexVector& segrep,
-                    Ref<IndexVector> repfnz_col, IndexVector& xprune, Ref<IndexVector> marker, IndexVector& parent,
-                    IndexVector& xplore, GlobalLU_t& glu, Index& nextl_col, Index krow, Traits& traits);
-     void panel_dfs(const Index m, const Index w, const Index jcol, MatrixType& A, IndexVector& perm_r, Index& nseg, ScalarVector& dense, IndexVector& panel_lsub, IndexVector& segrep, IndexVector& repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
-    
-     void panel_bmod(const Index m, const Index w, const Index jcol, const Index nseg, ScalarVector& dense, ScalarVector& tempv, IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu);
-     Index column_dfs(const Index m, const Index jcol, IndexVector& perm_r, Index maxsuper, Index& nseg,  BlockIndexVector lsub_col, IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
-     Index column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv, BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu); 
-     Index copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep, BlockIndexVector repfnz ,IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu); 
-     void pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow, const Index nseg, const IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, GlobalLU_t& glu);
-     void countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu); 
-     void fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu); 
-     
-     template<typename , typename >
-     friend struct column_dfs_traits;
-}; 
+class SparseLUImpl {
+ public:
+  typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
+  typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> ScalarMatrix;
+  typedef Map<ScalarMatrix, 0, OuterStride<> > MappedMatrixBlock;
+  typedef typename ScalarVector::RealScalar RealScalar;
+  typedef Ref<Matrix<Scalar, Dynamic, 1> > BlockScalarVector;
+  typedef Ref<Matrix<StorageIndex, Dynamic, 1> > BlockIndexVector;
+  typedef LU_GlobalLU_t<IndexVector, ScalarVector> GlobalLU_t;
+  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> MatrixType;
+
+ protected:
+  template <typename VectorType>
+  Index expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions);
+  Index memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size, GlobalLU_t& glu);
+  template <typename VectorType>
+  Index memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions);
+  void heap_relax_snode(const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants,
+                        IndexVector& relax_end);
+  void relax_snode(const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants,
+                   IndexVector& relax_end);
+  Index snode_dfs(const Index jcol, const Index kcol, const MatrixType& mat, IndexVector& xprune, IndexVector& marker,
+                  GlobalLU_t& glu);
+  Index snode_bmod(const Index jcol, const Index fsupc, ScalarVector& dense, GlobalLU_t& glu);
+  Index pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c,
+               Index& pivrow, GlobalLU_t& glu);
+  template <typename Traits>
+  void dfs_kernel(const StorageIndex jj, IndexVector& perm_r, Index& nseg, IndexVector& panel_lsub, IndexVector& segrep,
+                  Ref<IndexVector> repfnz_col, IndexVector& xprune, Ref<IndexVector> marker, IndexVector& parent,
+                  IndexVector& xplore, GlobalLU_t& glu, Index& nextl_col, Index krow, Traits& traits);
+  void panel_dfs(const Index m, const Index w, const Index jcol, MatrixType& A, IndexVector& perm_r, Index& nseg,
+                 ScalarVector& dense, IndexVector& panel_lsub, IndexVector& segrep, IndexVector& repfnz,
+                 IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
+
+  void panel_bmod(const Index m, const Index w, const Index jcol, const Index nseg, ScalarVector& dense,
+                  ScalarVector& tempv, IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu);
+  Index column_dfs(const Index m, const Index jcol, IndexVector& perm_r, Index maxsuper, Index& nseg,
+                   BlockIndexVector lsub_col, IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune,
+                   IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
+  Index column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv,
+                    BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu);
+  Index copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep, BlockIndexVector repfnz,
+                     IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu);
+  void pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow, const Index nseg,
+              const IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, GlobalLU_t& glu);
+  void countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu);
+  void fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu);
+
+  template <typename, typename>
+  friend struct column_dfs_traits;
+};
 
-} // end namespace internal
-} // namespace Eigen
+}  // end namespace internal
+}  // namespace Eigen
 
 #endif

package/eigen/Eigen/src/SparseLU/SparseLU_Memory.h

@@ -7,10 +7,10 @@
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-/* 
- 
- * NOTE: This file is the modified version of [s,d,c,z]memory.c files in SuperLU 
- 
+/*
+
+ * NOTE: This file is the modified version of [s,d,c,z]memory.c files in SuperLU
+
  * -- SuperLU routine (version 3.1) --
  * Univ. of California Berkeley, Xerox Palo Alto Research Center,
  * and Lawrence Berkeley National Lab.
@@ -31,196 +31,180 @@
 #ifndef EIGEN_SPARSELU_MEMORY
 #define EIGEN_SPARSELU_MEMORY
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
-  
+
 enum { LUNoMarker = 3 };
-enum {emptyIdxLU = -1};
-inline Index LUnumTempV(Index& m, Index& w, Index& t, Index& b)
-{
-  return (std::max)(m, (t+b)*w);
-}
+enum { emptyIdxLU = -1 };
+inline Index LUnumTempV(Index& m, Index& w, Index& t, Index& b) { return (std::max)(m, (t + b) * w); }
 
-template< typename Scalar>
-inline Index LUTempSpace(Index&m, Index& w)
-{
-  return (2*w + 4 + LUNoMarker) * m * sizeof(Index) + (w + 1) * m * sizeof(Scalar);
+template <typename Scalar>
+inline Index LUTempSpace(Index& m, Index& w) {
+  return (2 * w + 4 + LUNoMarker) * m * sizeof(Index) + (w + 1) * m * sizeof(Scalar);
 }
 
+/**
+ * Expand the existing storage to accommodate more fill-ins
+ * \param vec Valid pointer to the vector to allocate or expand
+ * \param[in,out] length  At input, contain the current length of the vector that is to be increased. At output, length
+ * of the newly allocated vector \param[in] nbElts Current number of elements in the factors \param keep_prev  1: use
+ * length  and do not expand the vector; 0: compute new_len and expand \param[in,out] num_expansions Number of times the
+ * memory has been expanded
+ */
+template <typename Scalar, typename StorageIndex>
+template <typename VectorType>
+Index SparseLUImpl<Scalar, StorageIndex>::expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev,
+                                                 Index& num_expansions) {
+  float alpha = 1.5;  // Ratio of the memory increase
+  Index new_len;      // New size of the allocated memory
 
+  if (num_expansions == 0 || keep_prev)
+    new_len = length;  // First time allocate requested
+  else
+    new_len = (std::max)(length + 1, Index(alpha * length));
 
+  VectorType old_vec;  // Temporary vector to hold the previous values
+  if (nbElts > 0) old_vec = vec.segment(0, nbElts);
 
-/** 
-  * Expand the existing storage to accommodate more fill-ins
-  * \param vec Valid pointer to the vector to allocate or expand
-  * \param[in,out] length  At input, contain the current length of the vector that is to be increased. At output, length of the newly allocated vector
-  * \param[in] nbElts Current number of elements in the factors
-  * \param keep_prev  1: use length  and do not expand the vector; 0: compute new_len and expand
-  * \param[in,out] num_expansions Number of times the memory has been expanded
-  */
-template <typename Scalar, typename StorageIndex>
-template <typename VectorType>
-Index  SparseLUImpl<Scalar,StorageIndex>::expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions) 
-{
-  
-  float alpha = 1.5; // Ratio of the memory increase 
-  Index new_len; // New size of the allocated memory
-  
-  if(num_expansions == 0 || keep_prev) 
-    new_len = length ; // First time allocate requested
-  else 
-    new_len = (std::max)(length+1,Index(alpha * length));
-  
-  VectorType old_vec; // Temporary vector to hold the previous values   
-  if (nbElts > 0 )
-    old_vec = vec.segment(0,nbElts); 
-  
-  //Allocate or expand the current vector
+    // Allocate or expand the current vector
 #ifdef EIGEN_EXCEPTIONS
   try
 #endif
   {
-    vec.resize(new_len); 
+    vec.resize(new_len);
   }
 #ifdef EIGEN_EXCEPTIONS
-  catch(std::bad_alloc& )
+  catch (std::bad_alloc&)
 #else
-  if(!vec.size())
+  if (!vec.size())
 #endif
   {
-    if (!num_expansions)
-    {
+    if (!num_expansions) {
       // First time to allocate from LUMemInit()
       // Let LUMemInit() deals with it.
       return -1;
     }
-    if (keep_prev)
-    {
+    if (keep_prev) {
       // In this case, the memory length should not not be reduced
       return new_len;
-    }
-    else 
-    {
-      // Reduce the size and increase again 
-      Index tries = 0; // Number of attempts
-      do 
-      {
-        alpha = (alpha + 1)/2;
-        new_len = (std::max)(length+1,Index(alpha * length));
+    } else {
+      // Reduce the size and increase again
+      Index tries = 0;  // Number of attempts
+      do {
+        alpha = (alpha + 1) / 2;
+        new_len = (std::max)(length + 1, Index(alpha * length));
 #ifdef EIGEN_EXCEPTIONS
         try
 #endif
         {
-          vec.resize(new_len); 
+          vec.resize(new_len);
         }
 #ifdef EIGEN_EXCEPTIONS
-        catch(std::bad_alloc& )
+        catch (std::bad_alloc&)
 #else
         if (!vec.size())
 #endif
         {
-          tries += 1; 
-          if ( tries > 10) return new_len; 
+          tries += 1;
+          if (tries > 10) return new_len;
         }
       } while (!vec.size());
     }
   }
-  //Copy the previous values to the newly allocated space 
-  if (nbElts > 0)
-    vec.segment(0, nbElts) = old_vec;   
-   
-  
-  length  = new_len;
-  if(num_expansions) ++num_expansions;
-  return 0; 
+  // Copy the previous values to the newly allocated space
+  if (nbElts > 0) vec.segment(0, nbElts) = old_vec;
+
+  length = new_len;
+  if (num_expansions) ++num_expansions;
+  return 0;
 }
 
 /**
  * \brief  Allocate various working space for the numerical factorization phase.
- * \param m number of rows of the input matrix 
- * \param n number of columns 
- * \param annz number of initial nonzeros in the matrix 
+ * \param m number of rows of the input matrix
+ * \param n number of columns
+ * \param annz number of initial nonzeros in the matrix
  * \param lwork  if lwork=-1, this routine returns an estimated size of the required memory
  * \param glu persistent data to facilitate multiple factors : will be deleted later ??
  * \param fillratio estimated ratio of fill in the factors
  * \param panel_size Size of a panel
- * \return an estimated size of the required memory if lwork = -1; otherwise, return the size of actually allocated memory when allocation failed, and 0 on success
- * \note Unlike SuperLU, this routine does not support successive factorization with the same pattern and the same row permutation
+ * \return an estimated size of the required memory if lwork = -1; otherwise, return the size of actually allocated
+ * memory when allocation failed, and 0 on success \note Unlike SuperLU, this routine does not support successive
+ * factorization with the same pattern and the same row permutation
  */
 template <typename Scalar, typename StorageIndex>
-Index SparseLUImpl<Scalar,StorageIndex>::memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size,  GlobalLU_t& glu)
-{
-  Index& num_expansions = glu.num_expansions; //No memory expansions so far
+Index SparseLUImpl<Scalar, StorageIndex>::memInit(Index m, Index n, Index annz, Index lwork, Index fillratio,
+                                                  Index panel_size, GlobalLU_t& glu) {
+  Index& num_expansions = glu.num_expansions;  // No memory expansions so far
   num_expansions = 0;
-  glu.nzumax = glu.nzlumax = (std::min)(fillratio * (annz+1) / n, m) * n; // estimated number of nonzeros in U 
-  glu.nzlmax = (std::max)(Index(4), fillratio) * (annz+1) / 4; // estimated  nnz in L factor
+  glu.nzumax = glu.nzlumax = (std::min)(fillratio * (annz + 1) / n, m) * n;  // estimated number of nonzeros in U
+  glu.nzlmax = (std::max)(Index(4), fillratio) * (annz + 1) / 4;             // estimated  nnz in L factor
   // Return the estimated size to the user if necessary
   Index tempSpace;
-  tempSpace = (2*panel_size + 4 + LUNoMarker) * m * sizeof(Index) + (panel_size + 1) * m * sizeof(Scalar);
-  if (lwork == emptyIdxLU) 
-  {
+  tempSpace = (2 * panel_size + 4 + LUNoMarker) * m * sizeof(Index) + (panel_size + 1) * m * sizeof(Scalar);
+  if (lwork == emptyIdxLU) {
     Index estimated_size;
-    estimated_size = (5 * n + 5) * sizeof(Index)  + tempSpace
-                    + (glu.nzlmax + glu.nzumax) * sizeof(Index) + (glu.nzlumax+glu.nzumax) *  sizeof(Scalar) + n; 
+    estimated_size = (5 * n + 5) * sizeof(Index) + tempSpace + (glu.nzlmax + glu.nzumax) * sizeof(Index) +
+                     (glu.nzlumax + glu.nzumax) * sizeof(Scalar) + n;
     return estimated_size;
   }
-  
-  // Setup the required space 
-  
+
+  // Setup the required space
+
   // First allocate Integer pointers for L\U factors
-  glu.xsup.resize(n+1);
-  glu.supno.resize(n+1);
-  glu.xlsub.resize(n+1);
-  glu.xlusup.resize(n+1);
-  glu.xusub.resize(n+1);
+  glu.xsup.resize(n + 1);
+  glu.supno.resize(n + 1);
+  glu.xlsub.resize(n + 1);
+  glu.xlusup.resize(n + 1);
+  glu.xusub.resize(n + 1);
 
   // Reserve memory for L/U factors
-  do 
-  {
-    if(     (expand<ScalarVector>(glu.lusup, glu.nzlumax, 0, 0, num_expansions)<0)
-        ||  (expand<ScalarVector>(glu.ucol,  glu.nzumax,  0, 0, num_expansions)<0)
-        ||  (expand<IndexVector> (glu.lsub,  glu.nzlmax,  0, 0, num_expansions)<0)
-        ||  (expand<IndexVector> (glu.usub,  glu.nzumax,  0, 1, num_expansions)<0) )
-    {
-      //Reduce the estimated size and retry
+  do {
+    if ((expand<ScalarVector>(glu.lusup, glu.nzlumax, 0, 0, num_expansions) < 0) ||
+        (expand<ScalarVector>(glu.ucol, glu.nzumax, 0, 0, num_expansions) < 0) ||
+        (expand<IndexVector>(glu.lsub, glu.nzlmax, 0, 0, num_expansions) < 0) ||
+        (expand<IndexVector>(glu.usub, glu.nzumax, 0, 1, num_expansions) < 0)) {
+      // Reduce the estimated size and retry
       glu.nzlumax /= 2;
       glu.nzumax /= 2;
       glu.nzlmax /= 2;
-      if (glu.nzlumax < annz ) return glu.nzlumax; 
+      if (glu.nzlumax < annz) return glu.nzlumax;
     }
   } while (!glu.lusup.size() || !glu.ucol.size() || !glu.lsub.size() || !glu.usub.size());
-  
+
   ++num_expansions;
   return 0;
-  
-} // end LuMemInit
 
-/** 
- * \brief Expand the existing storage 
- * \param vec vector to expand 
+}  // end LuMemInit
+
+/**
+ * \brief Expand the existing storage
+ * \param vec vector to expand
  * \param[in,out] maxlen On input, previous size of vec (Number of elements to copy ). on output, new size
  * \param nbElts current number of elements in the vector.
  * \param memtype Type of the element to expand
- * \param num_expansions Number of expansions 
+ * \param num_expansions Number of expansions
  * \return 0 on success, > 0 size of the memory allocated so far
  */
 template <typename Scalar, typename StorageIndex>
 template <typename VectorType>
-Index SparseLUImpl<Scalar,StorageIndex>::memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions)
-{
-  Index failed_size; 
+Index SparseLUImpl<Scalar, StorageIndex>::memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype,
+                                                   Index& num_expansions) {
+  Index failed_size;
   if (memtype == USUB)
-     failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 1, num_expansions);
+    failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 1, num_expansions);
   else
     failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 0, num_expansions);
 
-  if (failed_size)
-    return failed_size; 
-  
-  return 0 ;  
+  if (failed_size) return failed_size;
+
+  return 0;
 }
 
-} // end namespace internal
+}  // end namespace internal
 
-} // end namespace Eigen
-#endif // EIGEN_SPARSELU_MEMORY
+}  // end namespace Eigen
+#endif  // EIGEN_SPARSELU_MEMORY

package/eigen/Eigen/src/SparseLU/SparseLU_Structs.h

@@ -7,26 +7,26 @@
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-/* 
+/*
  * NOTE: This file comes from a partly modified version of files slu_[s,d,c,z]defs.h
  * -- SuperLU routine (version 4.1) --
  * Univ. of California Berkeley, Xerox Palo Alto Research Center,
  * and Lawrence Berkeley National Lab.
  * November, 2010
- * 
+ *
  * Global data structures used in LU factorization -
- * 
+ *
  *   nsuper: #supernodes = nsuper + 1, numbered [0, nsuper].
  *   (xsup,supno): supno[i] is the supernode no to which i belongs;
  *  xsup(s) points to the beginning of the s-th supernode.
  *  e.g.   supno 0 1 2 2 3 3 3 4 4 4 4 4   (n=12)
  *          xsup 0 1 2 4 7 12
- *  Note: dfs will be performed on supernode rep. relative to the new 
+ *  Note: dfs will be performed on supernode rep. relative to the new
  *        row pivoting ordering
  *
  *   (xlsub,lsub): lsub[*] contains the compressed subscript of
  *  rectangular supernodes; xlsub[j] points to the starting
- *  location of the j-th column in lsub[*]. Note that xlsub 
+ *  location of the j-th column in lsub[*]. Note that xlsub
  *  is indexed by column.
  *  Storage: original row subscripts
  *
@@ -50,7 +50,7 @@
  *  values.
  *
  *  The last column structures (for pruning) will be removed
- *  after the numercial LU factorization phase.
+ *  after the numerical LU factorization phase.
  *
  *   (xlusup,lusup): lusup[*] contains the numerical values of the
  *  rectangular supernodes; xlusup[j] points to the starting
@@ -68,43 +68,46 @@
 
 #ifndef EIGEN_LU_STRUCTS
 #define EIGEN_LU_STRUCTS
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
-  
-typedef enum {LUSUP, UCOL, LSUB, USUB, LLVL, ULVL} MemType; 
+
+enum MemType { LUSUP, UCOL, LSUB, USUB, LLVL, ULVL };
 
 template <typename IndexVector, typename ScalarVector>
 struct LU_GlobalLU_t {
-  typedef typename IndexVector::Scalar StorageIndex; 
-  IndexVector xsup; //First supernode column ... xsup(s) points to the beginning of the s-th supernode
-  IndexVector supno; // Supernode number corresponding to this column (column to supernode mapping)
-  ScalarVector  lusup; // nonzero values of L ordered by columns 
-  IndexVector lsub; // Compressed row indices of L rectangular supernodes. 
-  IndexVector xlusup; // pointers to the beginning of each column in lusup
-  IndexVector xlsub; // pointers to the beginning of each column in lsub
-  Index   nzlmax; // Current max size of lsub
-  Index   nzlumax; // Current max size of lusup
-  ScalarVector  ucol; // nonzero values of U ordered by columns 
-  IndexVector usub; // row indices of U columns in ucol
-  IndexVector xusub; // Pointers to the beginning of each column of U in ucol 
-  Index   nzumax; // Current max size of ucol
-  Index   n; // Number of columns in the matrix  
-  Index   num_expansions; 
+  typedef typename IndexVector::Scalar StorageIndex;
+  IndexVector xsup;    // First supernode column ... xsup(s) points to the beginning of the s-th supernode
+  IndexVector supno;   // Supernode number corresponding to this column (column to supernode mapping)
+  ScalarVector lusup;  // nonzero values of L ordered by columns
+  IndexVector lsub;    // Compressed row indices of L rectangular supernodes.
+  IndexVector xlusup;  // pointers to the beginning of each column in lusup
+  IndexVector xlsub;   // pointers to the beginning of each column in lsub
+  Index nzlmax;        // Current max size of lsub
+  Index nzlumax;       // Current max size of lusup
+  ScalarVector ucol;   // nonzero values of U ordered by columns
+  IndexVector usub;    // row indices of U columns in ucol
+  IndexVector xusub;   // Pointers to the beginning of each column of U in ucol
+  Index nzumax;        // Current max size of ucol
+  Index n;             // Number of columns in the matrix
+  Index num_expansions;
 };
 
 // Values to set for performance
 struct perfvalues {
-  Index panel_size; // a panel consists of at most <panel_size> consecutive columns
-  Index relax; // To control degree of relaxing supernodes. If the number of nodes (columns) 
-                // in a subtree of the elimination tree is less than relax, this subtree is considered 
-                // as one supernode regardless of the row structures of those columns
-  Index maxsuper; // The maximum size for a supernode in complete LU
-  Index rowblk; // The minimum row dimension for 2-D blocking to be used;
-  Index colblk; // The minimum column dimension for 2-D blocking to be used;
-  Index fillfactor; // The estimated fills factors for L and U, compared with A
-}; 
+  Index panel_size;  // a panel consists of at most <panel_size> consecutive columns
+  Index relax;       // To control degree of relaxing supernodes. If the number of nodes (columns)
+                     // in a subtree of the elimination tree is less than relax, this subtree is considered
+                     // as one supernode regardless of the row structures of those columns
+  Index maxsuper;    // The maximum size for a supernode in complete LU
+  Index rowblk;      // The minimum row dimension for 2-D blocking to be used;
+  Index colblk;      // The minimum column dimension for 2-D blocking to be used;
+  Index fillfactor;  // The estimated fills factors for L and U, compared with A
+};
 
-} // end namespace internal
+}  // end namespace internal
 
-} // end namespace Eigen
-#endif // EIGEN_LU_STRUCTS
+}  // end namespace Eigen
+#endif  // EIGEN_LU_STRUCTS