@smake/eigen 1.0.2 → 1.1.1

package/eigen/Eigen/src/SparseLU/SparseLU_panel_dfs.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]panel_dfs.c file in SuperLU 
- 
+/*
+
+ * NOTE: This file is the modified version of [s,d,c,z]panel_dfs.c file in SuperLU
+
  * -- SuperLU routine (version 2.0) --
  * Univ. of California Berkeley, Xerox Palo Alto Research Center,
  * and Lawrence Berkeley National Lab.
@@ -30,22 +30,20 @@
 #ifndef SPARSELU_PANEL_DFS_H
 #define SPARSELU_PANEL_DFS_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 
 namespace internal {
-  
-template<typename IndexVector>
-struct panel_dfs_traits
-{
+
+template <typename IndexVector>
+struct panel_dfs_traits {
   typedef typename IndexVector::Scalar StorageIndex;
-  panel_dfs_traits(Index jcol, StorageIndex* marker)
-    : m_jcol(jcol), m_marker(marker)
-  {}
-  bool update_segrep(Index krep, StorageIndex jj)
-  {
-    if(m_marker[krep]<m_jcol)
-    {
-      m_marker[krep] = jj; 
+  panel_dfs_traits(Index jcol, StorageIndex* marker) : m_jcol(jcol), m_marker(marker) {}
+  bool update_segrep(Index krep, StorageIndex jj) {
+    if (m_marker[krep] < m_jcol) {
+      m_marker[krep] = jj;
       return true;
     }
     return false;
@@ -56,147 +54,127 @@ struct panel_dfs_traits
   StorageIndex* m_marker;
 };
 
-
 template <typename Scalar, typename StorageIndex>
 template <typename Traits>
-void SparseLUImpl<Scalar,StorageIndex>::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 SparseLUImpl<Scalar, StorageIndex>::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) {
   StorageIndex kmark = marker(krow);
-      
+
   // For each unmarked krow of jj
-  marker(krow) = jj; 
-  StorageIndex kperm = perm_r(krow); 
-  if (kperm == emptyIdxLU ) {
+  marker(krow) = jj;
+  StorageIndex kperm = perm_r(krow);
+  if (kperm == emptyIdxLU) {
     // krow is in L : place it in structure of L(*, jj)
     panel_lsub(nextl_col++) = StorageIndex(krow);  // krow is indexed into A
-    
+
     traits.mem_expand(panel_lsub, nextl_col, kmark);
-  }
-  else 
-  {
+  } else {
     // krow is in U : if its supernode-representative krep
     // has been explored, update repfnz(*)
     // krep = supernode representative of the current row
-    StorageIndex krep = glu.xsup(glu.supno(kperm)+1) - 1; 
+    StorageIndex krep = glu.xsup(glu.supno(kperm) + 1) - 1;
     // First nonzero element in the current column:
-    StorageIndex myfnz = repfnz_col(krep); 
-    
-    if (myfnz != emptyIdxLU )
-    {
+    StorageIndex myfnz = repfnz_col(krep);
+
+    if (myfnz != emptyIdxLU) {
       // Representative visited before
-      if (myfnz > kperm ) repfnz_col(krep) = kperm; 
-      
-    }
-    else 
-    {
+      if (myfnz > kperm) repfnz_col(krep) = kperm;
+
+    } else {
       // Otherwise, perform dfs starting at krep
-      StorageIndex oldrep = emptyIdxLU; 
-      parent(krep) = oldrep; 
-      repfnz_col(krep) = kperm; 
-      StorageIndex xdfs =  glu.xlsub(krep); 
-      Index maxdfs = xprune(krep); 
-      
+      StorageIndex oldrep = emptyIdxLU;
+      parent(krep) = oldrep;
+      repfnz_col(krep) = kperm;
+      StorageIndex xdfs = glu.xlsub(krep);
+      Index maxdfs = xprune(krep);
+
       StorageIndex kpar;
-      do 
-      {
+      do {
         // For each unmarked kchild of krep
-        while (xdfs < maxdfs) 
-        {
-          StorageIndex kchild = glu.lsub(xdfs); 
-          xdfs++; 
-          StorageIndex chmark = marker(kchild); 
-          
-          if (chmark != jj ) 
-          {
-            marker(kchild) = jj; 
-            StorageIndex chperm = perm_r(kchild); 
-            
-            if (chperm == emptyIdxLU) 
-            {
+        while (xdfs < maxdfs) {
+          StorageIndex kchild = glu.lsub(xdfs);
+          xdfs++;
+          StorageIndex chmark = marker(kchild);
+
+          if (chmark != jj) {
+            marker(kchild) = jj;
+            StorageIndex chperm = perm_r(kchild);
+
+            if (chperm == emptyIdxLU) {
               // case kchild is in L: place it in L(*, j)
               panel_lsub(nextl_col++) = kchild;
               traits.mem_expand(panel_lsub, nextl_col, chmark);
-            }
-            else
-            {
+            } else {
               // case kchild is in U :
-              // chrep = its supernode-rep. If its rep has been explored, 
+              // chrep = its supernode-rep. If its rep has been explored,
               // update its repfnz(*)
-              StorageIndex chrep = glu.xsup(glu.supno(chperm)+1) - 1; 
-              myfnz = repfnz_col(chrep); 
-              
-              if (myfnz != emptyIdxLU) 
-              { // Visited before 
-                if (myfnz > chperm) 
-                  repfnz_col(chrep) = chperm; 
-              }
-              else 
-              { // Cont. dfs at snode-rep of kchild
-                xplore(krep) = xdfs; 
-                oldrep = krep; 
-                krep = chrep; // Go deeper down G(L)
-                parent(krep) = oldrep; 
-                repfnz_col(krep) = chperm; 
-                xdfs = glu.xlsub(krep); 
-                maxdfs = xprune(krep); 
-                
-              } // end if myfnz != -1
-            } // end if chperm == -1 
-                
-          } // end if chmark !=jj
-        } // end while xdfs < maxdfs
-        
+              StorageIndex chrep = glu.xsup(glu.supno(chperm) + 1) - 1;
+              myfnz = repfnz_col(chrep);
+
+              if (myfnz != emptyIdxLU) {  // Visited before
+                if (myfnz > chperm) repfnz_col(chrep) = chperm;
+              } else {  // Cont. dfs at snode-rep of kchild
+                xplore(krep) = xdfs;
+                oldrep = krep;
+                krep = chrep;  // Go deeper down G(L)
+                parent(krep) = oldrep;
+                repfnz_col(krep) = chperm;
+                xdfs = glu.xlsub(krep);
+                maxdfs = xprune(krep);
+
+              }  // end if myfnz != -1
+            }    // end if chperm == -1
+
+          }  // end if chmark !=jj
+        }    // end while xdfs < maxdfs
+
         // krow has no more unexplored nbrs :
-        //    Place snode-rep krep in postorder DFS, if this 
-        //    segment is seen for the first time. (Note that 
+        //    Place snode-rep krep in postorder DFS, if this
+        //    segment is seen for the first time. (Note that
         //    "repfnz(krep)" may change later.)
         //    Baktrack dfs to its parent
-        if(traits.update_segrep(krep,jj))
-        //if (marker1(krep) < jcol )
+        if (traits.update_segrep(krep, jj))
+        // if (marker1(krep) < jcol )
         {
-          segrep(nseg) = krep; 
-          ++nseg; 
-          //marker1(krep) = jj; 
+          segrep(nseg) = krep;
+          ++nseg;
+          // marker1(krep) = jj;
         }
-        
-        kpar = parent(krep); // Pop recursion, mimic recursion 
-        if (kpar == emptyIdxLU) 
-          break; // dfs done 
-        krep = kpar; 
-        xdfs = xplore(krep); 
-        maxdfs = xprune(krep); 
-
-      } while (kpar != emptyIdxLU); // Do until empty stack 
-      
-    } // end if (myfnz = -1)
-
-  } // end if (kperm == -1)   
+
+        kpar = parent(krep);            // Pop recursion, mimic recursion
+        if (kpar == emptyIdxLU) break;  // dfs done
+        krep = kpar;
+        xdfs = xplore(krep);
+        maxdfs = xprune(krep);
+
+      } while (kpar != emptyIdxLU);  // Do until empty stack
+
+    }  // end if (myfnz = -1)
+
+  }  // end if (kperm == -1)
 }
 
 /**
  * \brief Performs a symbolic factorization on a panel of columns [jcol, jcol+w)
- * 
+ *
  * A supernode representative is the last column of a supernode.
  * The nonzeros in U[*,j] are segments that end at supernodes representatives
- * 
- * The routine returns a list of the supernodal representatives 
- * in topological order of the dfs that generates them. This list is 
- * a superset of the topological order of each individual column within 
+ *
+ * The routine returns a list of the supernodal representatives
+ * in topological order of the dfs that generates them. This list is
+ * a superset of the topological order of each individual column within
  * the panel.
- * The location of the first nonzero in each supernodal segment 
- * (supernodal entry location) is also returned. Each column has 
- * a separate list for this purpose. 
- * 
+ * The location of the first nonzero in each supernodal segment
+ * (supernodal entry location) is also returned. Each column has
+ * a separate list for this purpose.
+ *
  * Two markers arrays are used for dfs :
  *    marker[i] == jj, if i was visited during dfs of current column jj;
- *    marker1[i] >= jcol, if i was visited by earlier columns in this panel; 
- * 
+ *    marker1[i] >= jcol, if i was visited by earlier columns in this panel;
+ *
  * \param[in] m number of rows in the matrix
  * \param[in] w Panel size
  * \param[in] jcol Starting  column of the panel
@@ -204,7 +182,7 @@ void SparseLUImpl<Scalar,StorageIndex>::dfs_kernel(const StorageIndex jj, IndexV
  * \param[in] perm_r Row permutation
  * \param[out] nseg Number of U segments
  * \param[out] dense Accumulate the column vectors of the panel
- * \param[out] panel_lsub Subscripts of the row in the panel 
+ * \param[out] panel_lsub Subscripts of the row in the panel
  * \param[out] segrep Segment representative i.e first nonzero row of each segment
  * \param[out] repfnz First nonzero location in each row
  * \param[out] xprune The pruned elimination tree
@@ -212,47 +190,46 @@ void SparseLUImpl<Scalar,StorageIndex>::dfs_kernel(const StorageIndex jj, IndexV
  * \param  parent The elimination tree
  * \param xplore work vector
  * \param glu The global data structure
- * 
+ *
  */
 
 template <typename Scalar, typename StorageIndex>
