chizeta/cnorxz
chizeta/cnorxz
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

started refactoring index linking -- intermediate commit

Browse source
This commit is contained in:
Christian Zimmermann 2017-05-22 13:39:37 +02:00
parent 0a5cdd2339
commit 030d26a3bb
8 changed files with 70 additions and 402 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
src/index_base.cc
View file

@ -38,54 +38,6 @@ namespace MultiArrayTools
//assert(not virt()); //assert(not virt());
mName = nm.own(); mName = nm.own();
} }
bool IndefinitIndexBase::link(IndefinitIndexBase* toLink)
{
//assert(not virt());
if(toLink->rangeType() != rangeType() and toLink->name() == name()){
assert(0);
// throw !!
}
if(toLink->rangeType() == rangeType() and toLink->name() == name()){
if(mLinked == toLink){
return true; // dont link twice the same
}
else if(mLinked == nullptr){
mLinked = toLink;
return true;
}
else {
return mLinked->link(toLink);
}
}
else {
return false;
}
}
void IndefinitIndexBase::freeLinked()
{
if(mLinked != nullptr){
//mLinked->freeLinked();
mLinked = nullptr;
}
if(mSoftLinked != nullptr){
//mSoftLinked->freeLinked();
mSoftLinked = nullptr;
}
}
bool IndefinitIndexBase::linked() const
{
//assert(not virt());
return mLinked != nullptr;
}
bool IndefinitIndexBase::linkedTo(IndefinitIndexBase* link) const
{
//assert(not virt());
return mLinked == link or mSoftLinked == link;
}
void IndefinitIndexBase::setPos(size_t pos) void IndefinitIndexBase::setPos(size_t pos)
{ {

9
src/index_base.h
View file

@ -39,13 +39,6 @@ namespace MultiArrayTools
virtual MultiRangeType rangeType() const = 0; virtual MultiRangeType rangeType() const = 0;
virtual bool link(IndefinitIndexBase* toLink);
virtual void freeLinked();
virtual bool linked() const;
virtual bool linkedTo(IndefinitIndexBase* link) const;
virtual void linkTo(IndefinitIndexBase* target) = 0;
virtual IndefinitIndexBase* getLinked(const std::string& name) = 0;
virtual void setPos(size_t pos); virtual void setPos(size_t pos);
virtual void setPosRel(int relPos); virtual void setPosRel(int relPos);
@ -72,9 +65,7 @@ namespace MultiArrayTools
int mPos; int mPos;
size_t mMajorStep; size_t mMajorStep;
IndefinitIndexBase* mLinked = nullptr;
IndefinitIndexBase* mMajor = nullptr; IndefinitIndexBase* mMajor = nullptr;
IndefinitIndexBase* mSoftLinked = nullptr;
}; };
template <class Index> template <class Index>

183
src/multi_array_operation.cc
View file

