|| || || || || || || ||

---

TalkNgbPnLoop.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Trait_TalkNgbPnLoop_h
#define Impala_Core_Array_Trait_TalkNgbPnLoop_h

#include "Core/Array/Pattern/Categories.h"
#include "Core/Array/Pattern/Cnum.h"
#include "Core/Array/Element/E1Cast.h"

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Trait
{


template<class DstArrayT, class SrcArrayT>
class TalkNgbPnLoop
{
public:

    typedef Pattern::TagLoop IteratorCategory;

    typedef Pattern::TagNPhase PhaseCategory;

    typedef typename DstArrayT::StorType DstStorType;
    typedef typename DstArrayT::ArithType DstArithType;
    typedef typename SrcArrayT::StorType SrcStorType;
    typedef typename SrcArrayT::ArithType SrcArithType;


    TalkNgbPnLoop(bool verbose, int ngbWidth, int ngbHeight)
    {
        mNgbWidth = ngbWidth;
        mNgbHeight = ngbHeight;
        mFactor = ngbWidth * ngbHeight;
        mVerbose = verbose;
    }

    int
    Width()
    {
        return mNgbWidth;
    }

    int
    Height()
    {
        return mNgbHeight;
    }

    void
    Init(int phase, int x, int y, SrcArithType value)
    {
        if (mVerbose)
            std::cout << "  TalkNgbPnLoop::init(" << phase << ","
                      << x << "," << y << "," << value << ") " << std::endl;
        if (phase == 1)
            mResult = Element::E1Cast(0, DstArithType());
    }

    void
    NextEl(int x, int y, SrcArithType value)
    {
        if (mVerbose)
            std::cout << "      TalkNgbPnLoop::next(" << x << "," << y << ","
                      << value << ") " << std::endl;
        mResult += value;
    }

    void
    Done(int phase)
    {
    }

    bool
    HasNextPhase(int lastPhase)
    {
        if (mVerbose)
            std::cout << "  TalkNgbPnLoop::hasNext(" << lastPhase << ") "
                      << std::endl;
        return (lastPhase < 4);
    }

    DstArithType
    Result() const
    {
        return Element::E1Cast(mResult, DstArithType()) /
               Element::E1Cast(mFactor, DstArithType());
    }

private:
    int          mNgbWidth;
    int          mNgbHeight;
    SrcArithType mResult;
    SrcArithType mFactor;
    bool         mVerbose;
};

} // namespace Trait
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---