DirectProductArray.hpp

#ifndef __FIBER_DIRECTPRODUCT_HPP
#define __FIBER_DIRECTPRODUCT_HPP

#include "MemArray.hpp"

namespace Fiber
{
using std::type_info;

template <class T>
class PolynomialArray : public MemArray<1, T>
{
public:
        typedef MemArray<1, T> Base_t;
        typedef typename Base_t::MultiArray_t MultiArray_t;
        MultiIndex<1>   max_index;

        using MultiArray_t::Size;
        using MultiArray_t::operator[];

        PolynomialArray(const MultiIndex<1>&M, index_t max_idx, const MemBase::Creator_t&C)
        : MemBase(C)
        , MemArray<1,T>(M,C)
        , max_index(max_idx)
        {}

        T operator()(index_t i) const
        {
        MultiIndex<1> Sz = Size();

        index_t p = Sz.size()-1;
        T       t = (*this)[p]; 
                while(p>0)
                {
                        t *= i;
                        p--;
                        t += (*this)[p];
                }
                return t;
        }

        index_t Length() const
        {
                return max_index.size();
        }

        void resize(index_t newSize)
        {
                max_index[0] = newSize;
        }

        bool locate(T&value) const
        {
                if (Length()==2)
                {
                        value = (value - (*this)[0] ) / (*this)[1]; 
                        return true;
                }

                return false;
        }
};


template <class T>
class LinearArray : public PolynomialArray<T>
{
public:
        typedef PolynomialArray<T> Base_t;
        using Base_t::operator[];

        LinearArray(index_t max_idx, const MemBase::Creator_t&C)
        : MemBase(C)
        , Base_t(MIndex(2), max_idx, C)
        {}

        LinearArray(const T&C0, const T&C1, index_t max_idx, const MemBase::Creator_t&C)
        : MemBase(C)
        , Base_t(MIndex(2), max_idx, C)
        {
                (*this)[0] = C0;
                (*this)[1] = C1;
        }

        override MemCore::memsize_t memsize() const
        {
                return 0;
        }

        T reverse(const T&value) const
        {
                return (value - (*this)[0] ) / (*this)[1];
        }
};


template <class T, int MDIMS>
class   DirectProductMemArrayBase : public MemArrayBase<MDIMS>
{
public:
        typedef typename T::value_type component_type;

        typedef PolynomialArray<component_type> PolynomialArray_t;

        enum
        {
                COMPONENTS = T::SIZE,
                Dims = MDIMS
        };

        RefPtr<PolynomialArray_t>       Components[ COMPONENTS ];

        Eagle::Vector<int, Dims>        ComponentMap;

        DirectProductMemArrayBase(const MemBase::Creator_t&C = MemCore::NullPtr() )
        : MemBase(C)
        , MemArrayBase<MDIMS>( C )
        {
                for(int i=0; i<Dims; i++)
                {
                        if (i<COMPONENTS)
                                ComponentMap[ i ] = i; 
                        else
                                ComponentMap[ i ] = -1; 
                }
        }

        DirectProductMemArrayBase(const RefPtr<PolynomialArray_t> C[ COMPONENTS ],
                                  const Eagle::Vector<int, Dims> &CMap,
                                  const MemBase::Creator_t&theCreator = MemCore::NullPtr() )
        : MemArrayBase<MDIMS>(theCreator)
        {
                for(int i=0; i<COMPONENTS; i++)
                {
                        Components[i] = C[i];
                }

                for(int i=0; i<Dims; i++)
                {
                        ComponentMap[ i ] = CMap[i];
                }
        }

        override void DeferredConstructor()
        {
                MemCore::SaveRegistry<DirectProductMemArrayBase>::addInterfaces(this); 
        }

        override MemCore::memsize_t memsize() const
        {
                return 0;
        }

        override RefPtr<MemBase> newMemArray() const
        {
                return new MemArray<MDIMS, T>( this->Size() );
        }

        RefPtr<MemArray<MDIMS,T> > createMemArray(const RefPtr<MemCore::ChunkBase>&Data, const MemBase::Creator_t&C) const
        {
                if (!Data) return MemCore::NullPtr(); 
                if (Data->elements() != Size().size() )
                        return MemCore::NullPtr(); 

                return new MemArray<MDIMS,T>(Data, Size(), C );
        }

        override RefPtr<MemBase> createEquallySizedMemArray(const RefPtr<MemCore::ChunkBase>&Storage, const MemBase::Creator_t&C) const
        {
                return createMemArray(Storage, C);
        }

