Eigen::internal::dhs_pack< Scalar, DataMapper, Packet, StorageOrder, PanelMode, UseLhs > Struct Template Reference

#include <MatrixProduct.h>

Public Member Functions
template<Index n>
EIGEN_ALWAYS_INLINE void	dhs_copy (Scalar *blockA, const DataMapper &lhs2, Index &i, Index &ri, Index depth, const Index vectorSize)
EIGEN_STRONG_INLINE void	operator() (Scalar *blockA, const DataMapper &lhs, Index depth, Index rows, Index stride, Index offset)

Member Function Documentation

dhs_copy()

template<typename Scalar , typename DataMapper , typename Packet , int StorageOrder, bool PanelMode, bool UseLhs>

template<Index n>

EIGEN_ALWAYS_INLINE void Eigen::internal::dhs_pack< Scalar, DataMapper, Packet, StorageOrder, PanelMode, UseLhs >::dhs_copy ( Scalar *  blockA, const DataMapper &  lhs2, Index &  i, Index &  ri, Index  depth, const Index  vectorSize  )

inline

                                                            {
    PacketBlock<Packet, 4> block[n];
 
    for (; i + n * vectorSize <= depth; i += n * vectorSize) {
      for (Index k = 0; k < n; k++) {
        if (UseLhs) {
          bload<DataMapper, Packet, 4, StorageOrder, false, 4>(block[k], lhs2, 0, i + k * vectorSize);
        } else {
          bload<DataMapper, Packet, 4, StorageOrder, false, 4>(block[k], lhs2, i + k * vectorSize, 0);
        }
      }
 
      if (((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs)) {
        for (Index k = 0; k < n; k++) {
          ptranspose(block[k]);
        }
      }
 
      for (Index k = 0; k < n; k++) {
        storeBlock<Scalar, Packet, 4>(blockA + ri + k * 4 * vectorSize, block[k]);
      }
 
      ri += n * 4 * vectorSize;
    }
  }

References block(), Eigen::ColMajor, i, k, n, Eigen::internal::ptranspose(), and Eigen::RowMajor.

operator()()

template<typename Scalar , typename DataMapper , typename Packet , int StorageOrder, bool PanelMode, bool UseLhs>

EIGEN_STRONG_INLINE void Eigen::internal::dhs_pack< Scalar, DataMapper, Packet, StorageOrder, PanelMode, UseLhs >::operator() ( Scalar *  blockA, const DataMapper &  lhs, Index  depth, Index  rows, Index  stride, Index  offset  )

inline

                                                    {
    const Index vectorSize = quad_traits<Scalar>::vectorsize;
    Index ri = 0, j = 0;
 
    for (; j + vectorSize <= rows; j += vectorSize) {
      const DataMapper lhs2 = UseLhs ? lhs.getSubMapper(j, 0) : lhs.getSubMapper(0, j);
      Index i = 0;
 
      if (PanelMode) ri += vectorSize * offset;
 
      dhs_copy<4>(blockA, lhs2, i, ri, depth, vectorSize);
      dhs_copy<2>(blockA, lhs2, i, ri, depth, vectorSize);
      dhs_copy<1>(blockA, lhs2, i, ri, depth, vectorSize);
 
      for (; i < depth; i++) {
        if (((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs)) {
          if (UseLhs) {
            blockA[ri + 0] = lhs2(0, i);
            blockA[ri + 1] = lhs2(1, i);
            blockA[ri + 2] = lhs2(2, i);
            blockA[ri + 3] = lhs2(3, i);
          } else {
            blockA[ri + 0] = lhs2(i, 0);
            blockA[ri + 1] = lhs2(i, 1);
            blockA[ri + 2] = lhs2(i, 2);
            blockA[ri + 3] = lhs2(i, 3);
          }
        } else {
          Packet lhsV;
          if (UseLhs) {
            lhsV = lhs2.template loadPacket<Packet>(0, i);
          } else {
            lhsV = lhs2.template loadPacket<Packet>(i, 0);
          }
          pstore<Scalar>(blockA + ri, lhsV);
        }
 
        ri += vectorSize;
      }
 
      if (PanelMode) ri += vectorSize * (stride - offset - depth);
    }
 
    if (!UseLhs) {
      if (PanelMode) ri += offset;
 
      for (; j < rows; j++) {
        const DataMapper lhs2 = lhs.getSubMapper(0, j);
        for (Index i = 0; i < depth; i++) {
          blockA[ri] = lhs2(i, 0);
          ri += 1;
        }
 
        if (PanelMode) ri += stride - depth;
      }
    } else {
      if (j < rows) {
        if (PanelMode) ri += offset * (rows - j);
 
        for (Index i = 0; i < depth; i++) {
          Index k = j;
          for (; k < rows; k++) {
            blockA[ri] = lhs(k, i);
            ri += 1;
          }
        }
      }
    }
  }

References Eigen::ColMajor, i, j, k, Eigen::RowMajor, and rows.

---

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

• MatrixProduct.h