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

---

FuncUpo.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncUpo_h
#define Impala_Core_Array_Pattern_FuncUpo_h

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

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Pattern
{


template <class DstArrayT, class SrcArrayT, class UpoT>
void
FuncUpo(DstArrayT* dst, SrcArrayT* src, UpoT& upo,
        TagTransInVar dummy, TagCallValue dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    int width = ArrayCW(dst);
    int height = ArrayCH(dst);
    for (int y=0 ; y<height ; y++)
    {
        SrcStorT* sPtr = ArrayCPB(src, 0, y);
        DstStorT* dPtr = ArrayCPB(dst, 0, y);
        for (int x=0 ; x<width ; x++)
        {
            PtrWrite(dPtr, upo.DoIt(PtrRead(sPtr, SrcArithT())));
            dPtr += DstArrayT::ElemSize();
            sPtr += SrcArrayT::ElemSize();
        }
    }
}

template <class DstArrayT, class SrcArrayT, class UpoT>
void
FuncUpo(DstArrayT* dst, SrcArrayT* src, UpoT& upo,
        TagTransInVar dummy, TagCallPointer dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    int width = ArrayCW(dst);
    int height = ArrayCH(dst);
    for (int y=0 ; y<height ; y++)
    {
        SrcStorT* sPtr = ArrayCPB(src, 0, y);
        DstStorT* dPtr = ArrayCPB(dst, 0, y);
        for (int x=0 ; x<width ; x++)
        {
            upo.DoIt(dPtr, sPtr);
            dPtr += DstArrayT::ElemSize();
            sPtr += SrcArrayT::ElemSize();
        }
    }
}

/****************************************
 * test case for Coordination Eumerator *
 ****************************************/

/*
#include "Ops/Array/Trait/CoordinateEnumerators.h"

template <class DstArrayT, class SrcArrayT, class UpoT, class CE>
void
FuncUpoCE(DstArrayT* dst, SrcArrayT* src, UpoT& upo, CE& ce,
          TagTransInVar dummy, TagCallValue dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    while (!ce.Done())
    {
        PtrWrite(ce.DstPointer(dst), upo.DoIt(PtrRead(ce.SrcPointer(src), SrcArithT())));
        ce.NextCoordinate(dst,src);
    }
}

template <class DstArrayT, class SrcArrayT, class UpoT, class CE>
void
FuncUpoCE(DstArrayT* dst, SrcArrayT* src, UpoT& upo, CE& ce,
          TagTransInVar dummy, TagCallPointer dummy2)
{
    while (!ce.Done())
    {
        upo.DoIt(ce.DstPointer(dst), ce.SrcPointer(src));
        ce.NextCoordinate(dst,src);
    }
}
*/

template <class DstArrayT, class SrcArrayT, class UpoT>
void
FuncUpoDispatch(DstArrayT* dst, SrcArrayT* src, UpoT& upo)
{
    FuncUpo(dst, src, upo, typename UpoT::TransVarianceCategory(),
              typename UpoT::CallCategory());
}

} // namespace Pattern
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---