HyperslabParameters.hpp

 
//
// $Id: HyperslabParameters.hpp,v 1.3 2007/10/08 22:22:08 werner Exp $
//
#ifndef __vector_HyperslabParameters_HPP
#define __vector_HyperslabParameters_HPP "Created 24.08.2006 11:48:12 by werner"
 
#include "Index.hpp"
#include <typeinfo>
 
namespace Fiber
{
 
class   HyperslabParameters
{
protected:
        index_t length;
        index_t stride;
        index_t offset;
        index_t shift;
        // how many elements at the end are not allowed to be iterable
        index_t cropped;
 
public:
        HyperslabParameters(index_t Length, index_t Stride, index_t Offset) throw()
        : length(Length)
        , stride(Stride)
        , offset(Offset)
        , shift(0)
        , cropped(0)
        {}
 
        HyperslabParameters(const HyperslabParameters&H) throw()
        : length(H.length)
        , stride(H.stride)
        , offset(H.offset)
        , shift(H.shift)
        , cropped(H.cropped)
        {}
 
        HyperslabParameters(index_t i, const HyperslabParameters&H) throw()
        : length(H.length)
        , stride(H.stride)
        , offset(H.offset)
        , shift (H.shift+i)
        , cropped(H.cropped)
        {}
 
        index_t getLength() const throw()
        {
                return length;
        }
 
        index_t getOffset() const throw()
        {
                return offset;
        }
 
        index_t getStride() const throw()
        {
                return stride;
        }
 
        index_t getShift() const throw()
        {
                return shift;
        }
 
        index_t getCropped() const throw()
        {
                return cropped;
        }
 
        bool isSeparatedCompound() const throw()
        {
                return stride == 1;
        }
 
        index_t multiplicity() const throw()
        {
                if (stride==1)
                {
                        assert(offset>0);
                        return length / offset;
                }
                else
                        return stride;
        }
 
        index_t maxcount() const throw()
        {
                if (stride==1)
                {
                        return offset - shift;
                }
                else
                {
                        assert(stride>0);
                        return length / stride - shift;
                }
        }
 
        index_t count() const throw()
        {
                return maxcount() - cropped;
        }
 
        void setCount(index_t size)  throw()
        {
                if( maxcount() < size )
                {
                        cropped = 0;
                        return;
                }
 
                cropped = maxcount() - size;
        }
 
        index_t getIndex(index_t i, int c) const throw()
        {
                return (shift + i)*stride + c*offset;
        }
 
 
        // MSVC                          GCC                                              SGI C++
#if     defined(_IOSTREAM_) || defined(_GLIBCXX_OSTREAM) || defined(_CPP_IOSTREAM) || defined(__SGI_STL_IOSTREAM) || defined(__clang__)
#define ITERATOR_OSTREAM
         friend std::ostream&operator<<(std::ostream&os, const HyperslabParameters&It)
         {
                 os << "{shift=" << It.shift << ", stride=" << It.stride << ", offset=" << It.offset
                    << ", length=" << It.length << ", cropped=" << It.cropped
                    <<  "} => count=" << It.count() << ", multiplicity=" << It.multiplicity() << "\n"
                   ;
                 return os;
         }
#endif
 
        HyperslabParameters&getHyperslabParameters() throw()
        {
                return *this;
        }
 
        const HyperslabParameters&getHyperslabParameters() const throw()
        {
                return *this;
        }
};
 
 
} /* namespace Fiber */
 
#endif /* __vector_HyperslabParameters_HPP */