-void SparseLUImpl<Scalar,StorageIndex>::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)
-{
-  Index nextl_col; // Next available position in panel_lsub[*,jj] 
-  
-  // Initialize pointers 
-  VectorBlock<IndexVector> marker1(marker, m, m); 
-  nseg = 0; 
-  
+void SparseLUImpl<Scalar, StorageIndex>::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) {
+  Index nextl_col;  // Next available position in panel_lsub[*,jj]
+
+  // Initialize pointers
+  VectorBlock<IndexVector> marker1(marker, m, m);
+  nseg = 0;
+
   panel_dfs_traits<IndexVector> traits(jcol, marker1.data());
-  
-  // For each column in the panel 
-  for (StorageIndex jj = StorageIndex(jcol); jj < jcol + w; jj++) 
-  {
-    nextl_col = (jj - jcol) * m; 
-    
-    VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero location in each row
-    VectorBlock<ScalarVector> dense_col(dense,nextl_col, m); // Accumulate a column vector here
-    
-    
+
+  // For each column in the panel
+  for (StorageIndex jj = StorageIndex(jcol); jj < jcol + w; jj++) {
+    nextl_col = (jj - jcol) * m;
+
+    VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m);  // First nonzero location in each row
+    VectorBlock<ScalarVector> dense_col(dense, nextl_col, m);   // Accumulate a column vector here
+
     // For each nnz in A[*, jj] do depth first search
-    for (typename MatrixType::InnerIterator it(A, jj); it; ++it)
-    {
-      Index krow = it.row(); 
+    for (typename MatrixType::InnerIterator it(A, jj); it; ++it) {
+      Index krow = it.row();
       dense_col(krow) = it.value();
-      
-      StorageIndex kmark = marker(krow); 
-      if (kmark == jj) 
-        continue; // krow visited before, go to the next nonzero
-      
-      dfs_kernel(jj, perm_r, nseg, panel_lsub, segrep, repfnz_col, xprune, marker, parent,
-                   xplore, glu, nextl_col, krow, traits);
-    }// end for nonzeros in column jj
-    
-  } // end for column jj
+
+      StorageIndex kmark = marker(krow);
+      if (kmark == jj) continue;  // krow visited before, go to the next nonzero
+
+      dfs_kernel(jj, perm_r, nseg, panel_lsub, segrep, repfnz_col, xprune, marker, parent, xplore, glu, nextl_col, krow,
+                 traits);
+    }  // end for nonzeros in column jj
+
+  }  // end for column jj
 }
 
