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 <memcore/breakpoint.hpp>
#include <vector>
 
namespace Fiber
{
        using Eagle::MetaInfo;
 
template <Dims_t N, class T>
class   MultiArrayBase : public CreativeIterator<T>
{
private:
        MultiIndex<N>   dimensions;
 
        using CreativeIterator<T>::myDataCreator;
 
public:
        typedef CreativeIterator<T> Base_t;
 
        using CreativeIterator<T>::ptr;
 
        using typename Base_t::ValueBase_t;
        using typename Base_t::component_t;
 
static  constexpr Dims_t Dims = N;
 
//      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)
        {}
 
        constexpr unsigned long memsize() const
        {
                return dimensions.size() * sizeof(T);
        }
 
        constexpr const Storage_t&storage() const
        {
                return (*this);
        }
 
        constexpr 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
        {
                return getElement(I);
        }
 
#ifdef  __cpp_multidimensional_subscript
        template<typename I0, typename I1, typename... I>
        auto    operator[](I0 i0, I1 i1, const I&... indices) const
        {
                static_assert( N == sizeof...(I)+2, "Wrong number of multidimensional arguments." );
                return getElement( MIndex(i0, i1, indices... ) );
        }
#endif
 
        reference_t getElement(const MultiIndex<N>&I) const
        {
                if (!ptr() )
                {
                        Assertion( myDataCreator, "Accessing MultiArray without storage!" );
 
                index_t i = I.maxidx();
                Slice_t mySlice( myDataCreator->slice(Dims-1, i), dimensions.subidx(), myDataCreator);
                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(myDataCreator);
 
                        return Slice_t( myDataCreator->slice(Dims-1, i), SubSize, myDataCreator);
                }
 
                // Create subarray from iterator here, no on-demand creator here (last argument 0)
 
                return Slice_t( *reinterpret_cast<const 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(std::size_t i=0; i<N; i++)
                        I[i] = 0;
 
                return (*this)[ I ];
        }
 
 
        reference_t last() const
        {
        MultiIndex<N> I;
                for(std::size_t 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>::myDataCreator;
 
public:
        using CreativeIterator<T>::ptr;
 
        typedef CreativeIterator<T> Base_t;
 
        using typename Base_t::ValueBase_t;
        using typename 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(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() );
        }
 
        MultiArrayBase(T*data, const MultiIndex<1>&Extension, DataCreator<T>*Crec)
        : CreativeIterator<T>( Extension.size(), data, Crec)
        , dimensions(Extension)
        {}
 
        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 (myDataCreator)
                        return myDataCreator->getElement(i);
 
                return storage()[ i ];
        }
 
              reference_t operator[](index_t i)
        {
                if (myDataCreator)
                        return myDataCreator->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 ];
        }
};
 
 
#ifdef  __clang__
#warning CLANG HAS BUG https://bugs.llvm.org/show_bug.cgi?id=42757
#define INDEX_SEQUENCE_BUG
#endif
 
#ifdef  INDEX_SEQUENCE_BUG
template <Dims_t N, class T>
class MultiArray;
#else
template <Dims_t N, class T, class = std::make_index_sequence<N>>
class MultiArray;
#endif
 
#ifdef  INDEX_SEQUENCE_BUG
template <Dims_t N, class T>
class   MultiArray : public MultiArrayBase<N,T>
#else
template <Dims_t N, class T, std::size_t... Is>
class   MultiArray<N, T, std::index_sequence<Is...>> : public MultiArrayBase<N,T>
#endif
{
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;
 
        typedef typename Base_t::ValueBase_t ValueBase_t;
        typedef typename Base_t::component_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, 0)
        {}
 
        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 hyperslab(index_t i) const
        {
                return Hyperslab_t( slice(i) );
        }
 
#ifndef INDEX_SEQUENCE_BUG
        T&operator()(decltype(Is, index_t{})... args)
        {
                return this->getElement( Fiber::MIndex(args...) );
        }
 
        const T&operator()(decltype(Is, index_t{})... args) const
        {
                return this->getElement( Fiber::MIndex(args...) );
        }
#endif
};
 
 
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) || defined(__clang__)
 
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 )
        {}
};
 
template <int N, class T>
[[deprecated("Warning: Converting an entire MultiArray to a string!")]]
inline  std::string mkString(const Fiber::MultiArray<N, T>&M)
{
std::string     retval;
 
        for(auto I : M.Size())
        {
                retval += "  " + to_string(I) + ": " + to_string(M[I]) + "\n";
        }
 
        return retval;
}
 
} /* namespace Fiber */
 
 
namespace std
{
 
template <int N, class T>
[[deprecated("Warning: Converting an entire MultiArray to a string!")]]
inline string to_string(const Fiber::MultiArray<N, T>&M)
{
string  retval;
 
        for(auto I : M.Size())
        {
                retval += "  " + to_string(I) + ": " + to_string(M[I]) + "\n";
        }
 
        return retval;
}
 
 
} // std
 
 
#endif /* __Fiber_MULTIARRAY_HPP */