sequenzo 0.1.18__cp310-cp310-win_amd64.whl → 0.1.19__cp310-cp310-win_amd64.whl

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h

@@ -1,375 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
-// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// 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/.
-
-#ifndef EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
-#define EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
-
-namespace Eigen {
-namespace internal {
-
-/** \ingroup SparseLU_Module
- * \brief a class to manipulate the L supernodal factor from the SparseLU factorization
- * 
- * This class  contain the data to easily store 
- * and manipulate the supernodes during the factorization and solution phase of Sparse LU. 
- * Only the lower triangular matrix has supernodes.
- * 
- * NOTE : This class corresponds to the SCformat structure in SuperLU
- * 
- */
-/* TODO
- * InnerIterator as for sparsematrix 
- * SuperInnerIterator to iterate through all supernodes 
- * Function for triangular solve
- */
-template <typename _Scalar, typename _StorageIndex>
-class MappedSuperNodalMatrix
-{
-  public:
-    typedef _Scalar Scalar; 
-    typedef _StorageIndex StorageIndex;
-    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
-    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
-  public:
-    MappedSuperNodalMatrix()
-    {
-      
-    }
-    MappedSuperNodalMatrix(Index m, Index n,  ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
-             IndexVector& rowind_colptr, IndexVector& col_to_sup, IndexVector& sup_to_col )
-    {
-      setInfos(m, n, nzval, nzval_colptr, rowind, rowind_colptr, col_to_sup, sup_to_col);
-    }
-    
-    ~MappedSuperNodalMatrix()
-    {
-      
-    }
-    /**
-     * Set appropriate pointers for the lower triangular supernodal matrix
-     * These infos are available at the end of the numerical factorization
-     * FIXME This class will be modified such that it can be use in the course 
-     * of the factorization.
-     */
-    void setInfos(Index m, Index n, ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
-             IndexVector& rowind_colptr, IndexVector& col_to_sup, IndexVector& sup_to_col )
-    {
-      m_row = m;
-      m_col = n; 
-      m_nzval = nzval.data(); 
-      m_nzval_colptr = nzval_colptr.data(); 
-      m_rowind = rowind.data(); 
-      m_rowind_colptr = rowind_colptr.data(); 
-      m_nsuper = col_to_sup(n); 
-      m_col_to_sup = col_to_sup.data(); 
-      m_sup_to_col = sup_to_col.data(); 
-    }
-    
-    /**
-     * Number of rows
-     */
-    Index rows() const { return m_row; }
-    
-    /**
-     * Number of columns
-     */
-    Index cols() const { return m_col; }
-    
-    /**
-     * Return the array of nonzero values packed by column
-     * 
-     * The size is nnz
-     */
-    Scalar* valuePtr() {  return m_nzval; }
-    
-    const Scalar* valuePtr() const 
-    {
-      return m_nzval; 
-    }
-    /**
-     * Return the pointers to the beginning of each column in \ref valuePtr()
-     */
-    StorageIndex* colIndexPtr()
-    {
-      return m_nzval_colptr; 
-    }
-    
-    const StorageIndex* colIndexPtr() const
-    {
-      return m_nzval_colptr; 
-    }
-    
-    /**
-     * Return the array of compressed row indices of all supernodes
-     */
-    StorageIndex* rowIndex()  { return m_rowind; }
-    
-    const StorageIndex* rowIndex() const
-    {
-      return m_rowind; 
-    }
-    
-    /**
-     * Return the location in \em rowvaluePtr() which starts each column
-     */
-    StorageIndex* rowIndexPtr() { return m_rowind_colptr; }
-    
-    const StorageIndex* rowIndexPtr() const
-    {
-      return m_rowind_colptr; 
-    }
-    
-    /** 
-     * Return the array of column-to-supernode mapping 
-     */
-    StorageIndex* colToSup()  { return m_col_to_sup; }
-    
-    const StorageIndex* colToSup() const
-    {
-      return m_col_to_sup;       
-    }
-    /**
-     * Return the array of supernode-to-column mapping
-     */
-    StorageIndex* supToCol() { return m_sup_to_col; }
-    
-    const StorageIndex* supToCol() const
-    {
-      return m_sup_to_col;
-    }
-    
-    /**
-     * Return the number of supernodes
-     */
-    Index nsuper() const
-    {
-      return m_nsuper; 
-    }
-    
-    class InnerIterator; 
-    template<typename Dest>
-    void solveInPlace( MatrixBase<Dest>&X) const;
-    template<bool Conjugate, typename Dest>
-    void solveTransposedInPlace( MatrixBase<Dest>&X) const;
-
-    
-      
-      
-    
-  protected:
-    Index m_row; // Number of rows
-    Index m_col; // Number of columns
-    Index m_nsuper; // Number of supernodes
-    Scalar* m_nzval; //array of nonzero values packed by column
-    StorageIndex* m_nzval_colptr; //nzval_colptr[j] Stores the location in nzval[] which starts column j
-    StorageIndex* m_rowind; // Array of compressed row indices of rectangular supernodes
-    StorageIndex* m_rowind_colptr; //rowind_colptr[j] stores the location in rowind[] which starts column j
-    StorageIndex* m_col_to_sup; // col_to_sup[j] is the supernode number to which column j belongs
-    StorageIndex* m_sup_to_col; //sup_to_col[s] points to the starting column of the s-th supernode
-    
-  private :
-};
-
-/**
-  * \brief InnerIterator class to iterate over nonzero values of the current column in the supernodal matrix L
-  * 
-  */
-template<typename Scalar, typename StorageIndex>
-class MappedSuperNodalMatrix<Scalar,StorageIndex>::InnerIterator
-{
-  public:
-     InnerIterator(const MappedSuperNodalMatrix& mat, Index outer)
-      : m_matrix(mat),
-        m_outer(outer),
-        m_supno(mat.colToSup()[outer]),
-        m_idval(mat.colIndexPtr()[outer]),
-        m_startidval(m_idval),
-        m_endidval(mat.colIndexPtr()[outer+1]),
-        m_idrow(mat.rowIndexPtr()[mat.supToCol()[mat.colToSup()[outer]]]),
-        m_endidrow(mat.rowIndexPtr()[mat.supToCol()[mat.colToSup()[outer]]+1])
-    {}
-    inline InnerIterator& operator++()
-    { 
-      m_idval++; 
-      m_idrow++;
-      return *this;
-    }
-    inline Scalar value() const { return m_matrix.valuePtr()[m_idval]; }
-    
-    inline Scalar& valueRef() { return const_cast<Scalar&>(m_matrix.valuePtr()[m_idval]); }
-    
-    inline Index index() const { return m_matrix.rowIndex()[m_idrow]; }
-    inline Index row() const { return index(); }
-    inline Index col() const { return m_outer; }
-    
-    inline Index supIndex() const { return m_supno; }
-    
-    inline operator bool() const 
-    { 
-      return ( (m_idval < m_endidval) && (m_idval >= m_startidval)
-                && (m_idrow < m_endidrow) );
-    }
-    
-  protected:
-    const MappedSuperNodalMatrix& m_matrix; // Supernodal lower triangular matrix 
-    const Index m_outer;                    // Current column 
-    const Index m_supno;                    // Current SuperNode number
-    Index m_idval;                          // Index to browse the values in the current column
-    const Index m_startidval;               // Start of the column value
-    const Index m_endidval;                 // End of the column value
-    Index m_idrow;                          // Index to browse the row indices 
-    Index m_endidrow;                       // End index of row indices of the current column
-};
-
-/**
- * \brief Solve with the supernode triangular matrix
- * 
- */
-template<typename Scalar, typename Index_>
-template<typename Dest>
-void MappedSuperNodalMatrix<Scalar,Index_>::solveInPlace( MatrixBase<Dest>&X) const
-{
-    /* Explicit type conversion as the Index type of MatrixBase<Dest> may be wider than Index */
-//    eigen_assert(X.rows() <= NumTraits<Index>::highest());
-//    eigen_assert(X.cols() <= NumTraits<Index>::highest());
-    Index n    = int(X.rows());
-    Index nrhs = Index(X.cols());
-    const Scalar * Lval = valuePtr();                 // Nonzero values 
-    Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);     // working vector
-    work.setZero();
-    for (Index k = 0; k <= nsuper(); k ++)
-    {
-      Index fsupc = supToCol()[k];                    // First column of the current supernode 
-      Index istart = rowIndexPtr()[fsupc];            // Pointer index to the subscript of the current column
-      Index nsupr = rowIndexPtr()[fsupc+1] - istart;  // Number of rows in the current supernode
-      Index nsupc = supToCol()[k+1] - fsupc;          // Number of columns in the current supernode
-      Index nrow = nsupr - nsupc;                     // Number of rows in the non-diagonal part of the supernode
-      Index irow;                                     //Current index row
-      
-      if (nsupc == 1 )
-      {
-        for (Index j = 0; j < nrhs; j++)
-        {
-          InnerIterator it(*this, fsupc);
-          ++it; // Skip the diagonal element
-          for (; it; ++it)
-          {
-            irow = it.row();
-            X(irow, j) -= X(fsupc, j) * it.value();
-          }
-        }
-      }
-      else
-      {
-        // The supernode has more than one column 
-        Index luptr = colIndexPtr()[fsupc]; 
-        Index lda = colIndexPtr()[fsupc+1] - luptr;
-        
-        // Triangular solve 
-        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(Lval[luptr]), nsupc, nsupc, OuterStride<>(lda) );
-        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
-        U = A.template triangularView<UnitLower>().solve(U); 
-        
-        // Matrix-vector product 
-        new (&A) Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > ( &(Lval[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
-        work.topRows(nrow).noalias() = A * U;
-        
-        //Begin Scatter 
-        for (Index j = 0; j < nrhs; j++)
-        {
-          Index iptr = istart + nsupc; 
-          for (Index i = 0; i < nrow; i++)
-          {
-            irow = rowIndex()[iptr]; 
-            X(irow, j) -= work(i, j); // Scatter operation
-            work(i, j) = Scalar(0); 
-            iptr++;
-          }
-        }
-      }
-    } 
-}
-
-template<typename Scalar, typename Index_>
-template<bool Conjugate, typename Dest>
-void MappedSuperNodalMatrix<Scalar,Index_>::solveTransposedInPlace( MatrixBase<Dest>&X) const
-{
-    using numext::conj;
-  Index n    = int(X.rows());
-  Index nrhs = Index(X.cols());
-  const Scalar * Lval = valuePtr();                 // Nonzero values
-  Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);     // working vector
-  work.setZero();
-  for (Index k = nsuper(); k >= 0; k--)
-  {
-    Index fsupc = supToCol()[k];                    // First column of the current supernode
-    Index istart = rowIndexPtr()[fsupc];            // Pointer index to the subscript of the current column
-    Index nsupr = rowIndexPtr()[fsupc+1] - istart;  // Number of rows in the current supernode
-    Index nsupc = supToCol()[k+1] - fsupc;          // Number of columns in the current supernode
-    Index nrow = nsupr - nsupc;                     // Number of rows in the non-diagonal part of the supernode
-    Index irow;                                     //Current index row
-
-    if (nsupc == 1 )
-    {
-      for (Index j = 0; j < nrhs; j++)
-      {
-        InnerIterator it(*this, fsupc);
-        ++it; // Skip the diagonal element
-        for (; it; ++it)
-        {
-          irow = it.row();
-          X(fsupc,j) -= X(irow, j) * (Conjugate?conj(it.value()):it.value());
-        }
-      }
-    }
-    else
-    {
-      // The supernode has more than one column
-      Index luptr = colIndexPtr()[fsupc];
-      Index lda = colIndexPtr()[fsupc+1] - luptr;
-
-      //Begin Gather
-      for (Index j = 0; j < nrhs; j++)
-      {
-        Index iptr = istart + nsupc;
-        for (Index i = 0; i < nrow; i++)
-        {
-          irow = rowIndex()[iptr];
-          work.topRows(nrow)(i,j)= X(irow,j); // Gather operation
-          iptr++;
-        }
-      }
-
-      // Matrix-vector product with transposed submatrix
-      Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(Lval[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
-      Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
-      if(Conjugate)
-        U = U - A.adjoint() * work.topRows(nrow);
-      else
-        U = U - A.transpose() * work.topRows(nrow);
-
-      // Triangular solve (of transposed diagonal block)
-      new (&A) Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > ( &(Lval[luptr]), nsupc, nsupc, OuterStride<>(lda) );
-      if(Conjugate)
-        U = A.adjoint().template triangularView<UnitUpper>().solve(U);
-      else
-        U = A.transpose().template triangularView<UnitUpper>().solve(U);
-
-    }
-
-  }
-}
-
-
-} // end namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSELU_MATRIX_H

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/SparseLU/SparseLU_Utils.h

@@ -1,80 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
-//
-// 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/.
-
-
-#ifndef EIGEN_SPARSELU_UTILS_H
-#define EIGEN_SPARSELU_UTILS_H
-
-namespace Eigen {
-namespace internal {
-
-/**
- * \brief Count Nonzero elements in the factors
- */
-template <typename Scalar, typename StorageIndex>
-void SparseLUImpl<Scalar,StorageIndex>::countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu)
-{
- nnzL = 0; 
- nnzU = (glu.xusub)(n); 
- Index nsuper = (glu.supno)(n); 
- Index jlen; 
- Index i, j, fsupc;
- if (n <= 0 ) return; 
- // For each supernode
- for (i = 0; i <= nsuper; i++)
- {
-   fsupc = glu.xsup(i); 
-   jlen = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
-   
-   for (j = fsupc; j < glu.xsup(i+1); j++)
-   {
-     nnzL += jlen; 
-     nnzU += j - fsupc + 1; 
-     jlen--; 
-   }
- }
-}
-
-/**
- * \brief Fix up the data storage lsub for L-subscripts. 
- * 
- * It removes the subscripts sets for structural pruning, 
- * and applies permutation to the remaining subscripts
- * 
- */
-template <typename Scalar, typename StorageIndex>
-void SparseLUImpl<Scalar,StorageIndex>::fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu)
-{
-  Index fsupc, i, j, k, jstart; 
-  
-  StorageIndex nextl = 0; 
-  Index nsuper = (glu.supno)(n); 
-  
-  // For each supernode 
-  for (i = 0; i <= nsuper; i++)
-  {
-    fsupc = glu.xsup(i); 
-    jstart = glu.xlsub(fsupc); 
-    glu.xlsub(fsupc) = nextl; 
-    for (j = jstart; j < glu.xlsub(fsupc + 1); j++)
-    {
-      glu.lsub(nextl) = perm_r(glu.lsub(j)); // Now indexed into P*A
-      nextl++;
-    }
-    for (k = fsupc+1; k < glu.xsup(i+1); k++)
-      glu.xlsub(k) = nextl; // other columns in supernode i
-  }
-  
-  glu.xlsub(n) = nextl; 
-}
-
-} // end namespace internal
-
-} // end namespace Eigen
-#endif // EIGEN_SPARSELU_UTILS_H

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/SparseLU/SparseLU_column_bmod.h

@@ -1,181 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
-// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// 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 xcolumn_bmod.c file in SuperLU 
- 
- * -- SuperLU routine (version 3.0) --
- * Univ. of California Berkeley, Xerox Palo Alto Research Center,
- * and Lawrence Berkeley National Lab.
- * October 15, 2003
- *
- * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
- *
- * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
- * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
- *
- * Permission is hereby granted to use or copy this program for any
- * purpose, provided the above notices are retained on all copies.
- * Permission to modify the code and to distribute modified code is
- * granted, provided the above notices are retained, and a notice that
- * the code was modified is included with the above copyright notice.
- */
-#ifndef SPARSELU_COLUMN_BMOD_H
-#define SPARSELU_COLUMN_BMOD_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 dense Store the full representation of the column
- * \param tempv working array 
- * \param segrep segment representative ...
- * \param repfnz ??? First nonzero column in each row ???  ...
- * \param fpanelc First column in the current panel
- * \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>::column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv,
-                                                     BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu)
-{
-  Index  jsupno, k, ksub, krep, ksupno; 
-  Index lptr, nrow, isub, irow, nextlu, new_next, ufirst; 
-  Index fsupc, nsupc, nsupr, luptr, kfnz, no_zeros; 
-  /* krep = representative of current k-th supernode
-    * fsupc =  first supernodal column
-    * nsupc = number of columns in a supernode
-    * nsupr = number of rows in a supernode
-    * luptr = location of supernodal LU-block in storage
-    * kfnz = first nonz in the k-th supernodal segment
-    * no_zeros = no lf leading zeros in a supernodal U-segment
-    */
-  
-  jsupno = glu.supno(jcol);
-  // For each nonzero supernode segment of U[*,j] in topological order 
-  k = nseg - 1; 
-  Index d_fsupc; // distance between the first column of the current panel and the 
-               // first column of the current snode
-  Index fst_col; // First column within small LU update
-  Index segsize; 
-  for (ksub = 0; ksub < nseg; ksub++)
-  {
-    krep = segrep(k); k--; 
-    ksupno = glu.supno(krep); 
-    if (jsupno != ksupno )
-    {
-      // outside the rectangular supernode 
-      fsupc = glu.xsup(ksupno); 
-      fst_col = (std::max)(fsupc, fpanelc); 
-      
-      // Distance from the current supernode to the current panel; 
-      // d_fsupc = 0 if fsupc > fpanelc
-      d_fsupc = fst_col - fsupc; 
-      
-      luptr = glu.xlusup(fst_col) + d_fsupc; 
-      lptr = glu.xlsub(fsupc) + d_fsupc; 
-      
-      kfnz = repfnz(krep); 
-      kfnz = (std::max)(kfnz, fpanelc); 
-      
-      segsize = krep - kfnz + 1; 
-      nsupc = krep - fst_col + 1; 
-      nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
-      nrow = nsupr - d_fsupc - nsupc;
-      Index lda = glu.xlusup(fst_col+1) - glu.xlusup(fst_col);
-      
-      
-      // Perform a triangular solver and block update, 
-      // then scatter the result of sup-col update to dense
-      no_zeros = kfnz - fst_col; 
-      if(segsize==1)
-        LU_kernel_bmod<1>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
-      else
-        LU_kernel_bmod<Dynamic>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
-    } // end if jsupno 
-  } // end for each segment
-  
-  // Process the supernodal portion of  L\U[*,j]
-  nextlu = glu.xlusup(jcol); 
-  fsupc = glu.xsup(jsupno);
-  
-  // copy the SPA dense into L\U[*,j]
-  Index mem; 
-  new_next = nextlu + glu.xlsub(fsupc + 1) - glu.xlsub(fsupc); 
-  Index offset = internal::first_multiple<Index>(new_next, internal::packet_traits<Scalar>::size) - new_next;
-  if(offset)
-    new_next += offset;
-  while (new_next > glu.nzlumax )
-  {
-    mem = memXpand<ScalarVector>(glu.lusup, glu.nzlumax, nextlu, LUSUP, glu.num_expansions);  
-    if (mem) return mem; 
-  }
-  
-  for (isub = glu.xlsub(fsupc); isub < glu.xlsub(fsupc+1); isub++)
-  {
-    irow = glu.lsub(isub);
-    glu.lusup(nextlu) = dense(irow);
-    dense(irow) = Scalar(0.0); 
-    ++nextlu; 
-  }
-  
-  if(offset)
-  {
-    glu.lusup.segment(nextlu,offset).setZero();
-    nextlu += offset;
-  }
-  glu.xlusup(jcol + 1) = StorageIndex(nextlu);  // close L\U(*,jcol); 
-  
-  /* For more updates within the panel (also within the current supernode),
-   * should start from the first column of the panel, or the first column
-   * of the supernode, whichever is bigger. There are two cases:
-   *  1) fsupc < fpanelc, then fst_col <-- fpanelc
-   *  2) fsupc >= fpanelc, then fst_col <-- fsupc
-   */
-  fst_col = (std::max)(fsupc, fpanelc); 
-  
-  if (fst_col  < jcol)
-  {
-    // Distance between the current supernode and the current panel
-    // d_fsupc = 0 if fsupc >= fpanelc
-    d_fsupc = fst_col - fsupc; 
-    
-    lptr = glu.xlsub(fsupc) + d_fsupc; 
-    luptr = glu.xlusup(fst_col) + d_fsupc; 
-    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); // leading dimension
-    nsupc = jcol - fst_col; // excluding jcol 
-    nrow = nsupr - d_fsupc - nsupc; 
-    
-    // points to the beginning of jcol in snode L\U(jsupno) 
-    ufirst = glu.xlusup(jcol) + d_fsupc; 
-    Index lda = glu.xlusup(jcol+1) - glu.xlusup(jcol);
-    MappedMatrixBlock A( &(glu.lusup.data()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
-    VectorBlock<ScalarVector> u(glu.lusup, ufirst, nsupc); 
-    u = A.template triangularView<UnitLower>().solve(u); 
-    
-    new (&A) MappedMatrixBlock ( &(glu.lusup.data()[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
-    VectorBlock<ScalarVector> l(glu.lusup, ufirst+nsupc, nrow); 
-    l.noalias() -= A * u;
-    
-  } // End if fst_col
-  return 0; 
-}
-
-} // end namespace internal
-} // end namespace Eigen
-
-#endif // SPARSELU_COLUMN_BMOD_H