MultiArray.hpp

#ifndef __FIBER_MULTIARRAY_HPP
#define __FIBER_MULTIARRAY_HPP "Created 3.07.2004 21:42:21 by bzfbenge"

#include "MultiIndex.hpp"
#include "Iterator.hpp"
#include "Expression.hpp"
#include "CreativeIterator.hpp"

#include <vector>

namespace Fiber
{
        using Eagle::MetaInfo;

template <int N, class T>
class   MultiArrayBase : public CreativeIterator<T>
{
private:
        MultiIndex<N>   dimensions;

        using CreativeIterator<T>::myCreator;

public:
        typedef CreativeIterator<T> Base_t;

        using CreativeIterator<T>::ptr;

        using Base_t::ValueBase_t;
        using Base_t::component_t;

        enum { Dims = N };

        typedef T value_type;

        typedef Iterator<T> Storage_t;

        typedef Iterator<T> SliceStorge_t;

        typedef MultiArrayBase<N-1,T> Slice_t;

        typedef typename Iterator<T>::reference_t reference_t;

        MultiArrayBase(T*data, const MultiIndex<Dims>&Extension, DataCreator<T>*Crec)
        : CreativeIterator<T>( Extension.size(), data, Crec)
        , dimensions(Extension)
        {}

        MultiArrayBase(const Iterator<T>&data, const MultiIndex<Dims>&Extension, DataCreator<T>*TheCreator=0)
        : Base_t(data, TheCreator)
        , dimensions(Extension)
        {
                if (Extension.size() < this->count() )
                {
                        this->setCount( dimensions.size() );
                }
        }

        MultiArrayBase(const MultiArrayBase&MAB)
        : Base_t(MAB)
        , dimensions(MAB.dimensions)
        {}

        unsigned long memsize() const
        {
                return dimensions.size() * sizeof(T);
        }

        const Storage_t&storage() const
        {
                return (*this);
        }

        const MultiIndex<Dims>&Size() const
        {
                return dimensions;
        }

        void    Resize(T*data, const MultiIndex<N>&D)
        {
                this->dimensions = D;
                this->SetNewData(data, dimensions.size() ); 

        }


        index_t nElements() const
        {
                return dimensions.size();
        }

        reference_t operator[](const MultiIndex<N>&I) const
        {
                if (!ptr() )
                {
                        assert( myCreator );

                index_t i = I.maxidx(); 
                Slice_t mySlice( myCreator->slice(Dims-1, i), dimensions.subidx(), myCreator); 
                MultiIndex<Dims-1> sI = I.subidx();

                        return mySlice[ sI ];
                }

                return Base_t::operator[]( I.linear(dimensions) );
        }

        Slice_t slice(index_t i) const
        {
        const MultiIndex<Dims-1>&SubSize = dimensions.subidx();
                assert(i>=0 && i < dimensions.maxidx() ); 

                if (!ptr() )
                {
                        assert(myCreator);

                        return Slice_t( myCreator->slice(Dims-1, i), SubSize, myCreator);
                }

                // Create subarray from iterator here, no on-demand creator here (last argument 0)

                return Slice_t( *(Iterator<T>*)this + index_t(i*SubSize.size()), SubSize, 0 );
        }

        Slice_t operator[](index_t i) const
        {
                return slice(i);
        }

        reference_t first() const
        {
        MultiIndex<N> I;
                for(int i=0; i<N; i++)
                        I[i] = 0; 

                return (*this)[ I ];
        }


        reference_t last() const
        {
        MultiIndex<N> I; 
                for(int i=0; i<N; i++)
                {
                        if (dimensions[i]<1)
                                I[i] = 0; 
                        else
                                I[i] = dimensions[i] - 1; 
                }

                return (*this)[ I ];
        }
}; 

template <class T>
class   MultiArrayBase<1,T> : public CreativeIterator<T> 
{
        using CreativeIterator<T>::myCreator;
public:
        using CreativeIterator<T>::ptr;

        typedef CreativeIterator<T> Base_t;

        using Base_t::ValueBase_t;
        using Base_t::component_t;

        enum { Dims = 1 };

        MultiIndex<Dims> dimensions;

        using Iterator<T>::count;

        typedef T value_type;

        typedef Iterator<T> Storage_t;

        typedef typename Iterator<T>::reference_t reference_t;

        MultiArrayBase<1,T>(const Iterator<T>&data, const MultiIndex<Dims>&Extension, DataCreator<T>*Crec)
        : Base_t(data, Crec)
        , dimensions( Extension )
        {
                if (count() > dimensions.size() )
                        this->setCount( dimensions.size() );            
        }

        const Storage_t&storage() const
        {
                return *this;
        }

        void    Resize(T*newData, const MultiIndex<1>&D)
        {
                this->dimensions = D;
                this->SetNewData(newData, D.size() ); 
        }

        void    Resize(T*newData, const index_t&D)
        {
                Resize(newData, MIndex(D) );
        }

        unsigned long memsize() const
        {
                return dimensions.size() * sizeof(T);
        }

        Iterator<T> getData(index_t i) const
        {
                return (*this)+i;
        }

        const MultiIndex<Dims>&Size() const
        {
                return dimensions;
        }

        index_t nElements() const
        {
                return dimensions.size();
        }

        const reference_t operator[](index_t i) const
        {
                if (myCreator)
                        return myCreator->getElement(i); 

                return storage()[ i ];
        }

