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

---

FuncMNpo.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncMNpo_h
#define Impala_Core_Array_Pattern_FuncMNpo_h

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

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


template <class DstArrayT, class SrcArrayT, class MNpoT>
void
FuncM9N4po(DstArrayT* dst1, DstArrayT* dst2, DstArrayT* dst3, DstArrayT* dst4,
           SrcArrayT* src1, SrcArrayT* src2, SrcArrayT* src3, SrcArrayT* src4,
           SrcArrayT* src5, SrcArrayT* src6, SrcArrayT* src7, SrcArrayT* src8,
           SrcArrayT* src9, MNpoT& mnpo)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    int width = ArrayCW(dst1);
    int height = ArrayCH(dst1);
    for (int y=0 ; y<height ; y++)
    {
        SrcStorT* s1Ptr = ArrayCPB(src1, 0, y);
        SrcStorT* s2Ptr = ArrayCPB(src2, 0, y);
        SrcStorT* s3Ptr = ArrayCPB(src3, 0, y);
        SrcStorT* s4Ptr = ArrayCPB(src4, 0, y);
        SrcStorT* s5Ptr = ArrayCPB(src5, 0, y);
        SrcStorT* s6Ptr = ArrayCPB(src6, 0, y);
        SrcStorT* s7Ptr = ArrayCPB(src7 , 0, y);
        SrcStorT* s8Ptr = ArrayCPB(src8, 0, y);
        SrcStorT* s9Ptr = ArrayCPB(src9, 0, y);
        DstStorT* d1Ptr = ArrayCPB(dst1, 0, y);
        DstStorT* d2Ptr = ArrayCPB(dst2, 0, y);
        DstStorT* d3Ptr = ArrayCPB(dst3, 0, y);
        DstStorT* d4Ptr = ArrayCPB(dst4, 0, y);
        for (int x=0 ; x<width ; x++)
        {
            mnpo.DoIt(d1Ptr, d2Ptr, d3Ptr, d4Ptr,
                      PtrRead(s1Ptr, SrcArithT()),
                      PtrRead(s2Ptr, SrcArithT()),
                      PtrRead(s3Ptr, SrcArithT()),
                      PtrRead(s4Ptr, SrcArithT()),
                      PtrRead(s5Ptr, SrcArithT()),
                      PtrRead(s6Ptr, SrcArithT()),
                      PtrRead(s7Ptr, SrcArithT()),
                      PtrRead(s8Ptr, SrcArithT()),
                      PtrRead(s9Ptr, SrcArithT()));
            d1Ptr += DstArrayT::ElemSize();
            d2Ptr += DstArrayT::ElemSize();
            d3Ptr += DstArrayT::ElemSize();
            d4Ptr += DstArrayT::ElemSize();
            s1Ptr += SrcArrayT::ElemSize();
            s2Ptr += SrcArrayT::ElemSize();
            s3Ptr += SrcArrayT::ElemSize();
            s4Ptr += SrcArrayT::ElemSize();
            s5Ptr += SrcArrayT::ElemSize();
            s6Ptr += SrcArrayT::ElemSize();
            s7Ptr += SrcArrayT::ElemSize();
            s8Ptr += SrcArrayT::ElemSize();
            s9Ptr += SrcArrayT::ElemSize();
        }
    }
}

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

#endif

---