@smake/eigen 1.1.0 → 1.1.1

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

@@ -6,10 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // 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]copy_to_ucol.c file in SuperLU 
- 
+/*
+
+ * NOTE: This file is the modified version of [s,d,c,z]copy_to_ucol.c file in SuperLU
+
  * -- SuperLU routine (version 2.0) --
  * Univ. of California Berkeley, Xerox Palo Alto Research Center,
  * and Lawrence Berkeley National Lab.
@@ -29,79 +29,78 @@
 #ifndef SPARSELU_COPY_TO_UCOL_H
 #define SPARSELU_COPY_TO_UCOL_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
 
 /**
  * \brief Performs numeric block updates (sup-col) in topological order
- * 
+ *
  * \param jcol current column to update
  * \param nseg Number of segments in the U part
  * \param segrep segment representative ...
  * \param repfnz First nonzero column in each row  ...
- * \param perm_r Row permutation 
+ * \param perm_r Row permutation
  * \param dense Store the full representation of the column
- * \param glu Global LU data. 
- * \return 0 - successful return 
+ * \param glu Global LU data.
+ * \return 0 - successful return
  *         > 0 - number of bytes allocated when run out of space
- * 
+ *
  */
 template <typename Scalar, typename StorageIndex>
-Index SparseLUImpl<Scalar,StorageIndex>::copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep,
-                                                      BlockIndexVector repfnz ,IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu)
-{  
-  Index ksub, krep, ksupno; 
-    
+Index SparseLUImpl<Scalar, StorageIndex>::copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep,
+                                                       BlockIndexVector repfnz, IndexVector& perm_r,
+                                                       BlockScalarVector dense, GlobalLU_t& glu) {
+  Index ksub, krep, ksupno;
+
   Index jsupno = glu.supno(jcol);
-  
-  // For each nonzero supernode segment of U[*,j] in topological order 
-  Index k = nseg - 1, i; 
-  StorageIndex nextu = glu.xusub(jcol); 
-  Index kfnz, isub, segsize; 
-  Index new_next,irow; 
-  Index fsupc, mem; 
-  for (ksub = 0; ksub < nseg; ksub++)
-  {
-    krep = segrep(k); k--; 
-    ksupno = glu.supno(krep); 
-    if (jsupno != ksupno ) // should go into ucol(); 
+
+  // For each nonzero supernode segment of U[*,j] in topological order
+  Index k = nseg - 1, i;
+  StorageIndex nextu = glu.xusub(jcol);
+  Index kfnz, isub, segsize;
+  Index new_next, irow;
+  Index fsupc, mem;
+  for (ksub = 0; ksub < nseg; ksub++) {
+    krep = segrep(k);
+    k--;
+    ksupno = glu.supno(krep);
+    if (jsupno != ksupno)  // should go into ucol();
     {
-      kfnz = repfnz(krep); 
-      if (kfnz != emptyIdxLU)
-      { // Nonzero U-segment 
-        fsupc = glu.xsup(ksupno); 
-        isub = glu.xlsub(fsupc) + kfnz - fsupc; 
-        segsize = krep - kfnz + 1; 
-        new_next = nextu + segsize; 
-        while (new_next > glu.nzumax) 
-        {
-          mem = memXpand<ScalarVector>(glu.ucol, glu.nzumax, nextu, UCOL, glu.num_expansions); 
-          if (mem) return mem; 
-          mem = memXpand<IndexVector>(glu.usub, glu.nzumax, nextu, USUB, glu.num_expansions); 
-          if (mem) return mem; 
-          
+      kfnz = repfnz(krep);
+      if (kfnz != emptyIdxLU) {  // Nonzero U-segment
+        fsupc = glu.xsup(ksupno);
+        isub = glu.xlsub(fsupc) + kfnz - fsupc;
+        segsize = krep - kfnz + 1;
+        new_next = nextu + segsize;
+        while (new_next > glu.nzumax) {
+          mem = memXpand<ScalarVector>(glu.ucol, glu.nzumax, nextu, UCOL, glu.num_expansions);
+          if (mem) return mem;
+          mem = memXpand<IndexVector>(glu.usub, glu.nzumax, nextu, USUB, glu.num_expansions);
+          if (mem) return mem;
         }
-        
-        for (i = 0; i < segsize; i++)
-        {
-          irow = glu.lsub(isub); 
-          glu.usub(nextu) = perm_r(irow); // Unlike the L part, the U part is stored in its final order
-          glu.ucol(nextu) = dense(irow); 
-          dense(irow) = Scalar(0.0); 
+
+        for (i = 0; i < segsize; i++) {
+          irow = glu.lsub(isub);
+          glu.usub(nextu) = perm_r(irow);  // Unlike the L part, the U part is stored in its final order
+          glu.ucol(nextu) = dense(irow);
+          dense(irow) = Scalar(0.0);
           nextu++;
           isub++;
         }
-        
-      } // end nonzero U-segment 
-      
-    } // end if jsupno 
-    
-  } // end for each segment
-  glu.xusub(jcol + 1) = nextu; // close U(*,jcol)
-  return 0; 
+
+      }  // end nonzero U-segment
+
+    }  // end if jsupno
+
+  }                             // end for each segment
+  glu.xusub(jcol + 1) = nextu;  // close U(*,jcol)
+  return 0;
 }
 
-} // namespace internal
-} // end namespace Eigen
+}  // namespace internal
+}  // end namespace Eigen
 
