From a6c860a352d26cc244886033736a53487d7d62fc Mon Sep 17 00:00:00 2001 From: Christian Zimmermann Date: Wed, 8 Mar 2017 20:10:11 +0100 Subject: [PATCH] add some range transformation routines --- src/base_def.h | 9 ++++++++- src/index_base.cc | 6 ------ src/index_base.h | 4 +++- src/manipulator.cc | 8 ++++---- src/manipulator.h | 2 +- src/multi_array.cc | 36 ++++++++++++++++++++++++++++++++---- src/multi_array.h | 14 +++++++++++--- src/multi_array_header.h | 2 ++ src/multi_range.cc | 3 +++ src/multi_range.h | 1 + src/range_transformer.cc | 25 +++++++++++++++++++++++++ src/range_transformer.h | 13 +++++++++++-- src/slice.cc | 23 ----------------------- src/slice.h | 8 +------- 14 files changed, 102 insertions(+), 52 deletions(-) diff --git a/src/base_def.h b/src/base_def.h index 5200fa0..d2865c6 100644 --- a/src/base_def.h +++ b/src/base_def.h @@ -92,7 +92,14 @@ namespace MultiArrayTools // slice.h template class Slice; - + + // manipulator.h + template + class ManipulatorBase; + + // manipulator.h + template + class BinReader; } #endif diff --git a/src/index_base.cc b/src/index_base.cc index 7ac0023..3a425a6 100644 --- a/src/index_base.cc +++ b/src/index_base.cc @@ -91,12 +91,6 @@ namespace MultiArrayTools } } - size_t IndefinitIndexBase::max() const - { - //assert(not virt()); - return static_cast( -1 ); - } - size_t IndefinitIndexBase::outOfRange() const { //assert(not virt()); diff --git a/src/index_base.h b/src/index_base.h index 256f008..9ed71c6 100644 --- a/src/index_base.h +++ b/src/index_base.h @@ -43,10 +43,12 @@ namespace MultiArrayTools virtual void freeLinked(); virtual bool linked() const; virtual void linkTo(IndefinitIndexBase* target) = 0; + + virtual IndefinitIndexBase* getLinked(const std::string& name) = 0; virtual void setPos(size_t pos); - virtual size_t max() const; + virtual size_t max() const = 0; virtual size_t outOfRange() const; virtual bool toNull() const; diff --git a/src/manipulator.cc b/src/manipulator.cc index 7ae929d..43f8a60 100644 --- a/src/manipulator.cc +++ b/src/manipulator.cc @@ -21,7 +21,7 @@ namespace MultiArrayTools template BinReader::BinReader(const std::string& fname, size_t readBegin): - fs(fname, std::fstream::in | std::fstream::binary), + mFs(fname, std::fstream::in | std::fstream::binary), mReadBegin(readBegin) {} template @@ -37,18 +37,18 @@ namespace MultiArrayTools const size_t blockSize = sizeof(T) * readSize; char* buffer = new char[blockSize]; - mFs.seekg(mReadBegin + MB::mLastPos, fs.beg); + mFs.seekg(mReadBegin + MB::mLastPos, mFs.beg); mFs.read(buffer, blockSize); MB::mLastPos += blockSize; T* content = reinterpret_cast( buffer ); - if(mTargetPtr->size() < MB::mEnd){ + if(MB::mTargetPtr->size() < MB::mEnd){ assert(0); // throw } - std::copy(&content[0], &content[readSize], mTargetPtr->begin() + MB::mBegin); + std::copy(&content[0], &content[readSize], MB::mTargetPtr->begin() + MB::mBegin); delete[] buffer; } diff --git a/src/manipulator.h b/src/manipulator.h index 1702998..f884d0d 100644 --- a/src/manipulator.h +++ b/src/manipulator.h @@ -33,7 +33,7 @@ namespace MultiArrayTools }; template - class BinReader : public ManipulatorBase + class BinReader : public ManipulatorBase { public: typedef ManipulatorBase MB; diff --git a/src/multi_array.cc b/src/multi_array.cc index a42835d..ee8e0c0 100644 --- a/src/multi_array.cc +++ b/src/multi_array.cc @@ -71,6 +71,32 @@ namespace MultiArrayTools } } + template + template + MultiArray::MultiArray(const MultiArray,Range3> in) : + MultiArrayBase(merge(in.range(), in[ in.begin() ].range())) + // assert that Range2 has always same extension + { + mCont.clear(); + for(auto i = in.begin(); i != in.end(); ++i){ + mCont.insert(mCont.end(), in[i].mCont.begin(), in[i].mCont.end()); + } + assert(mCont.size() == MAB::mRange->size()); + } + + template + template + MultiArray& MultiArray::operator=(const MultiArray,Range3> in) + { + MAB::mRange.reset(new Range(merge(in.range(), in[ in.begin() ].range()))); + // assert that Range2 has always same extension + mCont.clear(); + for(auto i = in.begin(); i != in.end(); ++i){ + mCont.insert(mCont.end(), in[i].mCont.begin(), in[i].mCont.end()); + } + assert(mCont.size() == MAB::mRange->size()); + } + template T& MultiArray::operator[](const typename Range::IndexType& i) { @@ -89,12 +115,14 @@ namespace MultiArrayTools return false; } + /* template - void MultiArray::manipulate(ManipulatorBase& mb, size_t manBegin, size_t manEnd) + void MultiArray::manipulate(ManipulatorBase& mb, + const typename Range::IndexType& manBegin, + const typename Range::IndexType& manEnd) { - //mb.reset(); - mb.setup(mCont, manBegin, manEnd); + mb.setup(mCont, manBegin.pos(), manEnd.pos()); mb.execute(); } - + */ } diff --git a/src/multi_array.h b/src/multi_array.h index bd869ba..3b32434 100644 --- a/src/multi_array.h +++ b/src/multi_array.h @@ -20,6 +20,8 @@ namespace MultiArrayTools { public: + // iterator ( containing idx of Range ) + DEFAULT_MEMBERS(MultiArrayBase); MultiArrayBase(const Range& range); @@ -37,8 +39,6 @@ namespace MultiArrayTools template MultiArrayOperationRoot operator()(const NameTypes&... str); - virtual void manipulate(ManipulatorBase& mb, size_t manBegin, size_t manEnd) = 0; - protected: std::shared_ptr mRange; @@ -55,13 +55,21 @@ namespace MultiArrayTools MultiArray(const Range& range); MultiArray(const Range& range, const std::vector& vec); MultiArray(const Range& range, std::vector&& vec); + + template + MultiArray(const MultiArray,Range3> in); + + template + MultiArray& operator=(const MultiArray,Range3> in); T& operator[](const typename Range::IndexType& i) override; const T& operator[](const typename Range::IndexType& i) const override; virtual bool isSlice() const override; - virtual void manipulate(ManipulatorBase& mb, size_t manBegin, size_t manEnd) override; + // virtual void manipulate(ManipulatorBase& mb, + // const typename Range::IndexType& manBegin, + // const typename Range::IndexType& manEnd); template friend class MultiArray; diff --git a/src/multi_array_header.h b/src/multi_array_header.h index 8987c84..8bb14cf 100644 --- a/src/multi_array_header.h +++ b/src/multi_array_header.h @@ -12,6 +12,8 @@ #include "multi_array_operation.h" #include "multi_array.h" #include "slice.h" +#include "manipulator.h" +#include "range_transformer.h" namespace MultiArrayTools { diff --git a/src/multi_range.cc b/src/multi_range.cc index c169934..02c99e3 100644 --- a/src/multi_range.cc +++ b/src/multi_range.cc @@ -597,6 +597,9 @@ namespace MultiArrayTools template MultiRange::MultiRange(const Ranges&... rs) : mSpace(std::make_tuple(rs...)) {} + + template + MultiRange::MultiRange(const SpaceType& space) : mSpace(space) {} template template diff --git a/src/multi_range.h b/src/multi_range.h index e94ec00..2cb9dfb 100644 --- a/src/multi_range.h +++ b/src/multi_range.h @@ -104,6 +104,7 @@ namespace MultiArrayTools DEFAULT_MEMBERS(MultiRange); MultiRange(const Ranges&... rs); + MultiRange(const SpaceType& space); static const size_t dim = sizeof...(Ranges); diff --git a/src/range_transformer.cc b/src/range_transformer.cc index 2370b7b..94f8e4f 100644 --- a/src/range_transformer.cc +++ b/src/range_transformer.cc @@ -5,5 +5,30 @@ namespace MultiArrayTools { + template + MultiRange makeRange(const std::tuple& rangeTuple) + { + return MultiRange( rangeTuple ); + } + template + MultiRange combine(const Ranges&... ranges) + { + return MultiRange(ranges...); + } + + template + auto extend(const Range& r, const MultiRange& mr) + -> decltype( MultiRange(std::tuple_cat( std::make_tuple(r), mr.space() ) ) ) + { + return MultiRange(std::tuple_cat( std::make_tuple(r), mr.space() ) ); + } + + template + auto merge(const MultiRange1& mr1, const MultiRange2& mr2) + -> decltype( makeRange( std::tuple_cat( mr1.space(), mr2.space() ) ) ) + { + return makeRange( std::tuple_cat( mr1.space(), mr2.space() ) ); + } + } diff --git a/src/range_transformer.h b/src/range_transformer.h index aab60eb..f6a415f 100644 --- a/src/range_transformer.h +++ b/src/range_transformer.h @@ -9,10 +9,19 @@ namespace MultiArrayTools { - // init 'MultiRange' with 'new' template - shared_ptr > combine(const Ranges&... ranges); + MultiRange makeRange(const std::tuple& rangeTuple); + + template + MultiRange combine(const Ranges&... ranges); + template + auto extend(const Range& r, const MultiRange& mr) + -> decltype( MultiRange(std::tuple_cat( std::make_tuple(r), mr.space() ) ) ); + + template + auto merge(const MultiRange1& mr1, const MultiRange2& mr2) + -> decltype(makeRange( std::tuple_cat( mr1.space(), mr2.space() ) ) ); } #include "range_transformer.cc" diff --git a/src/slice.cc b/src/slice.cc index cd30cbf..ee2b139 100644 --- a/src/slice.cc +++ b/src/slice.cc @@ -57,27 +57,4 @@ namespace MultiArrayTools //mOwnIdx = i.pos(); return (*mMultiArrayPtr)[ mMAIdx ]; } - - template - void Slice::manipulate(ManipulatorBase& mb, size_t manBegin, size_t manEnd) - { - mOwnIdx = manBegin; - const size_t blockSize = getBlockSize(); - const size_t totalManSize = manEnd - manBegin; - size_t curBegin = mMAIdx.pos(); - size_t curBlockNum = (mMAIdx.pos() - mMAIdx.pos() % blockSize) / blockSize; - size_t tempEnd = blockSize - mMAIdx.pos() % blockSize + blockSize * curBlockNum; - size_t manipulated = 0; - for(; manipulated < totalManSize; ){ - mMultiArrayPtr->manipulate(mb, curBegin, tempEnd); - // update variables... !!!! - } - } - - template - size_t Slice::getBlockSize() const - { - // implement !!! - return 1; - } } diff --git a/src/slice.h b/src/slice.h index c7c290f..de08ebe 100644 --- a/src/slice.h +++ b/src/slice.h @@ -38,15 +38,9 @@ namespace MultiArrayTools const Name& ownNm, const typename MARange::IndexType& MAIdx, const Name& MANm); - - virtual void manipulate(ManipulatorBase& mb, size_t manBegin, size_t manEnd) override; - - // size of coherent data blocks (vectorizable) managed by the slice - // = 1 if the smallest index of original array is NOT managed by the slice - size_t getBlockSize() const; private: - + MultiArrayBase* mMultiArrayPtr = nullptr; mutable typename Range::IndexType mOwnIdx; mutable typename MARange::IndexType mMAIdx;