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

Methods to use for C=AB with A divided in blocks and B divided in panels. 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	multBlockByPanel (SubLhs const &lhs, SubRhs const &rhs, Result &res)
	matrix product between a lhs block and a rhs panel
template<class SubLhs , class SubRhs >
static void	multBlockPartByPanel (SubLhs const &lhs, SubRhs const &rhs, Result &res)
	matrix product between a lhs block and a rhs panel

Detailed Description

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

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

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

See also

BlockByPanel

Definition at line 349 of file STK_ArrayByArrayProduct.h.

Member Typedef Documentation

Cmult

template<typename Lhs , typename Rhs , typename Result >

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

Definition at line 352 of file STK_ArrayByArrayProduct.h.

MultCoeff

template<typename Lhs , typename Rhs , typename Result >

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

Definition at line 353 of file STK_ArrayByArrayProduct.h.

Type

template<typename Lhs , typename Rhs , typename Result >

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

Definition at line 351 of file STK_ArrayByArrayProduct.h.

Member Function Documentation

multBlockByPanel()

template<typename Lhs , typename Rhs , typename Result >

template<class SubLhs , class SubRhs >

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

inlinestatic

matrix product between a lhs block and a rhs panel

Definition at line 419 of file STK_ArrayByArrayProduct.h.

  {
    const int k= rhs.beginRows();
    for (int j=rhs.beginCols(); j<rhs.endCols(); ++j)
    {
      int i = lhs.beginRows();
      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);
      ++i;
      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);
      ++i;
      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);
      ++i;
      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::BlockPanelProduct< Lhs, Rhs, Result >::run().

multBlockPartByPanel()

template<typename Lhs , typename Rhs , typename Result >

template<class SubLhs , class SubRhs >

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

inlinestatic

matrix product between a lhs block and a rhs panel

Definition at line 440 of file STK_ArrayByArrayProduct.h.

  {
    const int k= rhs.beginRows();
    for (int j=rhs.beginCols(); j<rhs.endCols(); ++j)
      for(int i=lhs.beginRows(); i<lhs.endRows(); ++i)
        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::BlockPanelProduct< Lhs, Rhs, Result >::run().

run()

template<typename Lhs , typename Rhs , typename Result >

static void STK::hidden::BlockPanelProduct< 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 358 of file STK_ArrayByArrayProduct.h.

  {
#ifdef STK_DEBUG
     stk_cout << _T("Entering BlockPanelProduct::run()\n");
#endif
    // compute number of loops
    int nbInnerLoop = lhs.sizeCols()/blockSize_;
    int nbBlocks    = lhs.sizeRows()/blockSize_;
    int nbPanels    = rhs.sizeCols()/panelSize_;
 
    // remaining sizes in the matrices
    int bSize = lhs.sizeRows() - blockSize_ * nbBlocks;
    int pSize = rhs.sizeCols() - panelSize_ * nbPanels;
    int tSize = lhs.sizeCols() - blockSize_ * nbInnerLoop;
 
    // remaining positions in the matrices
    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 i = 0; i<nbBlocks; ++i)
      {
        TRange<blockSize_> rowRange(lhs.beginRows() + i * blockSize_, blockSize_);
        for (int j = 0; j<nbPanels; ++j)
        {
          TRange<panelSize_> colRange(rhs.beginCols() + j * panelSize_, panelSize_);
          multBlockByPanel( lhs.sub(rowRange, innerRange), rhs.sub(innerRange, colRange), res);
        }
        // remaining incomplete panels
        Range colRange(rhs.beginCols() + nbPanels * panelSize_, pSize);
        multBlockByPanel( lhs.sub(rowRange, innerRange), rhs.sub(innerRange, colRange), res);
      }
      Range rowRange(lhs.beginRows() + nbBlocks * blockSize_, bSize);
#ifdef _OPENMP
#pragma omp parallel for
#endif
      for (int j = 0; j<nbPanels; ++j)
      {
        TRange<panelSize_> colRange(res.beginCols() + j * panelSize_, panelSize_);
        multBlockPartByPanel( lhs.sub(rowRange, innerRange), rhs.sub(innerRange, colRange), res);
      }
      // remaining incomplete panels
      Range colRange(res.beginCols() + nbPanels * panelSize_, pSize);
      multBlockPartByPanel( lhs.sub(rowRange, innerRange), rhs.sub(innerRange, colRange), res);
    } // InnerLoop
    // treat the remaining rows/columns not in outer loop k
    switch (tSize)
    {
      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::BlockPanelProduct< Lhs, Rhs, Result >::multBlockByPanel(), STK::hidden::BlockPanelProduct< Lhs, Rhs, Result >::multBlockPartByPanel(), STK::panelSize_, and stk_cout.

---

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

• STK_ArrayByArrayProduct.h