        override RefPtr<MemBase> getComponentArray(int member, const MemBase::Creator_t&C)
        {
                return MemCore::NullPtr();
        }

        void retrieve(T&retval, const MultiIndex<Dims>&I) const
        {
                for(int i=0; i<Dims; i++)
                {
                int     component = ComponentMap[ i ]; 
                        if (component<0 || component>=COMPONENTS)
                                continue;

                const RefPtr<PolynomialArray_t>&that = Components[ component ];

                        if (that)
                                retval[ component ] = (*that)( I[i] );
                }
        }

        bool locate(T&pos) const
        {
                for(int i=0; i<Dims; i++)
                {
                int     component = ComponentMap[ i ]; 
                        if (component<0 || component>=COMPONENTS)
                        {
                                continue;
                        }

                const RefPtr<PolynomialArray_t>&that = Components[ component ];

                        if (!that)
                                return false; 

                        if (!that->locate( pos[ component ] ) )
                                return false;
                }

                return true;
        }

        override MultiIndex<Dims> Size() const
        {
        MultiIndex<Dims> Sz;
                for(int i=0; i<Dims; i++)
                {
                int     component = ComponentMap[ i ]; 
                        if (component<0 || component>=COMPONENTS)
                        {
                                Sz[ i ] = 1; 
                                continue;
                        }
                const RefPtr<PolynomialArray_t>&that = Components[ component ]; 
                        Sz[i] = that->Length();
                }
                return Sz;
        }

        MultiIndex<Dims> firstIndex() const
        {
        MultiIndex<Dims> I;
                for(int i=0; i<Dims; i++)
                        I[i] = 0;

                return I;       
        }

        MultiIndex<Dims> lastIndex() const
        {
        MultiIndex<Dims> I; 
                for(int i=0; i<Dims; i++)
                {
                index_t sz = this->Size()[i]; 
                        if (sz>1)
                                I[i] = sz - 1; 
                        else
                                I[i] = 0;
                }

                return Size() - MIndex(1,1,1);
        }

//      override CreativeIterator<T>* creativeIterator()
//      {
//              return 0;
//      }

        override const type_info&getType() const
        {
                return typeid(T);
        }

        override RefPtr<MemBase> getSlice(index_t i, const MemBase::Creator_t&C) const
        {
                return MemCore::NullPtr(); // not yet implemented...
        }

        override const FiberTypeBase&getFiberType() const
        {
                return FiberType<T>::getFiberType();
        }

        override void*getPtr()
        {
                return 0;
        }

        override HyperslabParameters& getHyperslabParameters()
        {
        static  HyperslabParameters nix(0,0,0);
                return nix;
        }
/*
        override RefPtr<UntypedCreativeIterator> getIterator() const
        {
                return MemCore::NullPtr();
        }
*/
};

struct DirectProductMemArrayCreateBaseArray {};


template <class T, int MDIMS = T::SIZE>
class   DirectProductMemArray : public DirectProductMemArrayBase<typename T::FixedArray_t, MDIMS>, public TypedArray<T>
{
public:
        typedef MemArray<MDIMS, T> MemArray_t;

        typedef T value_type;

        typedef typename T::value_type component_type;

        typedef DirectProductMemArrayBase<typename T::FixedArray_t, MDIMS> DirectProductMemArrayBase_t;
        using DirectProductMemArrayBase_t::Size;

        enum
        {
                COMPONENTS = DirectProductMemArrayBase_t::COMPONENTS,
                Dims       = DirectProductMemArrayBase_t::Dims
        };

        T       origin;

        template <class TBase>
        DirectProductMemArray(const DirectProductMemArrayCreateBaseArray&,const DirectProductMemArray<TBase>&D, const MemBase::Creator_t&C = MemCore::NullPtr() )
        : DirectProductMemArrayBase_t(D.Components, D.ComponentMap, C)
        , TypedArray<T>( C )
        , origin(D.origin)
        {}

        DirectProductMemArray(const MemBase::Creator_t&C = MemCore::NullPtr() )
        : MemBase(C) // don't use creators here, these arrays don't take significant memory
        , TypedArray<T>( C )
        {
                for(int c=0; c<COMPONENTS; c++)
                        origin[ c ] = 0;
        }

        virtual override const T&Origin() const = 0;
        virtual override const T&Delta()  const = 0;

        override const void*OriginPtr() const { return &Origin(); }
        override const void*DeltaPtr()  const { return &Delta();  }

