Eigen::internal::LU_kernel_bmod< SegSizeAtCompileTime > Struct Template Reference

#include <src/eigen/Eigen/src/SparseLU/SparseLU_kernel_bmod.h>

Static Public Member Functions
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)

Detailed Description

template<int SegSizeAtCompileTime>
struct Eigen::internal::LU_kernel_bmod< SegSizeAtCompileTime >

Member Function Documentation

run()

template<int SegSizeAtCompileTime>

template<typename BlockScalarVector , typename ScalarVector , typename IndexVector >

EIGEN_DONT_INLINE void Eigen::internal::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  )

static

{
  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; 
  Index i;
  Index irow;
  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 += 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 
  isub = lptr + no_zeros;
  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++); 
    dense(irow) -= l(i);
  } 
}

References Eigen::Dynamic, Eigen::internal::first_default_aligned(), Eigen::internal::first_multiple(), and Eigen::Map< PlainObjectType, MapOptions, StrideType >::outerStride().

Referenced by Eigen::internal::SparseLUImpl< Scalar, StorageIndex >::column_bmod(), and Eigen::internal::SparseLUImpl< Scalar, StorageIndex >::panel_bmod().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this struct was generated from the following file:

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