-} // end namespace internal
-} // end namespace Eigen
+}  // end namespace internal
+}  // end namespace Eigen
 
-#endif // SPARSELU_PANEL_DFS_H
+#endif  // SPARSELU_PANEL_DFS_H

package/eigen/Eigen/src/SparseLU/SparseLU_pivotL.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 xpivotL.c file in SuperLU 
- 
+/*
+
+ * NOTE: This file is the modified version of xpivotL.c file in SuperLU
+
  * -- SuperLU routine (version 3.0) --
  * Univ. of California Berkeley, Xerox Palo Alto Research Center,
  * and Lawrence Berkeley National Lab.
@@ -30,12 +30,15 @@
 #ifndef SPARSELU_PIVOTL_H
 #define SPARSELU_PIVOTL_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
-  
+
 /**
- * \brief Performs the numerical pivotin on the current column of L, and the CDIV operation.
- * 
+ * \brief Performs the numerical pivoting on the current column of L, and the CDIV operation.
+ *
  * Pivot policy :
  * (1) Compute thresh = u * max_(i>=j) abs(A_ij);
  * (2) IF user specifies pivot row k and abs(A_kj) >= thresh THEN
@@ -44,64 +47,63 @@ namespace internal {
  *           pivot row = j;
  *       ELSE
  *           pivot row = m;
- * 
+ *
  *   Note: If you absolutely want to use a given pivot order, then set u=0.0.
- * 
+ *
  * \param jcol The current column of L
  * \param diagpivotthresh diagonal pivoting threshold
  * \param[in,out] perm_r Row permutation (threshold pivoting)
  * \param[in] iperm_c column permutation - used to finf diagonal of Pc*A*Pc'
  * \param[out] pivrow  The pivot row
  * \param glu Global LU data
- * \return 0 if success, i > 0 if U(i,i) is exactly zero 
- * 
+ * \return 0 if success, i > 0 if U(i,i) is exactly zero
+ *
  */
 template <typename Scalar, typename StorageIndex>
