MHO_NDArrayMath.hh

Go to the documentation of this file.

#ifndef MHO_NDArrayMath_HH__
#define MHO_NDArrayMath_HH__
 
#include <cmath>
#include <cstddef>
 
namespace hops
{
 
class MHO_NDArrayMath
{
    public:
        MHO_NDArrayMath(){};
        virtual ~MHO_NDArrayMath(){};
 
        static std::size_t Modulus(std::size_t arg, std::size_t n) { return arg % n; }
 
        template< std::size_t RANK >
        inline static std::size_t OffsetFromRowMajorIndex(const std::size_t* DimSize, const std::size_t* Index)
        {
            std::size_t val = Index[0];
            for(std::size_t i = 1; i < RANK; i++)
            {
                val *= DimSize[i];
                val += Index[i];
            }
            return val;
        }
 
        template< std::size_t RANK >
        inline static std::size_t OffsetFromStrideIndex(const std::size_t* Strides, const std::size_t* Index)
        {
            std::size_t val = 0;
            for(std::size_t i = 0; i < RANK; i++)
            {
                val += Index[i] * Strides[i];
            }
            return val;
        }
 
        template< std::size_t RANK >
        inline static std::size_t StrideFromRowMajorIndex(std::size_t selected_dim, const std::size_t* DimSize)
        {
            std::size_t val = 1;
            for(std::size_t i = 0; i < RANK; i++)
            {
                if(i > selected_dim)
                {
                    val *= DimSize[i];
                };
            }
            return val;
        }
 
        template< std::size_t RANK >
        inline static void RowMajorIndexFromOffset(std::size_t offset, const std::size_t* DimSize, std::size_t* Index)
        {
            std::size_t div[RANK];
 
            //in row major format the last index varies the fastest
            std::size_t i;
            for(std::size_t d = 0; d < RANK; d++)
            {
                i = RANK - d - 1;
 
                if(d == 0)
                {
                    Index[i] = MHO_NDArrayMath::Modulus(offset, DimSize[i]);
                    div[i] = (offset - Index[i]) / DimSize[i];
                }
                else
                {
                    Index[i] = MHO_NDArrayMath::Modulus(div[i + 1], DimSize[i]);
                    div[i] = (div[i + 1] - Index[i]) / DimSize[i];
                }
            }
        }
 
        //checks if all the indices in Index are in the valid range
        template< std::size_t RANK > inline static bool CheckIndexValidity(const std::size_t* DimSize, const std::size_t* Index)
        {
            for(std::size_t i = 0; i < RANK; i++)
            {
                if(Index[i] >= DimSize[i])
                {
                    return false;
                };
            }
            return true;
        };
 
        //given the dimensions of an array, computes its total size, assuming all dimensions are non-zero
        template< std::size_t RANK > inline static std::size_t TotalArraySize(const std::size_t* DimSize)
        {
            std::size_t val = 1;
            for(std::size_t i = 0; i < RANK; i++)
            {
                val *= DimSize[i];
            }
            return val;
        }
 
        template< std::size_t N > struct PowerOfTwo
        {
                enum
                {
                    value = 2 * PowerOfTwo< N - 1 >::value
                };
        };
 
        template< int numerator, int denominator > struct Divide
        {
                enum
                {
                    value = Divide< numerator, 1 >::value / Divide< denominator, 1 >::value
                };
        };
 
        template< std::size_t RANK >
        static void OffsetsForReversedIndices(const std::size_t* DimSize, std::size_t* ReversedIndex)
        {
            std::size_t total_array_size = MHO_NDArrayMath::TotalArraySize< RANK >(DimSize);
            std::size_t index[RANK];
            for(std::size_t i = 0; i < total_array_size; i++)
            {
                MHO_NDArrayMath::RowMajorIndexFromOffset< RANK >(i, DimSize, index);
                for(std::size_t j = 0; j < RANK; j++)
                {
                    index[j] = (DimSize[j] - index[j]) % DimSize[j];
                };
                ReversedIndex[i] = MHO_NDArrayMath::OffsetFromRowMajorIndex< RANK >(DimSize, index);
            }
        }
 
        template< std::size_t RANK > static bool IncrementIndices(const std::size_t* DimSize, std::size_t* Index)
        {
            for(std::size_t i = 1; i <= RANK; i++)
            {
                if(++Index[RANK - i] < DimSize[RANK - i])
                {
                    return true;
                }
                else
                {
                    Index[RANK - i] = 0;
                }
            }
            //if we have reached here we have overflowed the 0-th dimension
            return false;
        }
 
        template< std::size_t RANK >
        static bool IncrementIndices(const std::size_t* DimSize, std::size_t* Index, std::size_t diff)
        {
            std::size_t offset = OffsetFromRowMajorIndex< RANK >(DimSize, Index);
            offset += diff;
            if(offset < TotalArraySize< RANK >(DimSize))
            {
                RowMajorIndexFromOffset< RANK >(offset, DimSize, Index);
                return true;
            }
            //cannot increment past the end
            return false;
        }
 
        template< std::size_t RANK > static bool DecrementIndices(const std::size_t* DimSize, std::size_t* Index)
        {
            for(std::size_t i = 1; i <= RANK; i++)
            {
                if(Index[RANK - i] > 0)
                {
                    --Index[RANK - i];
                    return true;
                }
                else
                {
                    Index[RANK - i] = DimSize[RANK - i] - 1;
                }
            }
            //if we reach here we have underflowed the 0-th dimension
            return false;
        }
 
        template< std::size_t RANK >
        static bool DecrementIndices(const std::size_t* DimSize, std::size_t* Index, std::size_t diff)
        {
            std::size_t offset = OffsetFromRowMajorIndex< RANK >(DimSize, Index);
            if(diff < offset)
            {
                offset -= diff;
                RowMajorIndexFromOffset< RANK >(offset, DimSize, Index);
                return true;
            }
            //cannot decrement more than the offset from start
            return false;
        }
};
 
template<> struct MHO_NDArrayMath::PowerOfTwo< 0 >
{
        enum
        {
            value = 1
        };
};
 
template< int numerator > struct MHO_NDArrayMath::Divide< numerator, 1 >
{
        enum
        {
            value = numerator
        };
};
 
} // namespace hops
 
#endif