Eigen::internal::symm_pack_lhs< Scalar, Index, Pack1, Pack2_dummy, StorageOrder > Struct Template Reference

#include <src/eigen/Eigen/src/Core/products/SelfadjointMatrixMatrix.h>

Public Member Functions
template<int BlockRows>
void	pack (Scalar *blockA, const const_blas_data_mapper< Scalar, Index, StorageOrder > &lhs, Index cols, Index i, Index &count)
void	operator() (Scalar *blockA, const Scalar *_lhs, Index lhsStride, Index cols, Index rows)

Detailed Description

template<typename Scalar, typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
struct Eigen::internal::symm_pack_lhs< Scalar, Index, Pack1, Pack2_dummy, StorageOrder >

Member Function Documentation

operator()()

template<typename Scalar , typename Index , int Pack1, int Pack2_dummy, int StorageOrder>

void Eigen::internal::symm_pack_lhs< Scalar, Index, Pack1, Pack2_dummy, StorageOrder >::operator() ( Scalar *  blockA, const Scalar *  _lhs, Index  lhsStride, Index  cols, Index  rows  )

inline

  {
    enum { PacketSize = packet_traits<Scalar>::size };
    const_blas_data_mapper<Scalar,Index,StorageOrder> lhs(_lhs,lhsStride);
    Index count = 0;
    //Index peeled_mc3 = (rows/Pack1)*Pack1;
    
    const Index peeled_mc3 = Pack1>=3*PacketSize ? (rows/(3*PacketSize))*(3*PacketSize) : 0;
    const Index peeled_mc2 = Pack1>=2*PacketSize ? peeled_mc3+((rows-peeled_mc3)/(2*PacketSize))*(2*PacketSize) : 0;
    const Index peeled_mc1 = Pack1>=1*PacketSize ? (rows/(1*PacketSize))*(1*PacketSize) : 0;
    
    if(Pack1>=3*PacketSize)
      for(Index i=0; i<peeled_mc3; i+=3*PacketSize)
        pack<3*PacketSize>(blockA, lhs, cols, i, count);
    
    if(Pack1>=2*PacketSize)
      for(Index i=peeled_mc3; i<peeled_mc2; i+=2*PacketSize)
        pack<2*PacketSize>(blockA, lhs, cols, i, count);
    
    if(Pack1>=1*PacketSize)
      for(Index i=peeled_mc2; i<peeled_mc1; i+=1*PacketSize)
        pack<1*PacketSize>(blockA, lhs, cols, i, count);
 
    // do the same with mr==1
    for(Index i=peeled_mc1; i<rows; i++)
    {
      for(Index k=0; k<i; k++)
        blockA[count++] = lhs(i, k);                   // normal
 
      blockA[count++] = numext::real(lhs(i, i));       // real (diagonal)
 
      for(Index k=i+1; k<cols; k++)
        blockA[count++] = numext::conj(lhs(k, i));     // transposed
    }
  }

pack()

template<typename Scalar , typename Index , int Pack1, int Pack2_dummy, int StorageOrder>

template<int BlockRows>

void Eigen::internal::symm_pack_lhs< Scalar, Index, Pack1, Pack2_dummy, StorageOrder >::pack ( Scalar *  blockA, const const_blas_data_mapper< Scalar, Index, StorageOrder > &  lhs, Index  cols, Index  i, Index &  count  )

inline

  {
    // normal copy
    for(Index k=0; k<i; k++)
      for(Index w=0; w<BlockRows; w++)
        blockA[count++] = lhs(i+w,k);           // normal
    // symmetric copy
    Index h = 0;
    for(Index k=i; k<i+BlockRows; k++)
    {
      for(Index w=0; w<h; w++)
        blockA[count++] = numext::conj(lhs(k, i+w)); // transposed
 
      blockA[count++] = numext::real(lhs(k,k));   // real (diagonal)
 
      for(Index w=h+1; w<BlockRows; w++)
        blockA[count++] = lhs(i+w, k);          // normal
      ++h;
    }
    // transposed copy
    for(Index k=i+BlockRows; k<cols; k++)
      for(Index w=0; w<BlockRows; w++)
        blockA[count++] = numext::conj(lhs(k, i+w)); // transposed
  }

---

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

• src/eigen/Eigen/src/Core/products/SelfadjointMatrixMatrix.h