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

#include <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)

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

                                                                                               {
    typedef typename unpacket_traits<typename packet_traits<Scalar>::type>::half HalfPacket;
    typedef typename unpacket_traits<typename unpacket_traits<typename packet_traits<Scalar>::type>::half>::half
        QuarterPacket;
    enum {
      PacketSize = packet_traits<Scalar>::size,
      HalfPacketSize = unpacket_traits<HalfPacket>::size,
      QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
      HasHalf = (int)HalfPacketSize < (int)PacketSize,
      HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize
    };
 
    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 ? peeled_mc2 + ((rows - peeled_mc2) / (1 * PacketSize)) * (1 * PacketSize) : 0;
    const Index peeled_mc_half =
        Pack1 >= HalfPacketSize ? peeled_mc1 + ((rows - peeled_mc1) / (HalfPacketSize)) * (HalfPacketSize) : 0;
    const Index peeled_mc_quarter =
        Pack1 >= QuarterPacketSize
            ? peeled_mc_half + ((rows - peeled_mc_half) / (QuarterPacketSize)) * (QuarterPacketSize)
            : 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);
 
    if (HasHalf && Pack1 >= HalfPacketSize)
      for (Index i = peeled_mc1; i < peeled_mc_half; i += HalfPacketSize)
        pack<HalfPacketSize>(blockA, lhs, cols, i, count);
 
    if (HasQuarter && Pack1 >= QuarterPacketSize)
      for (Index i = peeled_mc_half; i < peeled_mc_quarter; i += QuarterPacketSize)
        pack<QuarterPacketSize>(blockA, lhs, cols, i, count);
 
    // do the same with mr==1
    for (Index i = peeled_mc_quarter; 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
    }
  }

References cols, conj(), i, int(), k, and rows.

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
  }

References cols, conj(), i, k, and w.

---

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

• SelfadjointMatrixMatrix.h