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;
        }

        int 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()
        {
                cropped = maxcount() - size; 
                if (cropped<0)
                        cropped=0;
        }

        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)
#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 */