STK::hidden::PanelBlockProduct< Lhs, Rhs, Result > Struct Template Reference

Methods to use for C=AB with A divided in panels and B divided in blocks. More...

#include <STK_ArrayByArrayProduct.h>

Public Types
typedef Result::Type	Type
typedef hidden::MultImpl< Type >	Cmult
typedef hidden::MultCoefImpl< Lhs, Rhs, Result >	MultCoeff

Static Public Member Functions
static void	run (Lhs const &lhs, Rhs const &rhs, Result &res)
	Main method for Matrices multiplication implementation.
template<class SubLhs , class SubRhs >
static void	multPanelByBlock (SubLhs const &lhs, SubRhs const &rhs, Result &res)
	Default dimension.
template<class SubLhs , class SubRhs >
static void	multPanelByBlockPart (SubLhs const &lhs, SubRhs const &rhs, Result &res)
	Default dimension.

Detailed Description

template<typename Lhs, typename Rhs, typename Result>
struct STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >

Methods to use for C=AB with A divided in panels and B divided in blocks.

The structure PanelBlockProduct contains only static methods and typedef and should normally not be used directly.

See also

PanelByBlock

Definition at line 458 of file STK_ArrayByArrayProduct.h.

Member Typedef Documentation

Cmult

template<typename Lhs , typename Rhs , typename Result >

typedef hidden::MultImpl<Type> STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::Cmult

Definition at line 461 of file STK_ArrayByArrayProduct.h.

MultCoeff

template<typename Lhs , typename Rhs , typename Result >

typedef hidden::MultCoefImpl<Lhs, Rhs, Result> STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::MultCoeff

Definition at line 462 of file STK_ArrayByArrayProduct.h.

Type

template<typename Lhs , typename Rhs , typename Result >

typedef Result::Type STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::Type

Definition at line 460 of file STK_ArrayByArrayProduct.h.

Member Function Documentation

multPanelByBlock()

template<typename Lhs , typename Rhs , typename Result >

template<class SubLhs , class SubRhs >

static void STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::multPanelByBlock ( SubLhs const &  lhs, SubRhs const &  rhs, Result &  res  )

inlinestatic

Default dimension.

Definition at line 529 of file STK_ArrayByArrayProduct.h.

  {
    int const k= lhs.beginCols();
    for (int i=lhs.beginRows(); i<lhs.endRows(); ++i)
    {
      int j = rhs.beginCols();
      res.elt(i,j) += lhs(i, k  ) * rhs(k  , j) + lhs(i, k+1) * rhs(k+1, j)
                    + lhs(i, k+2) * rhs(k+2, j) + lhs(i, k+3) * rhs(k+3, j);
      ++j;
      res.elt(i,j) += lhs(i, k  ) * rhs(k  , j) + lhs(i, k+1) * rhs(k+1, j)
                    + lhs(i, k+2) * rhs(k+2, j) + lhs(i, k+3) * rhs(k+3, j);
      ++j;
      res.elt(i,j) += lhs(i, k  ) * rhs(k  , j) + lhs(i, k+1) * rhs(k+1, j)
                    + lhs(i, k+2) * rhs(k+2, j) + lhs(i, k+3) * rhs(k+3, j);
      ++j;
      res.elt(i,j) += lhs(i, k  ) * rhs(k  , j) + lhs(i, k+1) * rhs(k+1, j)
                    + lhs(i, k+2) * rhs(k+2, j) + lhs(i, k+3) * rhs(k+3, j);
    }
  }

Referenced by STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::run().

multPanelByBlockPart()

template<typename Lhs , typename Rhs , typename Result >

template<class SubLhs , class SubRhs >

static void STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::multPanelByBlockPart ( SubLhs const &  lhs, SubRhs const &  rhs, Result &  res  )

inlinestatic

Default dimension.