-#endif // SPARSELU_COPY_TO_UCOL_H
+#endif  // SPARSELU_COPY_TO_UCOL_H

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

@@ -28,99 +28,87 @@
 #ifndef SPARSELU_HEAP_RELAX_SNODE_H
 #define SPARSELU_HEAP_RELAX_SNODE_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
 
-/** 
+/**
  * \brief Identify the initial relaxed supernodes
- * 
- * This routine applied to a symmetric elimination tree. 
+ *
+ * This routine applied to a symmetric 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>::heap_relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end)
-{
-  
-  // The etree may not be postordered, but its heap ordered  
+void SparseLUImpl<Scalar, StorageIndex>::heap_relax_snode(const Index n, IndexVector& et, const Index relax_columns,
+                                                          IndexVector& descendants, IndexVector& relax_end) {
+  // The etree may not be postordered, but its heap ordered
   IndexVector post;
-  internal::treePostorder(StorageIndex(n), et, post); // Post order etree
-  IndexVector inv_post(n+1); 
-  for (StorageIndex i = 0; i < n+1; ++i) inv_post(post(i)) = i; // inv_post = post.inverse()???
-  
-  // Renumber etree in postorder 
+  internal::treePostorder(StorageIndex(n), et, post);  // Post order etree
+  IndexVector inv_post(n + 1);
+  for (StorageIndex i = 0; i < n + 1; ++i) inv_post(post(i)) = i;  // inv_post = post.inverse()???
+
+  // Renumber etree in postorder
   IndexVector iwork(n);
-  IndexVector et_save(n+1);
-  for (Index i = 0; i < n; ++i)
-  {
+  IndexVector et_save(n + 1);
+  for (Index i = 0; i < n; ++i) {
     iwork(post(i)) = post(et(i));
   }
-  et_save = et; // Save the original etree
-  et = iwork; 
-  
+  et_save = et;  // Save the original etree
+  et = iwork;
+
   // compute the number of descendants of each node in the etree
   relax_end.setConstant(emptyIdxLU);
-  Index j, parent; 
+  Index j, parent;
   descendants.setZero();
-  for (j = 0; j < n; j++) 
-  {
+  for (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 
+  Index snode_start;  // beginning of a snode
   StorageIndex k;
-  Index nsuper_et_post = 0; // Number of relaxed snodes in postordered etree 
-  Index nsuper_et = 0; // Number of relaxed snodes in the original etree 
-  StorageIndex l; 
-  for (j = 0; j < n; )
-  {
+  StorageIndex l;
+  for (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 
-    ++nsuper_et_post;
+    // Found a supernode in postordered etree, j is the last column
     k = StorageIndex(n);
-    for (Index i = snode_start; i <= j; ++i)
-      k = (std::min)(k, inv_post(i));
+    for (Index i = snode_start; i <= j; ++i) k = (std::min)(k, inv_post(i));
     l = inv_post(j);
-    if ( (l - k) == (j - snode_start) )  // Same number of columns in the snode
+    if ((l - k) == (j - snode_start))  // Same number of columns in the snode
     {
       // This is also a supernode in the original etree
-      relax_end(k) = l; // Record last column 
-      ++nsuper_et; 
-    }
-    else 
-    {
-      for (Index i = snode_start; i <= j; ++i) 
-      {
+      relax_end(k) = l;  // Record last column
+    } else {
+      for (Index i = snode_start; i <= j; ++i) {
         l = inv_post(i);
-        if (descendants(i) == 0) 
-        {
+        if (descendants(i) == 0) {
           relax_end(l) = l;
-          ++nsuper_et;
         }
       }
     }
     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
+
   // Recover the original etree
-  et = et_save; 
+  et = et_save;
 }
 
-} // end namespace internal
+}  // end namespace internal
 
-} // end namespace Eigen
-#endif // SPARSELU_HEAP_RELAX_SNODE_H
+}  // end namespace Eigen
+#endif  // SPARSELU_HEAP_RELAX_SNODE_H

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

@@ -11,120 +11,123 @@
 #ifndef SPARSELU_KERNEL_BMOD_H
 #define SPARSELU_KERNEL_BMOD_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
-  
-template <int SegSizeAtCompileTime> struct LU_kernel_bmod
-{
+
+template <int SegSizeAtCompileTime>
+struct LU_kernel_bmod {
   /** \internal
-    * \brief Performs numeric block updates from a given supernode to a single column
-    *
-    * \param segsize Size of the segment (and blocks ) to use for updates
-    * \param[in,out] dense Packed values of the original matrix
-    * \param tempv temporary vector to use for updates
-    * \param lusup array containing the supernodes
-    * \param lda Leading dimension in the supernode
-    * \param nrow Number of rows in the rectangular part of the supernode
-    * \param lsub compressed row subscripts of supernodes
-    * \param lptr pointer to the first column of the current supernode in lsub
-    * \param no_zeros Number of nonzeros elements before the diagonal part of the supernode
-    */
+   * \brief Performs numeric block updates from a given supernode to a single column
+   *
+   * \param segsize Size of the segment (and blocks ) to use for updates
+   * \param[in,out] dense Packed values of the original matrix
+   * \param tempv temporary vector to use for updates
+   * \param lusup array containing the supernodes
+   * \param lda Leading dimension in the supernode
+   * \param nrow Number of rows in the rectangular part of the supernode
+   * \param lsub compressed row subscripts of supernodes
+   * \param lptr pointer to the first column of the current supernode in lsub
+   * \param no_zeros Number of nonzeros elements before the diagonal part of the supernode
+   */
   template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
