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

---

TalkBpoAssign.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Trait_TalkBpoAssign_h
#define Impala_Core_Array_Trait_TalkBpoAssign_h

#include "Core/Array/Pattern/Categories.h"

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


template<class DstArrayT, class SrcArrayT>
struct TalkBpoAssignPtrE1
{
    typedef Pattern::TagTransInVar TransVarianceCategory;

    typedef Pattern::TagCallPointer CallCategory;

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

    TalkBpoAssignPtrE1(bool verbose, bool doMin, int nrToGroup)
    {
        mVerbose = verbose;
        mDoMin = doMin;
        mNrToGroup = nrToGroup;
        mCurNr = 1;
    }

    void
    setNeutral(DstStorType* dPtr)
    {
        *dPtr = 0;
    }

    void
    DoIt(DstStorType* dPtr, SrcStorType* sPtr)
    {
        DstStorType res;
        res = (mDoMin) ? Min(*dPtr, *sPtr) : *dPtr + *sPtr;
        if (mVerbose)
        {
            std::cout << "             TalkBpoAssign::doIt("
                      << *dPtr << "," << *sPtr << ") = " << res << std::endl;
        }
        if (mVerbose && (mCurNr++ >= mNrToGroup))
        {
            mCurNr = 1;
            std::cout << std::endl;
        }
        *dPtr = res;
        /*
        if (mDoMin)
            x.minAssign(y);
        else
            x += y;
        */
    }

    static DstStorType
    NeutralElement()
    {
        return 0;
    }

private:
    bool       mVerbose;
    bool       mDoMin;
    static int mNrToGroup;
    static int mCurNr;
};

template <class DstStorT, class SrcStorT>
int TalkBpoAssignPtrE1<DstStorT,SrcStorT>::mNrToGroup;
template <class DstStorT, class SrcStorT>
int TalkBpoAssignPtrE1<DstStorT,SrcStorT>::mCurNr;


template<class DstArrayT, class SrcArrayT>
struct TalkBpoAssignPtrEn
{
    typedef Pattern::TagTransInVar TransVarianceCategory;

    typedef Pattern::TagCallPointer CallCategory;

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

    TalkBpoAssignPtrEn(bool verbose, bool doMin, int nrToGroup)
    {
        mVerbose = verbose;
        mDoMin = doMin;
        mNrToGroup = nrToGroup;
        mCurNr = 1;
    }

    void
    setNeutral(DstStorType* dPtr)
    {
        Pattern::PtrWrite(dPtr, Element::E1Cast(0, DstArithType()));
    }

    void
    DoIt(DstStorType* dPtr, SrcStorType* sPtr)
    {
        DstArithType x(Pattern::PtrRead(dPtr, DstArithType()));
        SrcArithType y(Pattern::PtrRead(sPtr, SrcArithType()));
        DstArithType res;
        res = (mDoMin) ? Min(x, y) : x + y;
        if (mVerbose)
        {
            std::cout << "             TalkBpoAssign::doIt("
                      << x << "," << y << ") = " << res << std::endl;
        }
        if (mVerbose && (mCurNr++ >= mNrToGroup))
        {
            mCurNr = 1;
            std::cout << std::endl;
        }
        Pattern::PtrWrite(dPtr, res);
        /*
        if (mDoMin)
            x.minAssign(y);
        else
            x += y;
        */
    }

    static DstArithType
    NeutralElement()
    {
        return 0;
    }

private:
    bool       mVerbose;
    bool       mDoMin;
    static int mNrToGroup;
    static int mCurNr;
};

template <class DstStorT, class SrcStorT>
int TalkBpoAssignPtrEn<DstStorT,SrcStorT>::mNrToGroup;
template <class DstStorT, class SrcStorT>
int TalkBpoAssignPtrEn<DstStorT,SrcStorT>::mCurNr;


template<class DstArrayT, class SrcArrayT>
struct TalkBpoAssignVal
{
    typedef Pattern::TagTransInVar TransVarianceCategory;

    typedef Pattern::TagCallValue CallCategory;

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

    TalkBpoAssignVal(bool verbose, bool doMin, int nrToGroup)
    {
        mVerbose = verbose;
        mDoMin = doMin;
        mNrToGroup = nrToGroup;
        mCurNr = 1;
    }

    void
    DoIt(DstArithType& x, const SrcArithType& y)
    {
        DstArithType res;
        res = (mDoMin) ? Min(x, y) : x + y;
        if (mVerbose)
        {
            std::cout << "             TalkBpoAssign::doIt("
                      << x << "," << y << ") = " << res << std::endl;
        }
        if (mVerbose && (mCurNr++ >= mNrToGroup))
        {
            mCurNr = 1;
            std::cout << std::endl;
        }
        x = res;
        /*
        if (mDoMin)
            x.minAssign(y);
        else
            x += y;
        */
    }

    static DstArithType
    NeutralElement()
    {
        return Element::E1Cast(0, DstArithType());
    }

private:
    bool       mVerbose;
    bool       mDoMin;
    static int mNrToGroup;
    static int mCurNr;
};

template <class DstStorT, class SrcStorT>
int TalkBpoAssignVal<DstStorT,SrcStorT>::mNrToGroup;
template <class DstStorT, class SrcStorT>
int TalkBpoAssignVal<DstStorT,SrcStorT>::mCurNr;

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

#endif

---