ArrayArithmetic.h

Go to the documentation of this file.

#ifndef GfxTL__ARRAYARITHMETIC_HEADER__
#define GfxTL__ARRAYARITHMETIC_HEADER__
#include <algorithm>
 
namespace GfxTL
{
 
    // c-style (row major) array layout
    template <unsigned int DimT>
    class ArrayArithmetic
    {
    public:
        ArrayArithmetic()
        {
        }
 
        template <class ExtentT>
        ArrayArithmetic(const ExtentT& ext)
        {
            Extent(ext);
        }
 
        template <class ExtentT>
        void
        Extent(const ExtentT& ext)
        {
            m_fac[DimT - 1] = 1;
            for (unsigned int i = DimT - 1; i != 0; --i)
            {
                m_fac[i - 1] = m_fac[i] * ext[i];
            }
            m_transFac[0] = 1;
            for (unsigned int i = 0; i < DimT - 1; ++i)
            {
                m_transFac[i + 1] = m_transFac[i] * ext[i];
            }
        }
 
        template <class SubscriptT>
        size_t
        Sub2Idx(const SubscriptT& sub) const
        {
            size_t idx = sub[0] * m_fac[0];
            for (unsigned int i = 1; i < DimT; ++i)
            {
                idx += sub[i] * m_fac[i];
            }
            return idx;
        }
 
        template <class SubscriptT>
        size_t
        Sub2TransposedIdx(const SubscriptT& sub) const
        {
            size_t idx = sub[0] * m_transFac[0];
            for (unsigned int i = 1; i < DimT; ++i)
            {
                idx += sub[i] * m_transFac[i];
            }
            return idx;
        }
 
        template <class SubscriptT>
        intptr_t
        Sub2Off(const SubscriptT& sub) const
        {
            intptr_t off = sub[0] * m_fac[0];
            for (unsigned int i = 1; i < DimT; ++i)
            {
                off += sub[i] * m_fac[i];
            }
            return off;
        }
 
        template <class SubscriptT>
        void
        Idx2Sub(size_t idx, SubscriptT* sub) const
        {
            for (unsigned int i = 0; i < DimT; ++i)
            {
                (*sub)[i] = idx / m_fac[i];
                idx %= m_fac[i];
            }
        }
 
        template <class SubscriptT>
        void
        TransposedIdx2Sub(size_t tidx, SubscriptT* sub) const
        {
            for (unsigned int i = DimT - 1; i != -1; --i)
            {
                (*sub)[i] = tidx / m_transFac[i];
                tidx %= m_transFac[i];
            }
        }
 
        // convert to column major index (Fortran and Matlab array layout)
        size_t
        Idx2TransposedIdx(size_t idx) const
        {
            size_t tidx = 0;
            for (unsigned int i = 0; i < DimT; ++i)
            {
                size_t j = idx / m_fac[i];
                idx %= m_fac[i];
                tidx += j * m_transFac[i];
            }
            return tidx;
        }
 
        // convert column major index (Fortran and Matlab array layout) to row major (c/c++ array layout)
        size_t
        TransposedIdx2Idx(size_t tidx) const
        {
            size_t idx = 0;
            for (unsigned int i = DimT - 1; i != -1; --i)
            {
                size_t j = tidx / m_transFac[i];
                tidx %= m_transFac[i];
                idx += j * m_fac[i];
            }
            return idx;
        }
 
    private:
        size_t m_fac[DimT];
        size_t m_transFac[DimT];
    };
 
}; // namespace GfxTL
 
#endif