@smake/eigen 1.0.2 → 1.1.1

package/eigen/Eigen/src/SparseLU/SparseLU_pruneL.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]pruneL.c file in SuperLU 
- 
+/*
+
+ * NOTE: This file is the modified version of [s,d,c,z]pruneL.c file in SuperLU
+
  * -- SuperLU routine (version 2.0) --
  * Univ. of California Berkeley, Xerox Palo Alto Research Center,
  * and Lawrence Berkeley National Lab.
@@ -30,6 +30,9 @@
 #ifndef SPARSELU_PRUNEL_H
 #define SPARSELU_PRUNEL_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
 
@@ -37,100 +40,91 @@ namespace internal {
  * \brief Prunes the L-structure.
  *
  * It prunes the L-structure  of supernodes whose L-structure contains the current pivot row "pivrow"
- * 
- * 
+ *
+ *
  * \param jcol The current column of L
  * \param[in] perm_r Row permutation
  * \param[out] pivrow  The pivot row
  * \param nseg Number of segments
- * \param segrep 
+ * \param segrep
  * \param repfnz
- * \param[out] xprune 
+ * \param[out] xprune
  * \param glu Global LU data
- * 
+ *
  */
 template <typename Scalar, typename StorageIndex>
-void SparseLUImpl<Scalar,StorageIndex>::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 SparseLUImpl<Scalar, StorageIndex>::pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow,
+                                                const Index nseg, const IndexVector& segrep, BlockIndexVector repfnz,
+                                                IndexVector& xprune, GlobalLU_t& glu) {
   // For each supernode-rep irep in U(*,j]
-  Index jsupno = glu.supno(jcol); 
-  Index i,irep,irep1; 
-  bool movnum, do_prune = false; 
-  Index kmin = 0, kmax = 0, minloc, maxloc,krow; 
-  for (i = 0; i < nseg; i++)
-  {
-    irep = segrep(i); 
-    irep1 = irep + 1; 
-    do_prune = false; 
-    
-    // Don't prune with a zero U-segment 
-    if (repfnz(irep) == emptyIdxLU) continue; 
-    
+  Index jsupno = glu.supno(jcol);
+  Index i, irep, irep1;
+  bool movnum, do_prune = false;
+  Index kmin = 0, kmax = 0, minloc, maxloc, krow;
+  for (i = 0; i < nseg; i++) {
+    irep = segrep(i);
+    irep1 = irep + 1;
+    do_prune = false;
+
+    // Don't prune with a zero U-segment
+    if (repfnz(irep) == emptyIdxLU) continue;
+
     // If a snode overlaps with the next panel, then the U-segment
-    // is fragmented into two parts -- irep and irep1. We should let 
-    // pruning occur at the rep-column in irep1s snode. 
-    if (glu.supno(irep) == glu.supno(irep1) ) continue; // don't prune 
-    
+    // is fragmented into two parts -- irep and irep1. We should let
+    // pruning occur at the rep-column in irep1s snode.
+    if (glu.supno(irep) == glu.supno(irep1)) continue;  // don't prune
+
     // If it has not been pruned & it has a nonz in row L(pivrow,i)
-    if (glu.supno(irep) != jsupno )
-    {
-      if ( xprune (irep) >= glu.xlsub(irep1) )
-      {
+    if (glu.supno(irep) != jsupno) {
+      if (xprune(irep) >= glu.xlsub(irep1)) {
         kmin = glu.xlsub(irep);
-        kmax = glu.xlsub(irep1) - 1; 
-        for (krow = kmin; krow <= kmax; krow++)
-        {
-          if (glu.lsub(krow) == pivrow) 
-          {
-            do_prune = true; 
-            break; 
+        kmax = glu.xlsub(irep1) - 1;
+        for (krow = kmin; krow <= kmax; krow++) {
+          if (glu.lsub(krow) == pivrow) {
+            do_prune = true;
+            break;
           }
         }
       }
-      
-      if (do_prune) 
-      {
+
+      if (do_prune) {
         // do a quicksort-type partition
         // movnum=true means that the num values have to be exchanged
-        movnum = false; 
-        if (irep == glu.xsup(glu.supno(irep)) ) // Snode of size 1 
-          movnum = true; 
-        
-        while (kmin <= kmax)
-        {
+        movnum = false;
+        if (irep == glu.xsup(glu.supno(irep)))  // Snode of size 1
+          movnum = true;
+
+        while (kmin <= kmax) {
           if (perm_r(glu.lsub(kmax)) == emptyIdxLU)
-            kmax--; 
-          else if ( perm_r(glu.lsub(kmin)) != emptyIdxLU)
+            kmax--;
+          else if (perm_r(glu.lsub(kmin)) != emptyIdxLU)
             kmin++;
-          else 
-          {
+          else {
             // kmin below pivrow (not yet pivoted), and kmax
-            // above pivrow: interchange the two suscripts
-            std::swap(glu.lsub(kmin), glu.lsub(kmax)); 
-            
-            // If the supernode has only one column, then we 
+            // above pivrow: interchange the two subscripts
+            std::swap(glu.lsub(kmin), glu.lsub(kmax));
+
+            // If the supernode has only one column, then we
             // only keep one set of subscripts. For any subscript
-            // intercnahge performed, similar interchange must be 
-            // done on the numerical values. 
-            if (movnum) 
-            {
-              minloc = glu.xlusup(irep) + ( kmin - glu.xlsub(irep) ); 
-              maxloc = glu.xlusup(irep) + ( kmax - glu.xlsub(irep) ); 
-              std::swap(glu.lusup(minloc), glu.lusup(maxloc)); 
+            // intercnahge performed, similar interchange must be
+            // done on the numerical values.
+            if (movnum) {
+              minloc = glu.xlusup(irep) + (kmin - glu.xlsub(irep));
+              maxloc = glu.xlusup(irep) + (kmax - glu.xlsub(irep));
+              std::swap(glu.lusup(minloc), glu.lusup(maxloc));
             }
             kmin++;
             kmax--;
           }
-        } // end while 
-        
-        xprune(irep) = StorageIndex(kmin);  //Pruning 
-      } // end if do_prune 
-    } // end pruning 
-  } // End for each U-segment
+        }  // end while
+
+        xprune(irep) = StorageIndex(kmin);  // Pruning
+      }                                     // end if do_prune
+    }                                       // end pruning
+  }                                         // End for each U-segment
 }
 
-} // end namespace internal
-} // end namespace Eigen
+}  // end namespace internal
+}  // end namespace Eigen
 
-#endif // SPARSELU_PRUNEL_H
+#endif  // SPARSELU_PRUNEL_H

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

@@ -28,56 +28,54 @@
 #ifndef SPARSELU_RELAX_SNODE_H
 #define SPARSELU_RELAX_SNODE_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 
 namespace internal {
- 
-/** 
+
+/**
  * \brief Identify the initial relaxed supernodes
- * 
- * This routine is applied to a column elimination tree. 
+ *
+ * This routine is applied to a column elimination tree.
  * It assumes that the matrix has been reordered according to the postorder of the etree
  * \param n  the number of columns
- * \param et elimination tree 
- * \param relax_columns Maximum number of columns allowed in a relaxed snode 
+ * \param et elimination tree
+ * \param relax_columns Maximum number of columns allowed in a relaxed snode
  * \param descendants Number of descendants of each node in the etree
  * \param relax_end last column in a supernode
  */
 template <typename Scalar, typename StorageIndex>
-void SparseLUImpl<Scalar,StorageIndex>::relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end)
-{
-  
+void SparseLUImpl<Scalar, StorageIndex>::relax_snode(const Index n, IndexVector& et, const Index relax_columns,
+                                                     IndexVector& descendants, IndexVector& relax_end) {
   // compute the number of descendants of each node in the etree
-  Index parent; 
+  Index parent;
   relax_end.setConstant(emptyIdxLU);
   descendants.setZero();
-  for (Index j = 0; j < n; j++) 
-  {
+  for (Index j = 0; j < n; j++) {
     parent = et(j);
-    if (parent != n) // not the dummy root
+    if (parent != n)  // not the dummy root
       descendants(parent) += descendants(j) + 1;
   }
   // Identify the relaxed supernodes by postorder traversal of the etree
-  Index snode_start; // beginning of a snode 
-  for (Index j = 0; j < n; )
-  {
+  Index snode_start;  // beginning of a snode
+  for (Index j = 0; j < n;) {
     parent = et(j);
-    snode_start = j; 
-    while ( parent != n && descendants(parent) < relax_columns ) 
-    {
-      j = parent; 
+    snode_start = j;
+    while (parent != n && descendants(parent) < relax_columns) {
+      j = parent;
       parent = et(j);
     }
-    // Found a supernode in postordered etree, j is the last column 
-    relax_end(snode_start) = StorageIndex(j); // Record last column
+    // Found a supernode in postordered etree, j is the last column
+    relax_end(snode_start) = StorageIndex(j);  // Record last column
     j++;
     // Search for a new leaf
     while (descendants(j) != 0 && j < n) j++;
-  } // End postorder traversal of the etree
-  
+  }  // End postorder traversal of the etree
 }
 
-} // end namespace internal
+}  // end namespace internal
 
-} // end namespace Eigen
+}  // end namespace Eigen
 #endif

package/eigen/Eigen/src/SparseQR/InternalHeaderCheck.h

@@ -0,0 +1,3 @@
+#ifndef EIGEN_SPARSEQR_MODULE_H
+#error "Please include Eigen/SparseQR instead of including headers inside the src directory directly."
+#endif