-  static EIGEN_DONT_INLINE void run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda,
-                                    const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros);
+  static EIGEN_DONT_INLINE void run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv,
+                                    ScalarVector& lusup, Index& luptr, const Index lda, const Index nrow,
+                                    IndexVector& lsub, const Index lptr, const Index no_zeros);
 };
 
 template <int SegSizeAtCompileTime>
 template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
-EIGEN_DONT_INLINE void LU_kernel_bmod<SegSizeAtCompileTime>::run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda,
-                                                                  const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros)
-{
+EIGEN_DONT_INLINE void LU_kernel_bmod<SegSizeAtCompileTime>::run(const Index segsize, BlockScalarVector& dense,
+                                                                 ScalarVector& tempv, ScalarVector& lusup, Index& luptr,
+                                                                 const Index lda, const Index nrow, IndexVector& lsub,
+                                                                 const Index lptr, const Index no_zeros) {
   typedef typename ScalarVector::Scalar Scalar;
   // First, copy U[*,j] segment from dense(*) to tempv(*)
-  // The result of triangular solve is in tempv[*]; 
-    // The result of matric-vector update is in dense[*]
-  Index isub = lptr + no_zeros; 
+  // The result of triangular solve is in tempv[*];
+  // The result of matric-vector update is in dense[*]
+  Index isub = lptr + no_zeros;
   Index i;
   Index irow;
-  for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++)
-  {
-    irow = lsub(isub); 
-    tempv(i) = dense(irow); 
-    ++isub; 
+  for (i = 0; i < ((SegSizeAtCompileTime == Dynamic) ? segsize : SegSizeAtCompileTime); i++) {
+    irow = lsub(isub);
+    tempv(i) = dense(irow);
+    ++isub;
   }
   // Dense triangular solve -- start effective triangle
-  luptr += lda * no_zeros + no_zeros; 
-  // Form Eigen matrix and vector 
-  Map<Matrix<Scalar,SegSizeAtCompileTime,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > A( &(lusup.data()[luptr]), segsize, segsize, OuterStride<>(lda) );
-  Map<Matrix<Scalar,SegSizeAtCompileTime,1> > u(tempv.data(), segsize);
-  
-  u = A.template triangularView<UnitLower>().solve(u); 
-  
-  // Dense matrix-vector product y <-- B*x 
+  luptr += lda * no_zeros + no_zeros;
+  // Form Eigen matrix and vector
+  Map<Matrix<Scalar, SegSizeAtCompileTime, SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > A(
+      &(lusup.data()[luptr]), segsize, segsize, OuterStride<>(lda));
+  Map<Matrix<Scalar, SegSizeAtCompileTime, 1> > u(tempv.data(), segsize);
+
+  u = A.template triangularView<UnitLower>().solve(u);
+
+  // Dense matrix-vector product y <-- B*x
   luptr += segsize;
   const Index PacketSize = internal::packet_traits<Scalar>::size;
   Index ldl = internal::first_multiple(nrow, PacketSize);
-  Map<Matrix<Scalar,Dynamic,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > B( &(lusup.data()[luptr]), nrow, segsize, OuterStride<>(lda) );
-  Index aligned_offset = internal::first_default_aligned(tempv.data()+segsize, PacketSize);
-  Index aligned_with_B_offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize))%PacketSize;
-  Map<Matrix<Scalar,Dynamic,1>, 0, OuterStride<> > l(tempv.data()+segsize+aligned_offset+aligned_with_B_offset, nrow, OuterStride<>(ldl) );
-  
-  l.setZero();
-  internal::sparselu_gemm<Scalar>(l.rows(), l.cols(), B.cols(), B.data(), B.outerStride(), u.data(), u.outerStride(), l.data(), l.outerStride());
-  
-  // Scatter tempv[] into SPA dense[] as a temporary storage 
+  Map<Matrix<Scalar, Dynamic, SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > B(&(lusup.data()[luptr]), nrow,
+                                                                                    segsize, OuterStride<>(lda));
+  Index aligned_offset = internal::first_default_aligned(tempv.data() + segsize, PacketSize);
+  Index aligned_with_B_offset = (PacketSize - internal::first_default_aligned(B.data(), PacketSize)) % PacketSize;
+  Map<Matrix<Scalar, Dynamic, 1>, 0, OuterStride<> > l(tempv.data() + segsize + aligned_offset + aligned_with_B_offset,
+                                                       nrow, OuterStride<>(ldl));
+
+  l.noalias() = B * u;
+
+  // Scatter tempv[] into SPA dense[] as a temporary storage
   isub = lptr + no_zeros;