-Index SparseLUImpl<Scalar,StorageIndex>::pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow, GlobalLU_t& glu)
-{
-  
-  Index fsupc = (glu.xsup)((glu.supno)(jcol)); // First column in the supernode containing the column jcol
-  Index nsupc = jcol - fsupc; // Number of columns in the supernode portion, excluding jcol; nsupc >=0
-  Index lptr = glu.xlsub(fsupc); // pointer to the starting location of the row subscripts for this supernode portion
-  Index nsupr = glu.xlsub(fsupc+1) - lptr; // Number of rows in the supernode
-  Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc); // leading dimension
-  Scalar* lu_sup_ptr = &(glu.lusup.data()[glu.xlusup(fsupc)]); // Start of the current supernode
-  Scalar* lu_col_ptr = &(glu.lusup.data()[glu.xlusup(jcol)]); // Start of jcol in the supernode
-  StorageIndex* lsub_ptr = &(glu.lsub.data()[lptr]); // Start of row indices of the supernode
-  
-  // Determine the largest abs numerical value for partial pivoting 
-  Index diagind = iperm_c(jcol); // diagonal index 
+Index SparseLUImpl<Scalar, StorageIndex>::pivotL(const Index jcol, const RealScalar& diagpivotthresh,
+                                                 IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow,
+                                                 GlobalLU_t& glu) {
+  Index fsupc = (glu.xsup)((glu.supno)(jcol));  // First column in the supernode containing the column jcol
+  Index nsupc = jcol - fsupc;                   // Number of columns in the supernode portion, excluding jcol; nsupc >=0
+  Index lptr = glu.xlsub(fsupc);  // pointer to the starting location of the row subscripts for this supernode portion
+  Index nsupr = glu.xlsub(fsupc + 1) - lptr;                    // Number of rows in the supernode
+  Index lda = glu.xlusup(fsupc + 1) - glu.xlusup(fsupc);        // leading dimension
+  Scalar* lu_sup_ptr = &(glu.lusup.data()[glu.xlusup(fsupc)]);  // Start of the current supernode
+  Scalar* lu_col_ptr = &(glu.lusup.data()[glu.xlusup(jcol)]);   // Start of jcol in the supernode
+  StorageIndex* lsub_ptr = &(glu.lsub.data()[lptr]);            // Start of row indices of the supernode
+
+  // Determine the largest abs numerical value for partial pivoting
+  Index diagind = iperm_c(jcol);  // diagonal index
   RealScalar pivmax(-1.0);
-  Index pivptr = nsupc; 
-  Index diag = emptyIdxLU; 
+  Index pivptr = nsupc;
+  Index diag = emptyIdxLU;
   RealScalar rtemp;
-  Index isub, icol, itemp, k; 
+  Index isub, icol, itemp, k;
   for (isub = nsupc; isub < nsupr; ++isub) {
     using std::abs;
     rtemp = abs(lu_col_ptr[isub]);
     if (rtemp > pivmax) {
-      pivmax = rtemp; 
+      pivmax = rtemp;
       pivptr = isub;
-    } 
+    }
     if (lsub_ptr[isub] == diagind) diag = isub;
   }