              reference_t operator[](index_t i)
        {
                if (myCreator)
                        return myCreator->getElement(i); 

                return storage()[ i ];
        }

        const reference_t operator[](const MultiIndex<1>&I) const
        {
        index_t i = I.maxidx();
                return (*this)[ i ]; 
        }

              reference_t operator[](const MultiIndex<1>&I)
        {
                return (*this)[ I.maxidx() ]; 
        }

        const reference_t slice(index_t i) const
        {
                return (*this)[i];
        }

        const reference_t first() const
        {
                return (*this)[ 0 ]; 
        }

        const reference_t last() const
        {
        index_t I = 0; 
                if (dimensions[0]>1)
                        I = dimensions[0] - 1; 
                
                return (*this)[ I ]; 
        }
};



template <int N, class T>
        struct  MultiArray : public MultiArrayBase<N,T>
{
public:
        typedef MultiArrayBase<N,T> Base_t;

        typedef typename Base_t::value_type value_type;

        typedef MultiArray MultiArray_t;

        using Base_t::Size;
        using Base_t::slice;
        using Base_t::operator[];
        using Base_t::ptr;

//      using typename Base_t::ValueBase_t;
        typedef typename Base_t::ValueBase_t ValueBase_t;
        typedef typename Base_t::component_t component_t;
//      using Base_t::component_t;

        typedef MultiArray<N, ValueBase_t> MultiArrayBase_t;

        typedef MultiArray<N, component_t>  MultiArrayComponent_t;

        MultiArray(T*data, const MultiIndex<N>&Sz)
        : Base_t( Iterator<T>(Sz.size(), data), Sz)
        {}

        MultiArray(const MultiIndex<N>&Sz, DataCreator<T>*Crec)
        : Base_t(0, Sz, Crec)
        {}

        MultiArray(const Iterator<T>&data, const MultiIndex<N>&Sz)
        : Base_t(data, Sz, 0)
        {}

        MultiArray(const MultiArray&MA)
        : Base_t(MA)
        {}

        MultiArray(const Base_t&MA)
        : Base_t(MA)
        {}

        MultiArrayBase_t arraybase() const
        {
                return MultiArrayBase_t( this->getArrayIterator(), Size() ); 
//              return MultiArrayBase_t(array_iterator(*this), Size() );
        }

        operator MultiArrayBase_t() const
        {
                return arraybase();
        }


        MultiArrayComponent_t component(int i) const
        {
                return  MultiArrayComponent_t(this->getComponent(i), Size() );
        }

        typedef Iterator<T> SliceStorage_t;

        typedef typename MultiArray<N-1,T>::MultiArray_t Hyperslab_t;

        Hyperslab_t operator[](index_t i) const
        {
                return Hyperslab_t( slice(i) );
        }
};


template <class T>
class   MultiArray<0, T>
{
public:
        typedef T MultiArray_t;

        typedef typename MetaInfo<T>::element_t component_t;

        typedef FixedArray< component_t, MetaInfo<T>::MULTIPLICITY>
                        FixedArray_t;

        typedef typename META::IF< MetaInfo<T>::MULTIPLICITY == 1,
                                   component_t, FixedArray_t>::result ValueBase_t;

        typedef MultiArray<0, ValueBase_t> MultiArrayBase_t;

        typedef MultiArray<0, component_t>  MultiArrayComponent_t;


        void *ptr() const { return 0; }
};


template <int I> struct MultiArrayOutStreamSeparator
{
        enum { begin = '{', end = '}' };
};

template <> struct MultiArrayOutStreamSeparator<1>
{
        enum { begin = 0, end = ' ' };
};

template <> struct MultiArrayOutStreamSeparator<2>
{
        enum { begin ='(', end = ')' };
};

template <> struct MultiArrayOutStreamSeparator<3>
{
        enum { begin = 0, end = '\n' };
};

//               MSVC                           GCC             G++                   SGI C++
#if     defined(_IOSTREAM_) || defined(_GLIBCXX_OSTREAM) || _CPP_IOSTREAM || defined(__SGI_STL_IOSTREAM)

template <int N, class T>
std::ostream&operator<<(std::ostream&out, const MultiArray<N,T>&M)
{
        for(index_t k=0; k<M.Size()[N-1]; k++)
        {
                if (MultiArrayOutStreamSeparator<N>::begin)
                        out << char(MultiArrayOutStreamSeparator<N>::begin);

                out << M[k] 
                    << char(MultiArrayOutStreamSeparator<N>::end);
        }
        return out;
}

#endif


template <class Operator>
struct MExpression
{

        template <int D, class Data, class Data1, class Data2>
        static  void ternary(const MultiArray<D,Data >&p, 
                             const MultiArray<D,Data1>&q, 
                             const MultiArray<D,Data2>&r)
        {
                Expression<Operator>::ternary( array_iterator(p),
                                               array_iterator(q),
                                               array_iterator(r) );
        }       
};

template <int N, class T>
struct  MultiArraySTLVector : public std::vector<T>, public MultiArray<N,T>
{
        MultiArraySTLVector(const MultiIndex<N>&Sz)
        : std::vector<T>( Sz.size() )
        , MultiArray<N,T>( &*this->begin(), Sz )
        {}
};


} /* namespace Fiber */ 

#endif /* __Fiber_MULTIARRAY_HPP */