        T operator[](const MultiIndex<Dims>&I) const
        {
        T       retval = origin; 
                retrieve( retval, I ); 
                return retval;
        }

        override RefPtr<MemBase> makeMemArray(const MemBase::Creator_t&C) const
        {
        MultiIndex<Dims> Sz = this->Size(); 

        RefPtr<MemArray_t> M = new MemArray_t( Sz, C );
        typename MemArray_t::MultiArray_t&dst = *M;

        MultiIndex<Dims> idx;

        T       val = origin;
                do
                {
                        retrieve( val, idx);
                        dst[idx] = val;

/*
  cannot use retrieve(dst[idx]) here, because dst[idx] might be an ElementProxy type,
  and passing such as non-const reference doesnt work.
  would be interesting how to fix that. if it is possible at all.
 */
//                      retrieve( dst[idx], idx);
                }
                while( idx.inc( Sz ) );

                return M;
        }


        override RefPtr<MemBase> getFixedArray() const
        {
                return MemCore::NullPtr(); 
//              return new DirectProductMemArray<FixedArray<component_type, MDIMS>, MDIMS>(DirectProductMemArrayCreateBaseArray(), *this);
        }

        override RefPtr<MemBase> getVectorArray() const
        {
                return MemCore::NullPtr();
//              return new DirectProductMemArray<Eagle::Vector<component_type, MDIMS>, MDIMS>(DirectProductMemArrayCreateBaseArray(), *this);
        }


        override RefPtr<MemBase> createMemArray(const MultiIndex<Dims>&, const MemBase::Creator_t&C) const
        {
                return MemCore::NullPtr();
        }

        override RefPtr<MemBase> createSubMemArray(const MultiIndex<Dims>&, const MultiIndex<Dims>&, const MemBase::Creator_t&C) const
        {
                return MemCore::NullPtr();
        }

        override const FiberTypeBase&getFiberType() const
        {
                return FiberType<T>::getFiberType();
        }

        override const type_info&getType() const
        {
                return typeid(T);
        }

        override CreativeIterator<T>* creativeIterator()
        {
                return 0;
        }

        override const CreativeIterator<T>* creativeIterator() const
        {
                return 0;
        }

        override RefPtr<MemCore::TypedChunk<T> > myChunk() const
        {
                return MemCore::NullPtr();
        }

        override T first() const
        {
                return (*this)[ this->firstIndex() ];   
        }

        override T last() const
        {
                return (*this)[ this->lastIndex() ];
        }
};


template <class T, class DeltaT = T, int MDIMS = T::SIZE>
class   LinearDirectProductMemArray : public DirectProductMemArray<T, MDIMS>
{
public:
        using DirectProductMemArray<T, MDIMS>::Components;

        enum { COMPONENTS = T::SIZE };

        typedef typename T::value_type component_type;

        const T baseValue;
        const DeltaT deltaValue;

        override const T&Origin()      const { return baseValue; }
        override const DeltaT&Delta()  const { return deltaValue; }

        LinearDirectProductMemArray(const index_t dims[MDIMS], const T&base, const DeltaT&delta, const MemBase::Creator_t&C = MemCore::NullPtr() )
        : MemBase(C)
        , DirectProductMemArray<T, MDIMS>(C)
        , baseValue(base)
        , deltaValue(delta)
        {
                for(int c=0; c<COMPONENTS; c++)
                {
                int     length = c<MDIMS ? dims[c] : 0;

                RefPtr<LinearArray<component_type> > 
                        LA = new LinearArray<component_type>( base[c], delta[c], length, C );

                        Components[c] = LA;
                }
        }

        LinearDirectProductMemArray(const MultiIndex<MDIMS>&dims, const T&base, const DeltaT&delta, const MemBase::Creator_t&C = MemCore::NullPtr() )
        : MemBase(C)
        , DirectProductMemArray<T, MDIMS>(C)
        , baseValue(base)
        , deltaValue(delta)
        {
                for(int c=0; c<COMPONENTS; c++)
                {
                int     length = c<MDIMS ? dims[c] : 0;

                RefPtr<LinearArray<component_type> > 
                        LA = new LinearArray<component_type>( base[c], delta[c], length, C );

                        Components[c] = LA;
                }
        }

        bool resize(int component, index_t newSize)
        {
                if (RefPtr<LinearArray<component_type> > LA = Components[component])
                {
                        LA->resize( newSize ); 
                        return true;
                } 
                return false;
        }
};

} /* namespace Fiber */ 

#endif /* __FIBER_DIRECTPRODUCT_HPP */