-  
+
   // Test for singularity
-  if ( pivmax <= RealScalar(0.0) ) {
+  if (pivmax <= RealScalar(0.0)) {
     // if pivmax == -1, the column is structurally empty, otherwise it is only numerically zero
     pivrow = pivmax < RealScalar(0.0) ? diagind : lsub_ptr[pivptr];
     perm_r(pivrow) = StorageIndex(jcol);
-    return (jcol+1);
+    return (jcol + 1);
   }
-  
-  RealScalar thresh = diagpivotthresh * pivmax; 
-  
-  // Choose appropriate pivotal element 
-  
+
+  RealScalar thresh = diagpivotthresh * pivmax;
+
+  // Choose appropriate pivotal element
+
   {
     // Test if the diagonal element can be used as a pivot (given the threshold value)
-    if (diag >= 0 ) 
-    {
+    if (diag >= 0) {
       // Diagonal element exists
       using std::abs;
       rtemp = abs(lu_col_ptr[diag]);
@@ -109,29 +111,26 @@ Index SparseLUImpl<Scalar,StorageIndex>::pivotL(const Index jcol, const RealScal
     }
     pivrow = lsub_ptr[pivptr];
   }
-  
+
   // Record pivot row
   perm_r(pivrow) = StorageIndex(jcol);
   // Interchange row subscripts
-  if (pivptr != nsupc )
-  {
-    std::swap( lsub_ptr[pivptr], lsub_ptr[nsupc] );
+  if (pivptr != nsupc) {
+    std::swap(lsub_ptr[pivptr], lsub_ptr[nsupc]);
     // Interchange numerical values as well, for the two rows in the whole snode
     // such that L is indexed the same way as A
-    for (icol = 0; icol <= nsupc; icol++)
-    {
-      itemp = pivptr + icol * lda; 
+    for (icol = 0; icol <= nsupc; icol++) {
+      itemp = pivptr + icol * lda;
       std::swap(lu_sup_ptr[itemp], lu_sup_ptr[nsupc + icol * lda]);
     }
   }
   // cdiv operations
   Scalar temp = Scalar(1.0) / lu_col_ptr[nsupc];
-  for (k = nsupc+1; k < nsupr; k++)
-    lu_col_ptr[k] *= temp; 
+  for (k = nsupc + 1; k < nsupr; k++) lu_col_ptr[k] *= temp;
   return 0;
 }
 
-} // end namespace internal
-} // end namespace Eigen
+}  // end namespace internal
+}  // end namespace Eigen
 
-#endif // SPARSELU_PIVOTL_H
+#endif  // SPARSELU_PIVOTL_H