Definition at line 550 of file STK_ArrayByArrayProduct.h.

  {
    const int k= lhs.beginCols();
    for (int i=lhs.beginRows(); i<lhs.endRows(); ++i)
      for (int j=rhs.beginCols(); j<rhs.endCols(); ++j)
        res.elt(i,j) += lhs(i, k  ) * rhs(k  , j) + lhs(i, k+1) * rhs(k+1, j)
                      + lhs(i, k+2) * rhs(k+2, j) + lhs(i, k+3) * rhs(k+3, j);
  }

Referenced by STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::run().

run()

template<typename Lhs , typename Rhs , typename Result >

static void STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::run ( Lhs const &  lhs, Rhs const &  rhs, Result &  res  )

inlinestatic

Main method for Matrices multiplication implementation.

Note

res have been resized and initialized to zero outside this method.

Definition at line 467 of file STK_ArrayByArrayProduct.h.

  {
#ifdef STK_ARRAYS_DEBUG
     stk_cout << _T("Entering PanelBlockProduct::run()\n");
#endif
    // compute dimensions
    int nbInnerLoop = lhs.sizeCols()/blockSize_; // = rhs.sizeRows()/blockSize_;
    int nbBlocks    = rhs.sizeCols()/blockSize_;
    int nbPanels    = lhs.sizeRows()/panelSize_;
 
    // remaining sizes in the matrices
    int bSize = rhs.sizeCols() - blockSize_ * nbBlocks;
    int pSize = lhs.sizeRows() - panelSize_ * nbPanels;
    int tSize = lhs.sizeCols() - blockSize_ * nbInnerLoop;
 
    // index of the remaining positions
    int kLastPos = lhs.beginCols() + blockSize_ * nbInnerLoop;
 
    // start blocks by panel
    for (int k = 0; k<nbInnerLoop; ++k)
    {
      TRange<blockSize_> innerRange(lhs.beginCols() + k * blockSize_, blockSize_);
#ifdef _OPENMP
#pragma omp parallel for
#endif
      for (int j = 0; j<nbBlocks; ++j)
      {
        TRange<blockSize_> colRange(rhs.beginCols() + j * blockSize_, blockSize_);
        for (int i = 0; i<nbPanels; ++i)
        {
          TRange<panelSize_> rowRange(lhs.beginRows() + i * panelSize_, panelSize_);
          multPanelByBlock( lhs.sub(rowRange, innerRange), rhs.sub(innerRange, colRange), res);
        }
        // remaining incomplete
        Range rowRange(lhs.beginRows() + nbPanels * panelSize_, pSize);
        multPanelByBlock( lhs.sub(rowRange, innerRange), rhs.sub(innerRange, colRange), res);
      }
      Range colRange(rhs.beginCols() + nbBlocks * blockSize_, bSize);
#ifdef _OPENMP
#pragma omp parallel for
#endif
      for (int i = 0; i<nbPanels; ++i)
      {
        TRange<panelSize_> rowRange(lhs.beginRows() + i * panelSize_, panelSize_);
        multPanelByBlockPart( lhs.sub(rowRange, innerRange), rhs.sub(innerRange, colRange), res);
      }
      // remaining incomplete panels
      Range rowRange(lhs.beginRows() + nbPanels * panelSize_, pSize);
      multPanelByBlockPart( lhs.sub(rowRange, innerRange), rhs.sub(innerRange, colRange), res);
    } // InnerLoop
    // treat the remaining rows/columns not in outer loop k
    switch (tSize)
    {
      case 0: break;
      case 1: MultCoeff::mult1Outer(lhs, rhs, res, kLastPos); break;
      case 2: MultCoeff::mult2Outer(lhs, rhs, res, kLastPos); break;
      case 3: MultCoeff::mult3Outer(lhs, rhs, res, kLastPos); break;
      default:break;
    }
  }

References _T, STK::blockSize_, STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mult1Outer(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mult2Outer(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mult3Outer(), STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::multPanelByBlock(), STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::multPanelByBlockPart(), STK::panelSize_, and stk_cout.

---

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

• STK_ArrayByArrayProduct.h