@ -36,7 +36,7 @@ namespace MultiArrayTools
{ {
//#error "WRITE MAOR INTRINSIC CONTRACT FUNCTION" //#error "WRITE MAOR INTRINSIC CONTRACT FUNCTION"
//CHECK; //CHECK;
in.linkIndicesTo(MAOB::mIibPtr);
//CHECK; //CHECK;
IndexType& iref = dynamic_cast<IndexType&>(*MAOB::mIibPtr); IndexType& iref = dynamic_cast<IndexType&>(*MAOB::mIibPtr);
//CHECK; //CHECK;
@ -51,7 +51,7 @@ namespace MultiArrayTools
//assert(not std::isnan( get() )); //assert(not std::isnan( get() ));
} }
//CHECK; //CHECK;
MAOB::mIibPtr->freeLinked();
} }
template <typename T, class Range> template <typename T, class Range>
@ -90,7 +90,7 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperationRoot<T,Range>& in) MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperationRoot<T,Range>& in)
{ {
performAssignment(in); performAssignment(in);
freeIndex();
return *this; return *this;
} }
@ -99,7 +99,7 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>::operator=(MultiArrayOperationRoot<T,Range>& in) MultiArrayOperationRoot<T,Range>::operator=(MultiArrayOperationRoot<T,Range>& in)
{ {
performAssignment(in); performAssignment(in);
freeIndex();
return *this; return *this;
} }
@ -109,7 +109,7 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>::operator=(MultiArrayOperationRoot<T,Range2>& in) MultiArrayOperationRoot<T,Range>::operator=(MultiArrayOperationRoot<T,Range2>& in)
{ {
performAssignment(in); performAssignment(in);
freeIndex();
return *this; return *this;
} }
@ -120,7 +120,7 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperationRoot<T,Range2>& in) MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperationRoot<T,Range2>& in)
{ {
performAssignment(in); performAssignment(in);
freeIndex();
return *this; return *this;
} }
@ -130,7 +130,7 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>::operator=(ConstMultiArrayOperationRoot<T,Range2>& in) MultiArrayOperationRoot<T,Range>::operator=(ConstMultiArrayOperationRoot<T,Range2>& in)
{ {
performAssignment(in); performAssignment(in);
freeIndex();
return *this; return *this;
} }
@ -141,7 +141,7 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>::operator=(const ConstMultiArrayOperationRoot<T,Range2>& in) MultiArrayOperationRoot<T,Range>::operator=(const ConstMultiArrayOperationRoot<T,Range2>& in)
{ {
performAssignment(in); performAssignment(in);
freeIndex();
return *this; return *this;
} }
@ -152,7 +152,7 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperation<T,Operation,MAOps...>& in) MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperation<T,Operation,MAOps...>& in)
{ {
performAssignment(in); performAssignment(in);
freeIndex();
return *this; return *this;
} }
@ -162,7 +162,7 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayContraction<T,Operation,Range2,MAOps...>& in) MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayContraction<T,Operation,Range2,MAOps...>& in)
{ {
performAssignment(in); performAssignment(in);
freeIndex();
return *this; return *this;
} }
@ -305,19 +305,6 @@ namespace MultiArrayTools
return 1; return 1;
} }
template <typename T, class Range>
IndefinitIndexBase* MultiArrayOperationRoot<T,Range>::getLinked(const std::string& name) const
{
return mIndex.getLinked(name);
}
template <typename T, class Range>
void MultiArrayOperationRoot<T,Range>::linkIndicesTo(IndefinitIndexBase* target) const
{
MAOB::mIibPtr = &mIndex;
MAOB::mIibPtr->linkTo(target);
}
template <typename T, class Range> template <typename T, class Range>
T& MultiArrayOperationRoot<T,Range>::get() T& MultiArrayOperationRoot<T,Range>::get()
{ {
@ -361,7 +348,6 @@ namespace MultiArrayTools
template <typename T, class Range> template <typename T, class Range>
void MultiArrayOperationRoot<T,Range>::freeIndex() const void MultiArrayOperationRoot<T,Range>::freeIndex() const
{ {
MAOB::mIibPtr->freeLinked();
mIndex = mArrayRef.beginIndex(); mIndex = mArrayRef.beginIndex();
MAOB::mIibPtr = &mIndex; MAOB::mIibPtr = &mIndex;
MAOB::mIibPtr->name(mNm); MAOB::mIibPtr->name(mNm);
@ -428,7 +414,7 @@ namespace MultiArrayTools
const std::string& indexName, const std::string& indexName,
const MAOps&... mao) const const MAOps&... mao) const
{ {
typename Range2::IndexType* ind = dynamic_cast<typename Range2::IndexType*>( mIndex.getLinked(indexName) ); // !!!!!
return MultiArrayContraction<T,ContractOperation,Range2, return MultiArrayContraction<T,ContractOperation,Range2,
ConstMultiArrayOperationRoot<T,Range>, ConstMultiArrayOperationRoot<T,Range>,
MAOps...>(cop, *ind, *this, mao...); MAOps...>(cop, *ind, *this, mao...);
@ -443,7 +429,7 @@ namespace MultiArrayTools
size_t end, size_t end,
const MAOps&... mao) const const MAOps&... mao) const
{ {
typename Range2::IndexType* ind = dynamic_cast<typename Range2::IndexType*>( mIndex.getLinked(indexName) ); // !!!!
return MultiArrayContraction<T,ContractOperation,Range2, return MultiArrayContraction<T,ContractOperation,Range2,
ConstMultiArrayOperationRoot<T,Range>, ConstMultiArrayOperationRoot<T,Range>,
MAOps...>(cop, *ind, begin, end, *this, mao...); MAOps...>(cop, *ind, begin, end, *this, mao...);
@ -508,19 +494,6 @@ namespace MultiArrayTools
return 1; return 1;
} }
template <typename T, class Range>
IndefinitIndexBase* ConstMultiArrayOperationRoot<T,Range>::getLinked(const std::string& name) const
{
return mIndex.getLinked(name);
}
template <typename T, class Range>
void ConstMultiArrayOperationRoot<T,Range>::linkIndicesTo(IndefinitIndexBase* target) const
{
MAOB::mIibPtr = &mIndex;
MAOB::mIibPtr->linkTo(target);
}
template <typename T, class Range> template <typename T, class Range>
const T& ConstMultiArrayOperationRoot<T,Range>::get() const const T& ConstMultiArrayOperationRoot<T,Range>::get() const
{ {
@ -542,15 +515,6 @@ namespace MultiArrayTools
return *this; return *this;
} }
template <typename T, class Range>
void ConstMultiArrayOperationRoot<T,Range>::freeIndex() const
{
MAOB::mIibPtr->freeLinked();
mIndex = mArrayRef.beginIndex();
MAOB::mIibPtr = &mIndex;
MAOB::mIibPtr->name(mNm);
}
/******************************** /********************************
* MultiArrayOperationMap * * MultiArrayOperationMap *
********************************/ ********************************/
@ -588,15 +552,10 @@ namespace MultiArrayTools
std::cout << "map assignment: " << endIndex.pos() << " elements" << std::endl; std::cout << "map assignment: " << endIndex.pos() << " elements" << std::endl;
mRoot.linkIndicesTo( &mIndex ); // !!!!!
mRoot.linkIndicesTo( &mMF.index() );
mMF.linkIndicesTo( &mIndex );
in.linkIndicesTo( &mIndex );
MultiArray<T,TotalRange> cnt(mRoot->range()); MultiArray<T,TotalRange> cnt(mRoot->range());
MultiArrayOperationRoot<T,TotalRange> cnto(cnt, mRoot.name()); MultiArrayOperationRoot<T,TotalRange> cnto(cnt, mRoot.name());
cnto.linkIndicesTo( &mIndex );
cnto.linkIndicesTo( &mMF.index() );
for(mIndex.setPos(0), mMF.eval(); mIndex != endIndex; ++mIndex, mMF.eval()){ for(mIndex.setPos(0), mMF.eval(); mIndex != endIndex; ++mIndex, mMF.eval()){
get() += in.get(); get() += in.get();
@ -624,16 +583,9 @@ namespace MultiArrayTools
std::cout << "map assignment: " << endIndex.pos() << " elements" << std::endl; std::cout << "map assignment: " << endIndex.pos() << " elements" << std::endl;
mRoot.linkIndicesTo( &mIndex ); //!!!!!!!
mRoot.linkIndicesTo( &mMF.index() );
mMF.linkIndicesTo( &mIndex );
in.linkIndicesTo( &mIndex );
MultiArray<T,TotalRange> cnt(mRoot->range()); MultiArray<T,TotalRange> cnt(mRoot->range());
MultiArrayOperationRoot<T,TotalRange> cnto(cnt, mRoot.name()); MultiArrayOperationRoot<T,TotalRange> cnto(cnt, mRoot.name());
cnto.linkIndicesTo( &mIndex );
cnto.linkIndicesTo( &mMF.index() );
for(mIndex.setPos(0), mMF.eval(); mIndex != endIndex; ++mIndex, mMF.eval()){ for(mIndex.setPos(0), mMF.eval(); mIndex != endIndex; ++mIndex, mMF.eval()){
get() += in.get(); get() += in.get();
cnto.get() += 1.; cnto.get() += 1.;
@ -651,24 +603,6 @@ namespace MultiArrayTools
return 1; return 1;
} }
template <typename T, class InRange, class TotalInRange, class OutRange, class TotalRange>
IndefinitIndexBase* MultiArrayOperationMap<T,InRange,TotalInRange,OutRange,TotalRange>::
getLinked(const std::string& name) const
{
return mRoot.getLinked(name);
}
template <typename T, class InRange, class TotalInRange, class OutRange, class TotalRange>
void MultiArrayOperationMap<T,InRange,TotalInRange,OutRange,TotalRange>::
linkIndicesTo(IndefinitIndexBase* target) const
{
mRoot.linkIndicesTo(target);
}
template <typename T, class InRange, class TotalInRange, class OutRange, class TotalRange>
void MultiArrayOperationMap<T,InRange,TotalInRange,OutRange,TotalRange>::setInternalLinks() const
{ }
template <typename T, class InRange, class TotalInRange, class OutRange, class TotalRange> template <typename T, class InRange, class TotalInRange, class OutRange, class TotalRange>
const T& MultiArrayOperationMap<T,InRange,TotalInRange,OutRange,TotalRange>::get() const const T& MultiArrayOperationMap<T,InRange,TotalInRange,OutRange,TotalRange>::get() const
{ {
@ -685,27 +619,6 @@ namespace MultiArrayTools
* MultiArrayOperation * * MultiArrayOperation *
*****************************/ *****************************/
template <size_t N>
struct TupleIndicesLinker
{
template <class IndexTuple>
static void linkTupleIndicesTo(IndexTuple& itp, IndefinitIndexBase* target)
{
std::get<N>(itp).linkIndicesTo(target);
TupleIndicesLinker<N-1>::linkTupleIndicesTo(itp, target);
}
};
template <>
struct TupleIndicesLinker<0>
{
template <class IndexTuple>
static void linkTupleIndicesTo(IndexTuple& itp, IndefinitIndexBase* target)
{
std::get<0>(itp).linkIndicesTo(target);
}
};
template <size_t N> template <size_t N>
struct OperationCall struct OperationCall
{ {
@ -745,37 +658,6 @@ namespace MultiArrayTools
return op(std::get<0>(tp).get(), args.get()...); return op(std::get<0>(tp).get(), args.get()...);
} }
}; };
template <size_t N>
struct LinkedIndexGetter
{
template <class Tuple>
static IndefinitIndexBase* getLinked(const Tuple& optuple,
const std::string& name,
IndefinitIndexBase* current)
{
if(current == nullptr){
current = std::get<N>(optuple).getLinked(name);
LinkedIndexGetter<N-1>::getLinked(optuple, name, current);
}
return current;
}
};
template <>
struct LinkedIndexGetter<0>
{
template <class Tuple>
static IndefinitIndexBase* getLinked(const Tuple& optuple,
const std::string& name,
IndefinitIndexBase* current)
{
if(current == nullptr){
current = std::get<0>(optuple).getLinked(name);
}
return current;
}
};
template <typename T, class Operation, class... MAOps> template <typename T, class Operation, class... MAOps>
MultiArrayOperation<T,Operation,MAOps...>:: MultiArrayOperation<T,Operation,MAOps...>::
@ -816,7 +698,7 @@ namespace MultiArrayTools
const std::string& indexName, const std::string& indexName,
const MAOps2&... mao) const const MAOps2&... mao) const
{ {
typename Range2::IndexType* ind = dynamic_cast<typename Range2::IndexType*>( getLinked(indexName) ); // !!!
return MultiArrayContraction<T,ContractOperation,Range2,MultiArrayOperation<T,Operation,MAOps...>, return MultiArrayContraction<T,ContractOperation,Range2,MultiArrayOperation<T,Operation,MAOps...>,
MAOps2...>(cop, *ind, *this, mao...); MAOps2...>(cop, *ind, *this, mao...);
} }
@ -859,19 +741,6 @@ namespace MultiArrayTools
return sizeof...(MAOps) + 1; return sizeof...(MAOps) + 1;
} }
template <typename T, class Operation, class... MAOps>
IndefinitIndexBase* MultiArrayOperation<T,Operation,MAOps...>::getLinked(const std::string& name) const
{
return LinkedIndexGetter<sizeof...(MAOps)-1>::getLinked(mArgs, name, nullptr);
}
template <typename T, class Operation, class... MAOps>
void MultiArrayOperation<T,Operation,MAOps...>::linkIndicesTo(IndefinitIndexBase* target) const
{
TupleIndicesLinker<sizeof...(MAOps)-1>::linkTupleIndicesTo(mArgs, target);
}
template <typename T, class Operation, class... MAOps> template <typename T, class Operation, class... MAOps>
const T& MultiArrayOperation<T,Operation,MAOps...>::get() const const T& MultiArrayOperation<T,Operation,MAOps...>::get() const
{ {
@ -991,28 +860,6 @@ namespace MultiArrayTools
return sizeof...(MAOps) + 1; return sizeof...(MAOps) + 1;
} }
template <typename T, class ContractOperation, class Range, class... MAOps>
IndefinitIndexBase* MultiArrayContraction<T,ContractOperation,Range,MAOps...>::getLinked(const std::string& name) const
{
return LinkedIndexGetter<sizeof...(MAOps)-1>::getLinked(mArgs, name, nullptr);
}
template <typename T, class ContractOperation, class Range, class... MAOps>
void MultiArrayContraction<T,ContractOperation,Range,MAOps...>::setInternalLinks() const
{
linkIndicesTo(&mRunIndex);
}
template <typename T, class ContractOperation, class Range, class... MAOps>
void MultiArrayContraction<T,ContractOperation,Range,MAOps...>::linkIndicesTo(IndefinitIndexBase* target) const
{
if(target != &mRunIndex){
setInternalLinks();
}
TupleIndicesLinker<sizeof...(MAOps)-1>::linkTupleIndicesTo(mArgs, target);
}
template <typename T, class ContractOperation, class Range, class... MAOps> template <typename T, class ContractOperation, class Range, class... MAOps>
const T& MultiArrayContraction<T,ContractOperation,Range,MAOps...>::get() const const T& MultiArrayContraction<T,ContractOperation,Range,MAOps...>::get() const
{ {

28
src/multi_array_operation.h
View file

@ -26,14 +26,10 @@ namespace MultiArrayTools
virtual size_t argNum() const = 0; virtual size_t argNum() const = 0;
const IndefinitIndexBase& index() const; const IndefinitIndexBase& index() const;
virtual IndefinitIndexBase* getLinked(const std::string& name) const = 0;
virtual void linkIndicesTo(IndefinitIndexBase* target) const = 0;
virtual const T& get() const = 0; virtual const T& get() const = 0;
virtual void setInternalLinks() const {}
virtual void freeIndex() const;
protected: protected:
mutable IndefinitIndexBase* mIibPtr = nullptr; mutable IndefinitIndexBase* mIibPtr = nullptr;
@ -145,16 +141,11 @@ namespace MultiArrayTools
MultiArrayOperationRoot<T,Range>& operator[](const IndexType& ind); MultiArrayOperationRoot<T,Range>& operator[](const IndexType& ind);
const MultiArrayOperationRoot<T,Range>& operator[](const IndexType& ind) const; const MultiArrayOperationRoot<T,Range>& operator[](const IndexType& ind) const;
virtual IndefinitIndexBase* getLinked(const std::string& name) const override;
virtual void linkIndicesTo(IndefinitIndexBase* target) const override;
virtual T& get() override; virtual T& get() override;
virtual const T& get() const override; virtual const T& get() const override;
const Name& name() const; const Name& name() const;
virtual void freeIndex() const override;
const MultiArrayBase<T,Range>& getCont() const { return mArrayRef; } const MultiArrayBase<T,Range>& getCont() const { return mArrayRef; }
template <typename U, class RangeX> template <typename U, class RangeX>
@ -224,16 +215,10 @@ namespace MultiArrayTools
// set index -> implement !!!!! // set index -> implement !!!!!
const ConstMultiArrayOperationRoot<T,Range>& operator[](const IndexType& ind) const; const ConstMultiArrayOperationRoot<T,Range>& operator[](const IndexType& ind) const;
virtual IndefinitIndexBase* getLinked(const std::string& name) const override;
virtual void linkIndicesTo(IndefinitIndexBase* target) const override;
virtual const T& get() const override; virtual const T& get() const override;
const Name& name() const; const Name& name() const;
virtual void freeIndex() const override;
const MultiArrayBase<T,Range>& getCont() const { return mArrayRef; } const MultiArrayBase<T,Range>& getCont() const { return mArrayRef; }
template <typename U, class RangeX> template <typename U, class RangeX>
@ -264,11 +249,6 @@ namespace MultiArrayTools
MultiArrayOperationMap& operator=(const ConstMultiArrayOperationRoot<T,TotalInRange>& in); MultiArrayOperationMap& operator=(const ConstMultiArrayOperationRoot<T,TotalInRange>& in);
virtual size_t argNum() const override; virtual size_t argNum() const override;
virtual IndefinitIndexBase* getLinked(const std::string& name) const override;
virtual void linkIndicesTo(IndefinitIndexBase* target) const override;
virtual void setInternalLinks() const override;
virtual const T& get() const override; virtual const T& get() const override;
virtual T& get() override; virtual T& get() override;
@ -319,9 +299,6 @@ namespace MultiArrayTools
auto operator/(const MAOp2& sec) -> decltype(operator()(std::divides<T>(), sec)); auto operator/(const MAOp2& sec) -> decltype(operator()(std::divides<T>(), sec));
virtual size_t argNum() const override; virtual size_t argNum() const override;
virtual IndefinitIndexBase* getLinked(const std::string& name) const override;
virtual void linkIndicesTo(IndefinitIndexBase* target) const override;
virtual const T& get() const override; virtual const T& get() const override;
@ -377,14 +354,9 @@ namespace MultiArrayTools
template <class MAOp2> template <class MAOp2>
auto operator/(const MAOp2& sec) -> decltype(operator()(std::divides<T>(), sec)); auto operator/(const MAOp2& sec) -> decltype(operator()(std::divides<T>(), sec));
virtual void setInternalLinks() const override;
virtual size_t argNum() const override; virtual size_t argNum() const override;
virtual IndefinitIndexBase* getLinked(const std::string& name) const override;
virtual void linkIndicesTo(IndefinitIndexBase* target) const override;
virtual const T& get() const override; virtual const T& get() const override;
protected: protected:

140
src/multi_range.cc
View file

@ -237,17 +237,17 @@ namespace MultiArrayTools
struct IndexSetter struct IndexSetter
{ {
template <class... Ranges> template <class... Ranges>
static void setBegin(std::tuple<typename Ranges::IndexType...>& i, const std::tuple<Ranges...>& r) static void setBegin(MultiRange<Ranges...>::IndexType& i, const MultiRange<Ranges...>::SpaceType& r)
{ {
std::get<N>(i) = std::get<N>(r).begin(); *std::get<N>(i) = std::get<N>(r)->begin();
IndexSetter<N-1>::setBegin(i,r); IndexSetter<N-1>::setBegin(i,r);
} }
template <class... Ranges> template <class... Ranges>
static void setEnd(std::tuple<typename Ranges::IndexType...>& i, const std::tuple<Ranges...>& r) static void setEnd(MultiRange<Ranges...>::IndexType& i, const MultiRange<Ranges...>::SpaceType& r)
{ {
std::get<N>(i) = std::get<N>(r).end(); *std::get<N>(i) = std::get<N>(r)->end();
std::get<N>(i) -= 1; *std::get<N>(i) -= 1;
IndexSetter<N-1>::setEnd(i,r); IndexSetter<N-1>::setEnd(i,r);
} }
}; };
@ -256,16 +256,16 @@ namespace MultiArrayTools
struct IndexSetter<0> struct IndexSetter<0>
{ {
template <class... Ranges> template <class... Ranges>
static void setBegin(std::tuple<typename Ranges::IndexType...>& i, const std::tuple<Ranges...>& r) static void setBegin(MultiRange<Ranges...>::IndexType& i, const MultiRange<Ranges...>::SpaceType& r)
{ {
std::get<0>(i) = std::get<0>(r).begin(); *std::get<0>(i) = std::get<0>(r)->begin();
} }
template <class... Ranges> template <class... Ranges>
static void setEnd(std::tuple<typename Ranges::IndexType...>& i, const std::tuple<Ranges...>& r) static void setEnd(MultiRange<Ranges...>::IndexType& i, const MultiRange<Ranges...>::SpaceType& r)
{ {
std::get<0>(i) = std::get<0>(r).end(); *std::get<0>(i) = std::get<0>(r)->end();
std::get<0>(i) -= 1; *std::get<0>(i) -= 1;
} }
}; };
@ -273,9 +273,9 @@ namespace MultiArrayTools
struct RangeVecBuilder struct RangeVecBuilder
{ {
template <class... Ranges> template <class... Ranges>
static void buildRangeVec(std::vector<MultiRangeType>& rvec, const std::tuple<Ranges...>& rs) static void buildRangeVec(std::vector<MultiRangeType>& rvec, const MultiRange<Ranges...>::SpaceType& rs)
{ {
rvec.push_back(std::get<sizeof...(Ranges)-N-1>(rs).type()); rvec.push_back(std::get<sizeof...(Ranges)-N-1>(rs)->type());
RangeVecBuilder<N-1>::buildRangeVec(rvec, rs); RangeVecBuilder<N-1>::buildRangeVec(rvec, rs);
} }
}; };
@ -283,20 +283,20 @@ namespace MultiArrayTools
struct RangeVecBuilder<0> struct RangeVecBuilder<0>
{ {
template <class... Ranges> template <class... Ranges>
static void buildRangeVec(std::vector<MultiRangeType>& rvec, const std::tuple<Ranges...>& rs) static void buildRangeVec(std::vector<MultiRangeType>& rvec, const MultiRange<Ranges...>::SpaceType& rs)
{ {
rvec.push_back(std::get<sizeof...(Ranges)-1>(rs).type()); rvec.push_back(std::get<sizeof...(Ranges)-1>(rs)->type());
} }
}; };
// HERE !!!
template <size_t N> template <size_t N>
struct MetaPosGetter struct MetaPosGetter
{ {
template <class... Indices> template <class... Indices>
static void getMetaPos(std::tuple<decltype(Indices().getMetaPos())...>& target, static void getMetaPos(std::tuple<decltype(Indices().getMetaPos())...>& target,
const std::tuple<Indices...>& source) const typename MultiIndex<Indices...>::IndexPack& source)
{ {
std::get<N>(target) = std::get<N>(source).getMetaPos(); std::get<N>(target) = std::get<N>(source)->getMetaPos();
MetaPosGetter<N-1>::getMetaPos(target, source); MetaPosGetter<N-1>::getMetaPos(target, source);
} }
}; };
@ -306,9 +306,9 @@ namespace MultiArrayTools
{ {
template <class... Indices> template <class... Indices>
static void getMetaPos(std::tuple<decltype(Indices().getMetaPos())...>& target, static void getMetaPos(std::tuple<decltype(Indices().getMetaPos())...>& target,
const std::tuple<Indices...>& source) const typename MultiIndex<Indices...>::IndexPack& source)
{ {
std::get<0>(target) = std::get<0>(source).getMetaPos(); std::get<0>(target) = std::get<0>(source)->getMetaPos();
} }
}; };
@ -527,55 +527,18 @@ namespace MultiArrayTools
} }
template <class... Indices> template <class... Indices>
bool MultiIndex<Indices...>::link(IndefinitIndexBase* toLink) template <size_t N>
auto getIndex() -> decltype(*std::get<N>(mIPack))&
//typename std::tuple_element<N, std::tuple<Indices...> >::type& MultiIndex<Indices...>::getIndex()
{ {
if(toLink->rangeType() != rangeType() and return *std::get<N>(mIPack);
toLink->name() == IIB::name() and
not (IIB::name() == "master")){
// throw !!
assert(0);
}
if(toLink->rangeType() == rangeType() and toLink->name() == IIB::name()){
if(IIB::mLinked == toLink or IIB::mSoftLinked == toLink){
return true; // dont link twice the same
}
else if(IIB::mLinked == nullptr and IIB::mSoftLinked == nullptr){
IIB::mLinked = toLink;
return true;
}
else {
if(IIB::mLinked == nullptr){
return IIB::mSoftLinked->link(toLink);
}
else {
return IIB::mLinked->link(toLink);
}
}
}
else {
if(linkLower(toLink)){
IIB::mSoftLinked = IIB::mLinked;
IIB::mLinked = nullptr;
return true;
}
else {
return false;
}
}
} }
template <class... Indices> template <class... Indices>
template <size_t N> template <size_t N>
typename std::tuple_element<N, std::tuple<Indices...> >::type& MultiIndex<Indices...>::getIndex() auto getIndex() const -> const decltype(*std::get<N>(mIPack))&
{ {
return std::get<N>(mIPack); return *std::get<N>(mIPack);
}
template <class... Indices>
template <size_t N>
typename std::tuple_element<N, std::tuple<Indices...> >::type const& MultiIndex<Indices...>::getIndex() const
{
return std::get<N>(mIPack);
} }
template <class... Indices> template <class... Indices>
@ -615,49 +578,12 @@ namespace MultiArrayTools
return *this; return *this;
} }
template <class... Indices>
bool MultiIndex<Indices...>::linkLower(IndefinitIndexBase* toLink)
{
bool res = false;
for(size_t i = 0; i != sizeof...(Indices); ++i){
res |= get(i).link(toLink);
}
return res;
}
template <class... Indices>
void MultiIndex<Indices...>::linkTo(IndefinitIndexBase* target)
{
target->link(this);
for(size_t i = 0; i != sizeof...(Indices); ++i){
get(i).linkTo(target);
}
}
template <class... Indices> template <class... Indices>
void MultiIndex<Indices...>::copyPos(const MultiIndex<Indices...>& in) void MultiIndex<Indices...>::copyPos(const MultiIndex<Indices...>& in)
{ {
PositionCopy<sizeof...(Indices)-1>::copyPos(*this, in); PositionCopy<sizeof...(Indices)-1>::copyPos(*this, in);
} }
template <class... Indices>
IndefinitIndexBase* MultiIndex<Indices...>::getLinked(const std::string& name)
{
if(name == IIB::mName){
return this;
}
for(size_t i = 0; i != sizeof...(Indices); ++i){
IndefinitIndexBase* iibPtr = get(i).getLinked(name);
if(iibPtr != nullptr){
//CHECK;
return iibPtr;
}
}
//CHECK;
return nullptr;
}
template <class... Indices> template <class... Indices>
size_t MultiIndex<Indices...>::giveSubStepSize(IndefinitIndexBase* subIndex) size_t MultiIndex<Indices...>::giveSubStepSize(IndefinitIndexBase* subIndex)
{ {
@ -703,23 +629,25 @@ namespace MultiArrayTools
******************/ ******************/
template <class... Ranges> template <class... Ranges>
MultiRange<Ranges...>::MultiRange(const Ranges&... rs) : mSpace(std::make_tuple(rs...)) {} MultiRange<Ranges...>::MultiRange(const std::shared_ptr<Ranges>&... rs) : mSpace(std::make_tuple(rs...)) {}
template <class... Ranges> template <class... Ranges>
MultiRange<Ranges...>::MultiRange(const SpaceType& space) : mSpace(space) {} MultiRange<Ranges...>::MultiRange(const SpaceType& space) : mSpace(space) {}
template <class... Ranges> template <class... Ranges>
template <size_t N> template <size_t N>
typename std::tuple_element<N, std::tuple<Ranges...> >::type& MultiRange<Ranges...>::getRange() auto getRange() -> decltype(*std::get<N>(mSpace))&
//typename std::tuple_element<N, std::tuple<Ranges...> >::type& MultiRange<Ranges...>::getRange()
{ {
return std::get<N>(mSpace); return *std::get<N>(mSpace);
} }
template <class... Ranges> template <class... Ranges>
template <size_t N> template <size_t N>
typename std::tuple_element<N, std::tuple<Ranges...> >::type const& MultiRange<Ranges...>::getRange() const auto getRange() const -> const decltype(*std::get<N>(mSpace))&
//typename std::tuple_element<N, std::tuple<Ranges...> >::type const& MultiRange<Ranges...>::getRange() const
{ {
return std::get<N>(mSpace); return *std::get<N>(mSpace);
} }
template <class... Ranges> template <class... Ranges>
@ -745,7 +673,7 @@ namespace MultiArrayTools
template <class... Ranges> template <class... Ranges>
MultiIndex<typename Ranges::IndexType...> MultiRange<Ranges...>::begin() const MultiIndex<typename Ranges::IndexType...> MultiRange<Ranges...>::begin() const
{ {
std::tuple<typename Ranges::IndexType...> is; std::tuple<std::shared_ptr<typename Ranges::IndexType>...> is;
IndexSetter<sizeof...(Ranges)-1>::setBegin(is,mSpace); IndexSetter<sizeof...(Ranges)-1>::setBegin(is,mSpace);
return MultiIndex<typename Ranges::IndexType...>(this, is); return MultiIndex<typename Ranges::IndexType...>(this, is);
} }
@ -753,7 +681,7 @@ namespace MultiArrayTools
template <class... Ranges> template <class... Ranges>
MultiIndex<typename Ranges::IndexType...> MultiRange<Ranges...>::end() const MultiIndex<typename Ranges::IndexType...> MultiRange<Ranges...>::end() const
{ {
std::tuple<typename Ranges::IndexType...> is; std::tuple<std::shared_ptr<typename Ranges::IndexType>...> is;
IndexSetter<sizeof...(Ranges)-1>::setEnd(is,mSpace); IndexSetter<sizeof...(Ranges)-1>::setEnd(is,mSpace);
return ++MultiIndex<typename Ranges::IndexType...>(this, is); return ++MultiIndex<typename Ranges::IndexType...>(this, is);
} }

42
src/multi_range.h
View file

@ -5,6 +5,7 @@
#include <cstdlib> #include <cstdlib>
#include <tuple> #include <tuple>
#include <memory>
#include "base_def.h" #include "base_def.h"
#include "range_base.h" #include "range_base.h"
@ -17,9 +18,9 @@ namespace MultiArrayTools
class MultiIndex : public IndexBase<MultiIndex<Indices...> > class MultiIndex : public IndexBase<MultiIndex<Indices...> >
{ {
public: public:
typedef std::tuple<Indices...> IndexPack; typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
typedef IndefinitIndexBase IIB; typedef IndefinitIndexBase IIB;
typedef IndexBase<MultiIndex<Indices...> > IB; typedef IndexBase<MultiIndex<std::shared_ptr<Indices>...> > IB;
typedef std::tuple<decltype(Indices().getMetaPos())...> MetaType; typedef std::tuple<decltype(Indices().getMetaPos())...> MetaType;
protected: protected:
@ -38,12 +39,12 @@ namespace MultiArrayTools
MultiIndex(const MultiIndex& in); MultiIndex(const MultiIndex& in);
MultiIndex& operator=(const MultiIndex& in); MultiIndex& operator=(const MultiIndex& in);
MultiIndex(RangeBase<MultiIndex<Indices...> > const* range); MultiIndex(RangeBase<MultiIndex<std::shared_ptr<Indices>...> > const* range);
MultiIndex(RangeBase<MultiIndex<Indices...> > const* range, MultiIndex(RangeBase<MultiIndex<std::shared_ptr<Indices>...> > const* range,
Indices&&... inds); Indices&&... inds);
MultiIndex(RangeBase<MultiIndex<Indices...> > const* range, MultiIndex(RangeBase<MultiIndex<std::shared_ptr<Indices>...> > const* range,
const IndexPack& ipack); const IndexPack& ipack);
//virtual ~MultiIndex(); //virtual ~MultiIndex();
@ -60,10 +61,12 @@ namespace MultiArrayTools
virtual MultiRangeType rangeType() const override; virtual MultiRangeType rangeType() const override;
template <size_t N> template <size_t N>
typename std::tuple_element<N, std::tuple<Indices...> >::type& getIndex(); auto getIndex() ->;
//typename std::tuple_element<N, std::tuple<std::shared_ptr<Indices>...> >::type& getIndex();
template <size_t N> template <size_t N>
typename std::tuple_element<N, std::tuple<Indices...> >::type const& getIndex() const; auto getIndex() const ->;
//typename std::tuple_element<N, std::tuple<std::shared_ptr<Indices>...> >::type const& getIndex() const;
IndefinitIndexBase& get(size_t n); IndefinitIndexBase& get(size_t n);
const IndefinitIndexBase& get(size_t n) const; const IndefinitIndexBase& get(size_t n) const;
@ -79,12 +82,8 @@ namespace MultiArrayTools
// dimension of MultiRange; includes ALL degrees of freedom // dimension of MultiRange; includes ALL degrees of freedom
virtual size_t dim() const override; virtual size_t dim() const override;
virtual bool link(IndefinitIndexBase* toLink) override; virtual void copyPos(const MultiIndex<std::shared_ptr<Indices>...>& in) override;
virtual void linkTo(IndefinitIndexBase* target) override;
virtual void copyPos(const MultiIndex<Indices...>& in) override;
virtual IndefinitIndexBase* getLinked(const std::string& name) override;
virtual size_t giveSubStepSize(IndefinitIndexBase* subIndex) override; virtual size_t giveSubStepSize(IndefinitIndexBase* subIndex) override;
//virtual void eval() override; //virtual void eval() override;
@ -102,23 +101,24 @@ namespace MultiArrayTools
{ {
public: public:
typedef std::tuple<Ranges...> SpaceType; typedef std::tuple<std::shared_ptr<Ranges>...> SpaceType;
typedef typename RangeBase<MultiIndex<typename Ranges::IndexType...> >::IndexType IndexType; typedef typename RangeBase<MultiIndex<typename Ranges::IndexType...> >::IndexType
IndexType;
DEFAULT_MEMBERS(MultiRange); DEFAULT_MEMBERS(MultiRange);
MultiRange(const Ranges&... rs); MultiRange(const std::shared_ptr<Ranges>&... rs);
MultiRange(const SpaceType& space); MultiRange(const SpaceType& space);
static const size_t dim = sizeof...(Ranges); static const size_t dim = sizeof...(Ranges);
static MultiRange<Ranges...> oType() { return MultiRange<Ranges...>(); } template <size_t N> // !!! return ref to range, not the corresp. shared ptr
auto getRange() -> ;
template <size_t N> //typename std::tuple_element<N, std::tuple<std::shared_ptr<Ranges>...> >::type& getRange();
typename std::tuple_element<N, std::tuple<Ranges...> >::type& getRange();
template <size_t N> template <size_t N> // !!!
typename std::tuple_element<N, std::tuple<Ranges...> >::type const& getRange() const; auto getRange() const ->;
//typename std::tuple_element<N, std::tuple<std::shared_ptr<Ranges>...> >::type const& getRange() const;
size_t size() const override; size_t size() const override;
const SpaceType& space() const; const SpaceType& space() const;

19
src/single_range.cc
View file

@ -347,31 +347,12 @@ namespace MultiArrayTools
return in.pos(); return in.pos();
} }
template <typename U, RangeType TYPE>
void SingleIndex<U,TYPE>::linkTo(IndefinitIndexBase* target)
{
target->link(this);
}
template <typename U, RangeType TYPE> template <typename U, RangeType TYPE>
void SingleIndex<U,TYPE>::copyPos(const SingleIndex<U,TYPE>& in) void SingleIndex<U,TYPE>::copyPos(const SingleIndex<U,TYPE>& in)
{ {
IIB::setPos(in.pos()); IIB::setPos(in.pos());
} }
template <typename U, RangeType TYPE>
IndefinitIndexBase* SingleIndex<U,TYPE>::getLinked(const std::string& name)
{
//VCHECK(name);
//VCHECK(IIB::mName);
if(name == IIB::mName){
return this;
}
else {
return nullptr;
}
}
template <typename U, RangeType TYPE> template <typename U, RangeType TYPE>
size_t SingleIndex<U,TYPE>::giveSubStepSize(IndefinitIndexBase* subIndex) size_t SingleIndex<U,TYPE>::giveSubStepSize(IndefinitIndexBase* subIndex)
{ {

3
src/single_range.h
View file

@ -47,11 +47,8 @@ namespace MultiArrayTools
virtual SingleIndex& atMeta(const U& metaPos); virtual SingleIndex& atMeta(const U& metaPos);
virtual size_t dim() const override; // = 1 virtual size_t dim() const override; // = 1
virtual void linkTo(IndefinitIndexBase* target) override;
virtual void copyPos(const SingleIndex& in) override; virtual void copyPos(const SingleIndex& in) override;
virtual IndefinitIndexBase* getLinked(const std::string& name) override;
virtual size_t giveSubStepSize(IndefinitIndexBase* subIndex) override; virtual size_t giveSubStepSize(IndefinitIndexBase* subIndex) override;
//virtual void eval() override; //virtual void eval() override;