-  for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++)
-  {
-    irow = lsub(isub++); 
+  for (i = 0; i < ((SegSizeAtCompileTime == Dynamic) ? segsize : SegSizeAtCompileTime); i++) {
+    irow = lsub(isub++);
     dense(irow) = tempv(i);
   }
-  
+
   // Scatter l into SPA dense[]
-  for (i = 0; i < nrow; i++)
-  {
-    irow = lsub(isub++); 
+  for (i = 0; i < nrow; i++) {
+    irow = lsub(isub++);
     dense(irow) -= l(i);
-  } 
+  }
 }
 
-template <> struct LU_kernel_bmod<1>
-{
+template <>
+struct LU_kernel_bmod<1> {
   template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
-  static EIGEN_DONT_INLINE void run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
-                                    const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros);
+  static EIGEN_DONT_INLINE void run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/,
+                                    ScalarVector& lusup, Index& luptr, const Index lda, const Index nrow,
+                                    IndexVector& lsub, const Index lptr, const Index no_zeros);
 };
 
-
 template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
-EIGEN_DONT_INLINE void LU_kernel_bmod<1>::run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
-                                              const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros)
-{
+EIGEN_DONT_INLINE void LU_kernel_bmod<1>::run(const Index /*segsize*/, BlockScalarVector& dense,
+                                              ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
+                                              const Index lda, const Index nrow, IndexVector& lsub, const Index lptr,
+                                              const Index no_zeros) {
   typedef typename ScalarVector::Scalar Scalar;
   typedef typename IndexVector::Scalar StorageIndex;
   Scalar f = dense(lsub(lptr + no_zeros));
   luptr += lda * no_zeros + no_zeros + 1;
   const Scalar* a(lusup.data() + luptr);
-  const StorageIndex*  irow(lsub.data()+lptr + no_zeros + 1);
+  const StorageIndex* irow(lsub.data() + lptr + no_zeros + 1);
   Index i = 0;
-  for (; i+1 < nrow; i+=2)
-  {
+  for (; i + 1 < nrow; i += 2) {
     Index i0 = *(irow++);
     Index i1 = *(irow++);
     Scalar a0 = *(a++);
     Scalar a1 = *(a++);
     Scalar d0 = dense.coeff(i0);
     Scalar d1 = dense.coeff(i1);
-    d0 -= f*a0;
-    d1 -= f*a1;
+    d0 -= f * a0;
+    d1 -= f * a1;
     dense.coeffRef(i0) = d0;
     dense.coeffRef(i1) = d1;
   }
-  if(i<nrow)
-    dense.coeffRef(*(irow++)) -= f * *(a++);
+  if (i < nrow) dense.coeffRef(*(irow++)) -= f * *(a++);
 }
 
-} // end namespace internal
+}  // end namespace internal
 
-} // end namespace Eigen
-#endif // SPARSELU_KERNEL_BMOD_H
+}  // end namespace Eigen
+#endif  // SPARSELU_KERNEL_BMOD_H