From a880d1e0db1450e55183858cb40e04da6027c8cb Mon Sep 17 00:00:00 2001 From: Christian Zimmermann Date: Sun, 18 Sep 2022 18:53:38 +0200 Subject: [PATCH] start refactoring mrange + index interface offset (not finished) --- src/include/ranges/index_base.h | 4 + src/include/ranges/mrange.cc.h | 241 ++++++++++++ src/include/ranges/mrange.h | 645 +++----------------------------- 3 files changed, 299 insertions(+), 591 deletions(-) create mode 100644 src/include/ranges/mrange.cc.h diff --git a/src/include/ranges/index_base.h b/src/include/ranges/index_base.h index 6168954..7c9c1cf 100644 --- a/src/include/ranges/index_base.h +++ b/src/include/ranges/index_base.h @@ -45,7 +45,10 @@ namespace CNORXZ SizeT dim() const { return THIS().dim(); } auto range() const { return THIS().range(); } + // TODO: getStepSize(PtrId iptr) !!!! SizeT getStepSize(SizeT n) const { return THIS().getStepSize(n); } + Int getOffset(PtrId iptr) const + { if(mRel) if(iptr == mRel->ptrId()) return mPos - mRel.pos(); return 0; } String stringMeta() const { return THIS().stringMeta(); } auto meta() const { return THIS().meta(); } @@ -74,6 +77,7 @@ namespace CNORXZ IndexInterface(SizeT pos); PtrId mPtrId = 0; + IndexPtr mRel; }; template diff --git a/src/include/ranges/mrange.cc.h b/src/include/ranges/mrange.cc.h new file mode 100644 index 0000000..1dc6460 --- /dev/null +++ b/src/include/ranges/mrange.cc.h @@ -0,0 +1,241 @@ + +#ifndef __cxz_mrange_cc_h__ +#define __cxz_mrange_cc_h__ + +#include "mrange.h" +#include "range_helper.h" +#include "statics/static_for.h" + +namespace CNORXZ +{ + /************** + * MIndex * + **************/ + + template + template + MIndex::MIndex(const Sptr& range) : + IndexInterface,Tuple >(0) + { + std::get(mBlockSizes) = 1; + sfor_mn + ( [&](auto i) { + auto r = range->template getPtr(); + std::get(mIPack) = r->beginPtr(); + *std::get(mIPack) = 0; + + std::get(mBlockSizes) = sfor_p + ( [&](auto j) { return std::get(mIPack)->max(); } , + [&](auto a, auto b) { return a * b; }); + return 0; + }); + + IB::mPos = sfor_m + ( [&](auto i) { return std::get(mIPack); }, + [&](auto a, auto b) {return a->pos() + b*a->max();}, 0 ); + } + + template + MIndex& MIndex::operator()(Sptr&... indices) + { + return (*this)(std::make_tuple(indices...)); + } + + template + MIndex& MIndex::operator()(const Tuple...>& indices) + { + sfor_pn<0,sizeof...(Indices)> + ( [&](auto i) { std::get(mIPack) = std::get(indices); return 0; } ); + RangeHelper::setIndexPack(mIPack, IB::mPos); + return *this; + } + + template + MIndex& MIndex::operator=(SizeT pos) + { + IB::mPos = pos; + RangeHelper::setIndexPack(mIPack, pos); + return *this; + } + + template + MIndex& MIndex::operator++() + { + sfor_m + ( [&](auto i) { + auto& si = *std::get( mIPack ); + if(si.last() and i != 0) { si = 0; return true; } + else { ++si; return false; } + return false; + } ); + ++IB::mPos; + return *this; + } + + template + MIndex& MIndex::operator--() + { + sfor_m + ( [&](auto i) { + auto& si = *std::get( mIPack ); + if(si.first() and i != 0) { si = si.max()-1; return true; } + else { --si; return false; } + return false; + } ); + --IB::mPos; + return *this; + } + + + template + int MIndex::pp(PtrId idxPtrNum) + { + const int tmp = RangeHelper::ppx(mIPack, mBlockSizes, idxPtrNum); + IB::mPos += tmp; + return tmp; + } + + template + int MIndex::mm(PtrId idxPtrNum) + { + const int tmp = RangeHelper::mmx(mIPack, mBlockSizes, idxPtrNum); + IB::mPos -= tmp; + return tmp; + } + + template + String MIndex::stringMeta() const + { + return std::dynamic_pointer_cast( IB::mRangePtr )->stringMeta(IB::mPos); + } + + template + typename MIndex::MetaType MIndex::meta() const + { + MetaType metaTuple; + sfor_pn<0,sizeof...(Indices)> + ( [&](auto i) { std::get(metaTuple) = std::get(mIPack)->meta(); return 0; } ); + return metaTuple; + } + + template + MIndex& MIndex::at(const MetaType& metaPos) + { + sfor_pn<0,sizeof...(Indices)> + ( [&](auto i) { std::get(mIPack)->at( std::get(metaPos) ); return 0; } ); + IB::mPos = sfor_m + ( [&](auto i) { return std::get(mIPack); }, + [&](auto a, auto b) {return a->pos() + b*a->max();}, 0 ); + return *this; + } + + template + SizeT MIndex::dim() + { + return sizeof...(Indices); + } + + template + Sptr::RangeType> + MIndex::range() + { + return std::dynamic_pointer_cast( mRangePtr ); + } + + template + SizeT MIndex::getStepSize(SizeT n) + { + if(n >= sizeof...(Indices)){ + assert(0); + // throw !! + } + return mBlockSizes[n+1]; + } + /* + template + template + auto MIndex::ifor(SizeT step, Exprs exs) const + { + return RangeHelper::mkFor<0>(step, mIPack, mBlockSizes, exs); + } + + template + template + auto MIndex::iforh(SizeT step, Exprs exs) const + { + return RangeHelper::mkForh<0>(step, mIPack, mBlockSizes, exs); + } + + template + template + auto MIndex::pifor(SizeT step, Exprs exs) const + { + return RangeHelper::mkPFor<0>(step, mIPack, mBlockSizes, exs); + } + */ + + /********************* + * MRangeFactory * + *********************/ + + template + MRangeFactory::MRangeFactory(const Sptr&... rs) + { + mProd = Sptr< MRange >( new MRange( rs... ) ); + } + + template + MRangeFactory::MRangeFactory(const typename MRange::Space& st) + { + mProd = Sptr< MRange >( new MRange( st ) ); + } + + template + Sptr MRangeFactory::create() + { + mProd = checkIfCreated( std::dynamic_pointer_cast( mProd )->mSpace ); + setSelf(); + return mProd; + } + + /****************** + * MRange * + ******************/ + + template + MRange::MRange(const Sptr&... rs) : mSpace(std::make_tuple(rs...)) {} + + template + MRange::MRange(const Space& space) : mSpace( space ) {} + + template + SizeT MRange::getMeta(const MetaType& metaPos) const + { + return RangeHelper::getMeta(mSpace,metaPos); + } + + template + SizeT MRange::dim() const + { + return sdim; + } + + template + SizeT MRange::size() const + { + return sfor_p<0,sizeof...(Ranges)> + ( [&](auto i) { return std::get(mSpace)->size(); }, + [&](auto a, auto b) { return a * b; } ); + } + + template + String MRange::stringMeta(SizeT pos) const + { + auto i = begin(); + i = pos; + return "[" + RangeHelper::getStringMeta<0>(i) + "]"; + } + +} + +#endif diff --git a/src/include/ranges/mrange.h b/src/include/ranges/mrange.h index ceff746..f8ad35b 100644 --- a/src/include/ranges/mrange.h +++ b/src/include/ranges/mrange.h @@ -1,106 +1,66 @@ // -*- C++ -*- -#ifndef __cxz_multi_range_h__ -#define __cxz_multi_range_h__ +#ifndef __cxz_mrange_h__ +#define __cxz_mrange_h__ #include "base/base.h" -#include - #include "range_base.h" #include "index_base.h" -#include "range_helper.h" -//#include "multi_range_factory_product_map.h" - -#include "statics/static_for.h" - namespace CNORXZ { template - class MultiIndex : public IndexInterface, - Tuple > + class MIndex : public IndexInterface, + Tuple > { public: - typedef IndexInterface, + typedef IndexInterface, Tuple > IB; typedef Tuple...> IndexPack; typedef Tuple MetaType; - typedef MultiRange RangeType; - typedef MultiIndex IType; + typedef MRange RangeType; - static constexpr IndexType sType() { return IndexType::MULTI; } - static constexpr SizeT sDim() { return sizeof...(Indices); } - static constexpr SizeT totalDim() { return (... * Indices::totalDim()); } - - static constexpr SpaceType STYPE = SpaceType::ANY; - static constexpr bool PARALLEL = TupleElem<0,Tuple>::type::PARALLEL; - - private: - - IndexPack mIPack; - Arr mBlockSizes; - MultiIndex() = default; - - public: - - const IndexPack& pack() const { return mIPack; } - // NO DEFAULT HERE !!! // ( have to assign sub-indices (ptr!) correctly ) + MIndex(const MIndex& i); + MIndex(MIndex&& i); + MIndex& operator=(const MIndex& i); + MIndex& operator=(MIndex&& i); - template - MultiIndex(const Sptr& range); + MIndex(const RangePtr& range, SizeT pos = 0); - template - MultiIndex& up(); + // replace sub-index instances; only use if you know what you are doing! + MIndex& operator()(Sptr&... indices); + MIndex& operator()(const MIndex& indices); - template - MultiIndex& down(); - - template - auto get() const -> decltype( *std::get( mIPack ) )&; - - template - auto getPtr() const -> decltype( std::get( mIPack ) )&; - - template - SizeT getBlockSize() const { return std::get(mBlockSizes); } + const IndexPack& pack() const { return mIPack; } + const auto& getBlockSizes() const { return mBlockSizes; } - // raplace instances (in contrast to its analogon in ConstContainerIndex - // MultiIndices CANNOT be influences be its subindices, so there is - // NO foreign/external controll) - // Do NOT share index instances between two or more MultiIndex instances - MultiIndex& operator()(Sptr&... indices); - MultiIndex& operator()(const Tuple...>& indices); + MIndex& operator=(SizeT pos); + MIndex& operator++(); + MIndex& operator--(); + MIndex operator+(Int n) const; + MIndex operator-(Int n) const; + MIndex& operator+=(Int n); + MIndex& operator-=(Int n); - // ==== >>>>> STATIC POLYMORPHISM <<<<< ==== - - IndexType type() const; - - MultiIndex& operator=(SizeT pos); - - MultiIndex& operator++(); - MultiIndex& operator--(); + SizeT operator*() const; + SizeT operator->() const; int pp(PtrId idxPtrNum); int mm(PtrId idxPtrNum); - std::string stringMeta() const; - MetaType meta() const; - MultiIndex& at(const MetaType& metaPos); - SizeT dim(); - bool first(); - bool last(); Sptr range(); - - template - auto getPtr() -> decltype( std::get( mIPack ) )&; - SizeT getStepSize(SizeT n); + String stringMeta() const; + MetaType meta() const; + MIndex& at(const MetaType& metaPos); + + /* template auto ifor(SizeT step, Exprs exs) const; @@ -109,559 +69,62 @@ namespace CNORXZ template auto pifor(SizeT step, Exprs exs) const; + */ + private: + MIndex() = default; + + IndexPack mIPack; + Arr mBlockSizes; + Sptr mRange; }; - /************************* - * MultiRangeFactory * - *************************/ // NOT THREAD SAVE template - class MultiRangeFactory : public RangeFactoryBase + class MRangeFactory : public RangeFactoryBase { public: - typedef MultiRange oType; + MRangeFactory() = delete; + MRangeFactory(const Sptr&... rs); + MRangeFactory(const Tuple...>& rs); - MultiRangeFactory() = delete; - MultiRangeFactory(const Sptr&... rs); - MultiRangeFactory(const typename MultiRange::Space& space); - - virtual Sptr create() override; - private: - - Sptr checkIfCreated(const Tuple...>& ptp); - + virtual void make() override final; + + Tuple...> mRs; }; - /****************** - * MultiRange * - ******************/ - template - class MultiRange : public RangeInterface > + class MRange : public RangeInterface > { public: typedef RangeBase RB; - typedef Tuple...> Space; - typedef MultiIndex IndexType; + typedef MIndex IndexType; typedef Tuple MetaType; - typedef MultiRange RangeType; - typedef MultiRangeFactory FType; - protected: - MultiRange() = delete; - MultiRange(const MultiRange& in) = delete; - MultiRange& operator=(const MultiRange& in) = delete; - - MultiRange(const Sptr&... rs); - MultiRange(const Space& space); - - Space mSpace; - - public: - - static const SizeT sdim = sizeof...(Ranges); - - template - auto get() const -> decltype( *std::get( mSpace ) )&; + const Space& space() const; SizeT getMeta(const MetaType& metaPos) const; - template - auto getPtr() const -> decltype( std::get( mSpace ) )&; - virtual Sptr sub(SizeT num) const override; virtual SizeT dim() const final; virtual SizeT size() const final; - virtual SpaceType spaceType() const final; - virtual DataHeader dataHeader() const final; - - virtual Vector typeNum() const final; - virtual SizeT cmeta(char* target, SizeT pos) const final; - virtual SizeT cmetaSize() const final; - virtual std::string stringMeta(SizeT pos) const final; - virtual Vector data() const final; + virtual String stringMeta(SizeT pos) const final; - const Space& space() const; - - virtual IndexType begin() const final; - virtual IndexType end() const final; + friend MRangeFactory; - template - auto cat(const Sptr >& erange) - -> Sptr >; + protected: + MRange() = delete; + MRange(const MRange& in) = delete; + MRange& operator=(const MRange& in) = delete; - friend MultiRangeFactory; + Tuple...> mRs; - static constexpr bool HASMETACONT = false; - static constexpr bool defaultable = false; - static constexpr SizeT ISSTATIC = (... & Ranges::ISSTATIC); - static constexpr SizeT SIZE = (... * Ranges::SIZE); }; } -/* ========================= * - * --- TEMPLATE CODE --- * - * ========================= */ - -namespace CNORXZ -{ - - namespace - { - using namespace CNORXZInternal; - } - - // -> define in range_base.cc - Sptr mkMULTI(const char** dp); - - /****************** - * MultiIndex * - ******************/ - - template - template - MultiIndex::MultiIndex(const Sptr& range) : - IndexInterface,Tuple >(range, 0) - { - std::get(mBlockSizes) = 1; - sfor_mn - ( [&](auto i) { - auto r = range->template getPtr(); - std::get(mIPack) = r->beginPtr(); - *std::get(mIPack) = 0; - - std::get(mBlockSizes) = sfor_p - ( [&](auto j) { return std::get(mIPack)->max(); } , - [&](auto a, auto b) { return a * b; }); - return 0; - }); - - IB::mPos = sfor_m - ( [&](auto i) { return std::get(mIPack); }, - [&](auto a, auto b) {return a->pos() + b*a->max();}, 0 ); - } - - template - template - MultiIndex& MultiIndex::up() - { - static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices"); - IB::mPos += sfor_p - ( [&](auto i) { return std::get(mIPack)->max(); }, - [&](auto a, auto b) { return a * b; } ); - sfor_m - ( [&](auto i) { - auto& si = *std::get( mIPack ); - if(si.last() and i != 0) { si = 0; return true; } - else { ++si; return false; } - return false; - } ); - return *this; - } - - template - template - MultiIndex& MultiIndex::down() - { - static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices"); - IB::mPos -= sfor_p - ( [&](auto i) { return std::get(mIPack)->max(); }, - [&](auto a, auto b) { return a * b; } ); - sfor_m - ( [&](auto i) { - auto& si = *std::get( mIPack ); - if(si.first() and i != 0) { si = si.max()-1; return true; } - else { --si; return false; } - return false; - } ); - return *this; - } - - template - template - auto MultiIndex::get() const -> decltype( *std::get( mIPack ) )& - { - return *std::get(mIPack); - } - - template - template - auto MultiIndex::getPtr() const -> decltype( std::get( mIPack ) )& - { - return std::get(mIPack); - } - - template - MultiIndex& MultiIndex::operator()(Sptr&... indices) - { - return (*this)(std::make_tuple(indices...)); - } - - template - MultiIndex& MultiIndex::operator()(const Tuple...>& indices) - { - sfor_pn<0,sizeof...(Indices)> - ( [&](auto i) { std::get(mIPack) = std::get(indices); return 0; } ); - RangeHelper::setIndexPack(mIPack, IB::mPos); - return *this; - } - - template - IndexType MultiIndex::type() const - { - return IndexType::MULTI; - } - - template - MultiIndex& MultiIndex::operator=(SizeT pos) - { - IB::mPos = pos; - RangeHelper::setIndexPack(mIPack, pos); - return *this; - } - - template - MultiIndex& MultiIndex::operator++() - { - sfor_m - ( [&](auto i) { - auto& si = *std::get( mIPack ); - if(si.last() and i != 0) { si = 0; return true; } - else { ++si; return false; } - return false; - } ); - ++IB::mPos; - return *this; - } - - template - MultiIndex& MultiIndex::operator--() - { - sfor_m - ( [&](auto i) { - auto& si = *std::get( mIPack ); - if(si.first() and i != 0) { si = si.max()-1; return true; } - else { --si; return false; } - return false; - } ); - --IB::mPos; - return *this; - } - - - template - int MultiIndex::pp(PtrId idxPtrNum) - { - const int tmp = RangeHelper::ppx(mIPack, mBlockSizes, idxPtrNum); - IB::mPos += tmp; - return tmp; - } - - template - int MultiIndex::mm(PtrId idxPtrNum) - { - const int tmp = RangeHelper::mmx(mIPack, mBlockSizes, idxPtrNum); - IB::mPos -= tmp; - return tmp; - } - - template - std::string MultiIndex::stringMeta() const - { - return std::dynamic_pointer_cast( IB::mRangePtr )->stringMeta(IB::mPos); - } - - template - typename MultiIndex::MetaType MultiIndex::meta() const - { - MetaType metaTuple; - sfor_pn<0,sizeof...(Indices)> - ( [&](auto i) { std::get(metaTuple) = std::get(mIPack)->meta(); return 0; } ); - return metaTuple; - } - - template - MultiIndex& MultiIndex::at(const MetaType& metaPos) - { - sfor_pn<0,sizeof...(Indices)> - ( [&](auto i) { std::get(mIPack)->at( std::get(metaPos) ); return 0; } ); - IB::mPos = sfor_m - ( [&](auto i) { return std::get(mIPack); }, - [&](auto a, auto b) {return a->pos() + b*a->max();}, 0 ); - return *this; - } - - template - SizeT MultiIndex::dim() - { - return sizeof...(Indices); - } - - template - bool MultiIndex::first() - { - return IB::mPos == 0; - } - - template - bool MultiIndex::last() - { - return IB::mPos == IB::mMax - 1; - } - - template - Sptr::RangeType> - MultiIndex::range() - { - return std::dynamic_pointer_cast( IB::mRangePtr ); - } - - template - template - auto MultiIndex::getPtr() -> decltype( std::get( mIPack ) )& - { - return std::get(mIPack); - } - - template - SizeT MultiIndex::getStepSize(SizeT n) - { - if(n >= sizeof...(Indices)){ - assert(0); - // throw !! - } - return mBlockSizes[n+1]; - } - - template - template - auto MultiIndex::ifor(SizeT step, Exprs exs) const - { - return RangeHelper::mkFor<0>(step, mIPack, mBlockSizes, exs); - } - - template - template - auto MultiIndex::iforh(SizeT step, Exprs exs) const - { - return RangeHelper::mkForh<0>(step, mIPack, mBlockSizes, exs); - } - - template - template - auto MultiIndex::pifor(SizeT step, Exprs exs) const - { - return RangeHelper::mkPFor<0>(step, mIPack, mBlockSizes, exs); - } - - /************************* - * MultiRangeFactory * - *************************/ - - template - MultiRangeFactory::MultiRangeFactory(const Sptr&... rs) - { - mProd = Sptr< MultiRange >( new MultiRange( rs... ) ); - } - - template - MultiRangeFactory::MultiRangeFactory(const typename MultiRange::Space& st) - { - mProd = Sptr< MultiRange >( new MultiRange( st ) ); - } - - template - Sptr MultiRangeFactory::create() - { - mProd = checkIfCreated( std::dynamic_pointer_cast( mProd )->mSpace ); - setSelf(); - return mProd; - } - - template - Sptr MultiRangeFactory::checkIfCreated(const Tuple...>& ptp) - { - Sptr out; - bool check = false; - for(auto& x: MultiRangeFactoryProductMap::mAleadyCreated){ - if(x.second.size() == sizeof...(Ranges)){ - check = sfor_p<0,sizeof...(Ranges)> - ( [&](auto i) { return reinterpret_cast( std::get(ptp).get() ) == x.second[i]; }, - [&](auto a, auto b) { return a and b; } ); - if(check){ - out = x.first; - break; - } - } - } - if(not check){ - Vector pv(sizeof...(Ranges)); - sfor_pn<0,sizeof...(Ranges)> - ( [&](auto i) { pv[i] = reinterpret_cast( std::get(ptp).get() ); return 0; } ); - MultiRangeFactoryProductMap::mAleadyCreated[mProd] = pv; - out = mProd; - } - return out; - } - - /****************** - * MultiRange * - ******************/ - - template - MultiRange::MultiRange(const Sptr&... rs) : mSpace(std::make_tuple(rs...)) {} - - template - MultiRange::MultiRange(const Space& space) : mSpace( space ) {} - - template - template - auto MultiRange::get() const -> decltype( *std::get( mSpace ) )& - { - return *std::get(mSpace); - } - - template - SizeT MultiRange::getMeta(const MetaType& metaPos) const - { - return RangeHelper::getMeta(mSpace,metaPos); - } - - template - template - auto MultiRange::getPtr() const -> decltype( std::get( mSpace ) )& - { - return std::get(mSpace); - } - - template - Sptr MultiRange::sub(SizeT num) const - { - assert(num < sizeof...(Indices)); - return sforx_p<0,sizeof...(Indices)> - ( [&](auto i) { return std::dynamic_pointer_cast(std::get(mSpace)); }, - [&](auto i) { return num != i;} ); - } - - template - SizeT MultiRange::dim() const - { - return sdim; - } - - template - SizeT MultiRange::size() const - { - return sfor_p<0,sizeof...(Ranges)> - ( [&](auto i) { return std::get(mSpace)->size(); }, - [&](auto a, auto b) { return a * b; } ); - } - - template - SpaceType MultiRange::spaceType() const - { - return SpaceType::ANY; - } - - template - const typename MultiRange::Space& MultiRange::space() const - { - return mSpace; - } - - template - Vector MultiRange::typeNum() const - { - Vector o; - RangeHelper::getTypeNum(o,mSpace); - return o; - } - - template - SizeT MultiRange::cmeta(char* target, SizeT pos) const - { - const SizeT off = cmetaSize(); - MetaType* xtarget = reinterpret_cast(target); - return RangeHelper::getCMeta(xtarget,pos,mSpace,off); - } - - template - SizeT MultiRange::cmetaSize() const - { - return RangeHelper::getCMetaSize<0>(mSpace); - } - - template - std::string MultiRange::stringMeta(SizeT pos) const - { - auto i = begin(); - i = pos; - return "[" + RangeHelper::getStringMeta<0>(i) + "]"; - } - - template - Vector MultiRange::data() const - { - DataHeader h = dataHeader(); - Vector out; - //out.reserve(h.metaSize + sizeof(DataHeader)); - char* hcp = reinterpret_cast(&h); - out.insert(out.end(), hcp, hcp + sizeof(DataHeader)); - sfor_pn<0,sizeof...(Ranges)> - ( [&](auto i) { - Vector part = std::get(mSpace)->data(); - out.insert(out.end(), part.begin(), part.end()); - return 0; - } ); - return out; - } - - template - DataHeader MultiRange::dataHeader() const - { - DataHeader h; - h.spaceType = static_cast( SpaceType::ANY ); - h.metaSize = sizeof...(Ranges); - h.multiple = 1; - return h; - } - - template - typename MultiRange::IndexType MultiRange::begin() const - { - MultiIndex - i( std::dynamic_pointer_cast > - ( Sptr( RB::mThis ) ) ); - i = 0; - return i; - } - - template - typename MultiRange::IndexType MultiRange::end() const - { - MultiIndex - i( std::dynamic_pointer_cast > - ( Sptr( RB::mThis )) ); - i = size(); - return i; - } - - template - template - auto MultiRange::cat(const Sptr >& erange) - -> Sptr > - { - auto crange = std::tuple_cat(mSpace, erange->space()); - MultiRangeFactory rf(crange); - return std::dynamic_pointer_cast >(rf.create()); - } - -} - #endif