bugfix + continue prev com
This commit is contained in:
Christian Zimmermann
parent
482a7a7b4e
commit
43e8486354
7 changed files with 126 additions and 297 deletions
|
|
@ -114,11 +114,8 @@ namespace MultiArrayTools
|
|||
|
||||
namespace
|
||||
{
|
||||
template <size_t N>
|
||||
template <size_t N, class... Indices>
|
||||
struct Create
|
||||
{
|
||||
template <class... Indices>
|
||||
struct cx
|
||||
{
|
||||
template <class ROP, class OpF, class... OPs>
|
||||
struct ccx
|
||||
|
|
@ -131,65 +128,39 @@ namespace MultiArrayTools
|
|||
const OPs&... ops,
|
||||
const DOPs&... dops)
|
||||
{
|
||||
static_assert(N > 0, "N > 0 failed");
|
||||
//static_assert(N > 0, "N > 0 failed");
|
||||
auto& inn = std::get<N>(in);
|
||||
if(not inn->root()){
|
||||
auto dop = inn->create(inds...);
|
||||
auto op = *dop.op.data()->mOp;
|
||||
typedef decltype(op) OP;
|
||||
res.appendOuter(dop);
|
||||
assert(dop.op.init());
|
||||
Create<N-1>::template cx<Indices...>::template ccx<ROP,OpF,OP,OPs...>::template cccx<M>
|
||||
if constexpr(N > 0){
|
||||
typedef decltype(op) OP;
|
||||
Create<N-1,Indices...>::template ccx<ROP,OpF,OP,OPs...>::template cccx<M>
|
||||
(res, in, inds..., op, ops..., dop, dops...);
|
||||
}
|
||||
else {
|
||||
res.op = mkDynOutOp(mkFOp<OpF>(op,ops...), inds...);
|
||||
res.appendOuterM(dop.op,dops.op...);
|
||||
}
|
||||
}
|
||||
else {
|
||||
auto op = inn->get();
|
||||
auto vop = inn->vget();
|
||||
if constexpr(N > 0){
|
||||
typedef typename std::remove_reference<decltype(*op)>::type OP;
|
||||
typedef typename std::remove_reference<decltype(*vop)>::type VOP;
|
||||
if(op != nullptr){
|
||||
Create<N-1>::template cx<Indices...>::template ccx<ROP,OpF,OP,OPs...>::template cccx<M>
|
||||
Create<N-1,Indices...>::template ccx<ROP,OpF,OP,OPs...>::template cccx<M>
|
||||
(res, in, inds..., *op, ops..., dops...);
|
||||
}
|
||||
else {
|
||||
Create<N-1>::template cx<Indices...>::template ccx<ROP,OpF,VOP,OPs...>::template cccx<M>
|
||||
Create<N-1,Indices...>::template ccx<ROP,OpF,VOP,OPs...>::template cccx<M>
|
||||
(res, in, inds..., *vop, ops..., dops...);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Create<0>
|
||||
{
|
||||
template <class... Indices>
|
||||
struct cx
|
||||
{
|
||||
template <class ROP, class OpF, class... OPs>
|
||||
struct ccx
|
||||
{
|
||||
template <size_t M, class... DOPs>
|
||||
static inline void
|
||||
cccx(typename HighLevelOpBase<ROP>::template RetT<Indices...>& res,
|
||||
const std::array<std::shared_ptr<HighLevelOpBase<ROP>>,M>& in,
|
||||
const std::shared_ptr<Indices>&... inds,
|
||||
const OPs&... ops,
|
||||
const DOPs&... dops)
|
||||
{
|
||||
auto& inn = std::get<0>(in);
|
||||
if(not inn->root()){
|
||||
auto dop = inn->create(inds...);
|
||||
auto op = *dop.op.data()->mOp;
|
||||
res.appendOuter(dop);
|
||||
res.op = mkDynOutOp(mkFOp<OpF>(op,ops...), inds...);
|
||||
assert(dop.op.init());
|
||||
res.appendOuterM(dop.op,dops.op...);
|
||||
}
|
||||
else {
|
||||
auto op = inn->get();
|
||||
auto vop = inn->vget();
|
||||
if(op != nullptr){
|
||||
res.op = mkDynOutOp(mkFOp<OpF>(*op,ops...), inds...);
|
||||
}
|
||||
|
|
@ -199,9 +170,10 @@ namespace MultiArrayTools
|
|||
res.appendOuterM(dops.op...);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <class ROP, class OpF, size_t N>
|
||||
|
|
@ -234,7 +206,7 @@ namespace MultiArrayTools
|
|||
-> typename B::template RetT<Inds...>
|
||||
{
|
||||
typename B::template RetT<Inds...> res;
|
||||
Create<N-1>::template cx<Inds...>::template ccx<ROP,OpF>::template cccx<N>
|
||||
Create<N-1,Inds...>::template ccx<ROP,OpF>::template cccx<N>
|
||||
(res,mIn,inds...);
|
||||
return res;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -87,41 +87,31 @@ namespace MultiArrayTools
|
|||
return std::make_shared<ExtT<ExtType>>(mExt);
|
||||
}
|
||||
|
||||
// -> define in range_base.cc
|
||||
//std::shared_ptr<RangeFactoryBase> mkMULTI(const char** dp);
|
||||
|
||||
/******************
|
||||
* MapIndex *
|
||||
******************/
|
||||
|
||||
/*
|
||||
template <class MapF, class... Indices>
|
||||
MapIndex<MapF,Indices...>::MapIndex(const MapIndex<MapF,Indices...>& in) :
|
||||
IndexInterface<std::tuple<typename Indices::MetaType...> >(in)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::copy(mIPack, in);
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
}
|
||||
|
||||
template <class MapF, class... Indices>
|
||||
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::operator=(const MapIndex<MapF,Indices...>& in)
|
||||
{
|
||||
IndexI::operator=(in);
|
||||
RPackNum<sizeof...(Indices)-1>::copy(mIPack, in);
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
return *this;
|
||||
}
|
||||
*/
|
||||
|
||||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
template <class MRange>
|
||||
GenMapIndex<OIType,Op,XSTYPE,Indices...>::GenMapIndex(const std::shared_ptr<MRange>& range) :
|
||||
IndexInterface<GenMapIndex<OIType,Op,XSTYPE,Indices...>,typename Op::value_type>(range, 0)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::construct(mIPack, *range);
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
std::get<sizeof...(Indices)>(mBlockSizes) = 1;
|
||||
RPackNum<sizeof...(Indices)-1>::initBlockSizes(mBlockSizes, mIPack); // has one more element!
|
||||
sfor_mn<sizeof...(Indices),0>
|
||||
( [&](auto i) {
|
||||
auto r = range->template getPtr<i>();
|
||||
std::get<i>(mIPack) = r->beginPtr();
|
||||
*std::get<i>(mIPack) = 0;
|
||||
|
||||
std::get<i>(mBlockSizes) = sfor_p<i,sizeof...(Indices)>
|
||||
( [&](auto j) { return std::get<j>(mIPack)->max(); } ,
|
||||
[&](auto a, auto b) { return a * b; });
|
||||
return 0;
|
||||
});
|
||||
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
mOutIndex = std::make_shared<OIType>
|
||||
( std::dynamic_pointer_cast<RangeType>( IB::mRangePtr )->outRange()->begin() );
|
||||
}
|
||||
|
|
@ -185,7 +175,18 @@ namespace MultiArrayTools
|
|||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
GenMapIndex<OIType,Op,XSTYPE,Indices...>& GenMapIndex<OIType,Op,XSTYPE,Indices...>::operator()(const std::shared_ptr<Indices>&... indices)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices...);
|
||||
//RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices...);
|
||||
//RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, IB::mPos);
|
||||
return (*this)(std::make_tuple(indices...));
|
||||
//return *this;
|
||||
}
|
||||
|
||||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
GenMapIndex<OIType,Op,XSTYPE,Indices...>& GenMapIndex<OIType,Op,XSTYPE,Indices...>::operator()(const std::tuple<std::shared_ptr<Indices>...>& indices)
|
||||
{
|
||||
sfor_pn<0,sizeof...(Indices)>
|
||||
( [&](auto i) { std::get<i>(mIPack) = std::get<i>(indices); return 0; } );
|
||||
//RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices...);
|
||||
RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, IB::mPos);
|
||||
return *this;
|
||||
}
|
||||
|
|
@ -245,17 +246,12 @@ namespace MultiArrayTools
|
|||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
typename GenMapIndex<OIType,Op,XSTYPE,Indices...>::MetaType GenMapIndex<OIType,Op,XSTYPE,Indices...>::meta() const
|
||||
{
|
||||
//MetaType metaTuple;
|
||||
//RPackNum<sizeof...(Indices)-1>::getMetaPos(metaTuple, mIPack);
|
||||
//assert(0);
|
||||
return mOutIndex->meta();
|
||||
}
|
||||
|
||||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
GenMapIndex<OIType,Op,XSTYPE,Indices...>& GenMapIndex<OIType,Op,XSTYPE,Indices...>::at(const MetaType& metaPos)
|
||||
{
|
||||
//RPackNum<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
|
||||
//IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
mOutIndex->at(metaPos);
|
||||
IB::mPos = mOutIndex->pos();
|
||||
return *this;
|
||||
|
|
@ -309,30 +305,9 @@ namespace MultiArrayTools
|
|||
return mBlockSizes[n+1];
|
||||
}
|
||||
|
||||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
std::string GenMapIndex<OIType,Op,XSTYPE,Indices...>::id() const
|
||||
{
|
||||
return std::string("mul") + std::to_string(IB::mId);
|
||||
}
|
||||
|
||||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
void GenMapIndex<OIType,Op,XSTYPE,Indices...>::print(size_t offset) const
|
||||
{
|
||||
if(offset == 0){
|
||||
std::cout << " === " << std::endl;
|
||||
}
|
||||
for(size_t j = 0; j != offset; ++j) { std::cout << "\t"; }
|
||||
std::cout << id() << "[" << reinterpret_cast<std::intptr_t>(this)
|
||||
<< "]" << "(" << IB::mRangePtr << "): " << meta() << std::endl;
|
||||
RPackNum<sizeof...(Indices)-1>::printIndex(mIPack, offset+1);
|
||||
}
|
||||
|
||||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
template <class Exprs>
|
||||
auto GenMapIndex<OIType,Op,XSTYPE,Indices...>::ifor(size_t step, Exprs exs) const
|
||||
-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh
|
||||
(step, mIPack, mBlockSizes, OpExpr<Op,GenMapIndex<OIType,Op,XSTYPE,Indices...>,Exprs,XSTYPE>
|
||||
( range()->map(), this, step, exs ) ) )
|
||||
{
|
||||
return RPackNum<sizeof...(Indices)-1>::mkForh
|
||||
(0, mIPack, mBlockSizes, OpExpr<Op,GenMapIndex<OIType,Op,XSTYPE,Indices...>,Exprs,XSTYPE>
|
||||
|
|
@ -342,7 +317,6 @@ namespace MultiArrayTools
|
|||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
template <class Exprs>
|
||||
auto GenMapIndex<OIType,Op,XSTYPE,Indices...>::pifor(size_t step, Exprs exs) const
|
||||
-> decltype(ifor(step, exs))
|
||||
{
|
||||
return ifor(step, exs);
|
||||
}
|
||||
|
|
@ -350,7 +324,6 @@ namespace MultiArrayTools
|
|||
template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
|
||||
template <class Exprs>
|
||||
auto GenMapIndex<OIType,Op,XSTYPE,Indices...>::iforh(size_t step, Exprs exs) const
|
||||
-> decltype(ifor(step, exs))
|
||||
{
|
||||
return ifor(step, exs);
|
||||
}
|
||||
|
|
@ -600,7 +573,6 @@ namespace MultiArrayTools
|
|||
size_t GenMapRange<ORType,Op,XSTYPE,Ranges...>::size() const
|
||||
{
|
||||
return mOutRange->size();
|
||||
//return RPackNum<sizeof...(Ranges)-1>::getSize(mSpace);
|
||||
}
|
||||
|
||||
template <class ORType, class Op, SpaceType XSTYPE, class... Ranges>
|
||||
|
|
@ -629,7 +601,6 @@ namespace MultiArrayTools
|
|||
//MetaType* xtarget = reinterpret_cast<MetaType*>(target);
|
||||
assert(0);
|
||||
return 0;
|
||||
//return RPackNum<sizeof...(Ranges)-1>::getCMeta(xtarget,pos,mSpace,cmetaSize());
|
||||
}
|
||||
|
||||
template <class ORType, class Op, SpaceType XSTYPE, class... Ranges>
|
||||
|
|
|
|||
|
|
@ -164,6 +164,7 @@ namespace MultiArrayTools
|
|||
// NO foreign/external controll)
|
||||
// Do NOT share index instances between two or more MapIndex instances
|
||||
GenMapIndex& operator()(const std::shared_ptr<Indices>&... indices);
|
||||
GenMapIndex& operator()(const std::tuple<std::shared_ptr<Indices>...>& indices);
|
||||
|
||||
// ==== >>>>> STATIC POLYMORPHISM <<<<< ====
|
||||
|
||||
|
|
@ -192,23 +193,14 @@ namespace MultiArrayTools
|
|||
|
||||
size_t getStepSize(size_t n) const;
|
||||
|
||||
std::string id() const;
|
||||
void print(size_t offset) const;
|
||||
template <class Exprs>
|
||||
auto ifor(size_t step, Exprs exs) const; // first step arg not used!
|
||||
|
||||
template <class Exprs>
|
||||
auto ifor(size_t step, Exprs exs) const
|
||||
-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh
|
||||
(step, mIPack, mBlockSizes, OpExpr<Op,GenMapIndex,Exprs,XSTYPE>( range()->map(), this, step, exs ) ) );
|
||||
// first step arg not used!
|
||||
auto pifor(size_t step, Exprs exs) const; // NO MULTITHREADING
|
||||
|
||||
template <class Exprs>
|
||||
auto pifor(size_t step, Exprs exs) const
|
||||
-> decltype(ifor(step, exs)); // NO MULTITHREADING
|
||||
|
||||
|
||||
template <class Exprs>
|
||||
auto iforh(size_t step, Exprs exs) const
|
||||
-> decltype(ifor(step, exs));
|
||||
auto iforh(size_t step, Exprs exs) const;
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -261,11 +253,7 @@ namespace MultiArrayTools
|
|||
typedef RangeBase RB;
|
||||
typedef std::tuple<std::shared_ptr<Ranges>...> Space;
|
||||
typedef GenMapIndex<typename ORType::IndexType,Op,XSTYPE,typename Ranges::IndexType...> IndexType;
|
||||
//typedef GenMapRange RangeType;
|
||||
//typedef SingleRange<typename Op::value_type,XSTYPE> ORType;
|
||||
//typedef SingleRangeFactory<typename Op::value_type,XSTYPE> ORFType;
|
||||
typedef typename Op::value_type MetaType;
|
||||
//typedef typename RangeInterface<MapIndex<typename Ranges::IndexType...> >::IndexType IndexType;
|
||||
|
||||
protected:
|
||||
GenMapRange() = delete;
|
||||
|
|
|
|||
|
|
@ -208,10 +208,22 @@ namespace MultiArrayTools
|
|||
IndexInterface<ContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
|
||||
mObjPtrNum(objPtrNum)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::construct(mIPack, *range);
|
||||
std::get<sizeof...(Indices)>(mBlockSizes) = 1;
|
||||
RPackNum<sizeof...(Indices)-1>::initBlockSizes(mBlockSizes, mIPack);
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
sfor_mn<sizeof...(Indices),0>
|
||||
( [&](auto i) {
|
||||
auto r = range->template getPtr<i>();
|
||||
std::get<i>(mIPack) = r->beginPtr();
|
||||
*std::get<i>(mIPack) = 0;
|
||||
|
||||
std::get<i>(mBlockSizes) = sfor_p<i,sizeof...(Indices)>
|
||||
( [&](auto j) { return std::get<j>(mIPack)->max(); } ,
|
||||
[&](auto a, auto b) { return a * b; });
|
||||
return 0;
|
||||
});
|
||||
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
|
||||
}
|
||||
|
||||
|
|
@ -223,9 +235,16 @@ namespace MultiArrayTools
|
|||
IndexInterface<ContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
|
||||
mObjPtrNum(objPtrNum)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::construct(mIPack, *range);
|
||||
mBlockSizes = blockSizes;
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
sfor_mn<sizeof...(Indices),0>
|
||||
( [&](auto i) {
|
||||
auto r = range->template getPtr<i>();
|
||||
std::get<i>(mIPack) = r->beginPtr();
|
||||
*std::get<i>(mIPack) = 0;
|
||||
return 0;
|
||||
});
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
|
||||
mNonTrivialBlocks = true;
|
||||
}
|
||||
|
|
@ -244,7 +263,9 @@ namespace MultiArrayTools
|
|||
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::sync()
|
||||
{
|
||||
if(mExternControl){
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -267,15 +288,14 @@ namespace MultiArrayTools
|
|||
template <typename T, class... Indices>
|
||||
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator()(const std::shared_ptr<Indices>&... inds)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, inds...);
|
||||
mExternControl = true;
|
||||
return sync();
|
||||
return (*this)(std::make_tuple(inds...));
|
||||
}
|
||||
|
||||
template <typename T, class... Indices>
|
||||
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator()(const std::tuple<std::shared_ptr<Indices>...>& inds)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, inds);
|
||||
sfor_pn<0,sizeof...(Indices)>
|
||||
( [&](auto i) { std::get<i>(mIPack) = std::get<i>(inds); return 0; } );
|
||||
mExternControl = true;
|
||||
return sync();
|
||||
}
|
||||
|
|
@ -293,7 +313,9 @@ namespace MultiArrayTools
|
|||
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator++()
|
||||
{
|
||||
if(mExternControl){
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
}
|
||||
sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) {
|
||||
|
|
@ -311,7 +333,9 @@ namespace MultiArrayTools
|
|||
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator--()
|
||||
{
|
||||
if(mExternControl){
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
}
|
||||
sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) {
|
||||
|
|
@ -361,14 +385,16 @@ namespace MultiArrayTools
|
|||
typename ContainerIndex<T,Indices...>::MetaType ContainerIndex<T,Indices...>::meta() const
|
||||
{
|
||||
MetaType metaTuple;
|
||||
RPackNum<sizeof...(Indices)-1>::getMetaPos(metaTuple, mIPack);
|
||||
sfor_pn<0,sizeof...(Indices)>
|
||||
( [&](auto i) { std::get<i>(metaTuple) = std::get<i>(mIPack)->meta(); return 0; } );
|
||||
return metaTuple;
|
||||
}
|
||||
|
||||
template <typename T, class... Indices>
|
||||
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::at(const MetaType& metaPos)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
|
||||
sfor_pn<0,sizeof...(Indices)>
|
||||
( [&](auto i) { std::get<i>(mIPack)->at( std::get<i>(metaPos) ); return 0; } );
|
||||
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
|
||||
return *this;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -247,7 +247,7 @@ namespace MultiArrayTools
|
|||
{
|
||||
sfor_p<0,sizeof...(Indices)>
|
||||
( [&](auto i) { std::get<i>(mIPack) = ci.template getPtr<i>(); return true; } );
|
||||
IB::mPos = sfor_p<0,sizeof...(Indices)>
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
return *this;
|
||||
|
|
@ -271,7 +271,7 @@ namespace MultiArrayTools
|
|||
return 0;
|
||||
});
|
||||
|
||||
IB::mPos = sfor_p<0,sizeof...(Indices)>
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
}
|
||||
|
|
@ -329,15 +329,14 @@ namespace MultiArrayTools
|
|||
template <class... Indices>
|
||||
MultiIndex<Indices...>& MultiIndex<Indices...>::operator()(std::shared_ptr<Indices>&... indices)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices...);
|
||||
RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, IB::mPos);
|
||||
return *this;
|
||||
return (*this)(std::make_tuple(indices...));
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MultiIndex<Indices...>& MultiIndex<Indices...>::operator()(const std::tuple<std::shared_ptr<Indices>...>& indices)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices);
|
||||
sfor_pn<0,sizeof...(Indices)>
|
||||
( [&](auto i) { std::get<i>(mIPack) = std::get<i>(indices); return 0; } );
|
||||
RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, IB::mPos);
|
||||
return *this;
|
||||
}
|
||||
|
|
@ -411,18 +410,19 @@ namespace MultiArrayTools
|
|||
typename MultiIndex<Indices...>::MetaType MultiIndex<Indices...>::meta() const
|
||||
{
|
||||
MetaType metaTuple;
|
||||
RPackNum<sizeof...(Indices)-1>::getMetaPos(metaTuple, mIPack);
|
||||
sfor_pn<0,sizeof...(Indices)>
|
||||
( [&](auto i) { std::get<i>(metaTuple) = std::get<i>(mIPack)->meta(); return 0; } );
|
||||
return metaTuple;
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MultiIndex<Indices...>& MultiIndex<Indices...>::at(const MetaType& metaPos)
|
||||
{
|
||||
RPackNum<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
|
||||
sfor_pn<0,sizeof...(Indices)>
|
||||
( [&](auto i) { std::get<i>(mIPack)->at( std::get<i>(metaPos) ); return 0; } );
|
||||
IB::mPos = sfor_m<sizeof...(Indices),0>
|
||||
( [&](auto i) { return std::get<i>(mIPack); },
|
||||
[&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
|
||||
//IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -33,15 +33,6 @@ namespace MultiArrayHelper
|
|||
v.insert(v.begin(), r);
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class... Indices>
|
||||
void RPackNum<N>::initBlockSizes(std::array<size_t,sizeof...(Indices)+1>& bs,
|
||||
std::tuple<std::shared_ptr<Indices>...>& ip)
|
||||
{
|
||||
std::get<N>(bs) = RPackNum<sizeof...(Indices)-N>::blockSize(ip);
|
||||
RPackNum<N-1>::initBlockSizes(bs, ip);
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class RangeTuple>
|
||||
size_t RPackNum<N>::getSize(const RangeTuple& rt)
|
||||
|
|
@ -49,23 +40,6 @@ namespace MultiArrayHelper
|
|||
return std::get<N>(rt)->size() * RPackNum<N-1>::getSize(rt);
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class IndexPack, class MetaType>
|
||||
void RPackNum<N>::getMetaPos(MetaType& target,
|
||||
const IndexPack& source)
|
||||
{
|
||||
std::get<N>(target) = std::get<N>(source)->meta();
|
||||
RPackNum<N-1>::getMetaPos(target, source);
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class IndexPack, typename MetaType>
|
||||
void RPackNum<N>::setMeta(IndexPack& target, const MetaType& source)
|
||||
{
|
||||
std::get<N>(target)->at( std::get<N>(source) );
|
||||
RPackNum<N-1>::setMeta(target, source);
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class SpaceClass>
|
||||
inline std::shared_ptr<RangeBase> RPackNum<N>::getSub(const SpaceClass& space, size_t num)
|
||||
|
|
@ -88,24 +62,6 @@ namespace MultiArrayHelper
|
|||
RPackNum<N-1>::setIndexPack(iPack, (pos - ownPos) / i.max() );
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class MRange, class... Indices>
|
||||
void RPackNum<N>::construct(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const MRange& range)
|
||||
{
|
||||
typedef typename std::remove_reference<decltype(range.template get<N>())>::type SubRangeType;
|
||||
typedef typename SubRangeType::IndexType SubIndexType;
|
||||
typedef typename std::remove_reference<decltype(*std::get<N>(ip).get())>::type TypeFromIndexPack;
|
||||
|
||||
static_assert(std::is_same<SubIndexType,TypeFromIndexPack>::value,
|
||||
"inconsistent types");
|
||||
|
||||
std::get<N>(ip) = std::shared_ptr<SubIndexType>( new SubIndexType( range.template getPtr<N>() ) );
|
||||
*std::get<N>(ip) = 0;
|
||||
//VCHECK(std::get<N>(ip)->max());
|
||||
RPackNum<N-1>::construct(ip, range);
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class IndexType, class... Indices>
|
||||
void RPackNum<N>::copyInst(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
|
|
@ -125,14 +81,6 @@ namespace MultiArrayHelper
|
|||
RPackNum<N-1>::copyIndex(ip, ind);
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class... Indices>
|
||||
inline size_t RPackNum<N>::makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup)
|
||||
{
|
||||
//const auto& idx = *std::get<N>(iPtrTup);
|
||||
return std::get<N>(iPtrTup)->pos() + RPackNum<N-1>::makePos(iPtrTup) * std::get<N>(iPtrTup)->max();
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
template <class... Indices>
|
||||
inline size_t RPackNum<N>::makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
|
||||
|
|
@ -337,32 +285,12 @@ namespace MultiArrayHelper
|
|||
|
||||
|
||||
|
||||
template <class... Indices>
|
||||
void RPackNum<0>::initBlockSizes(std::array<size_t,sizeof...(Indices)+1>& bs,
|
||||
std::tuple<std::shared_ptr<Indices>...>& ip)
|
||||
{
|
||||
std::get<0>(bs) = RPackNum<sizeof...(Indices)>::blockSize(ip);
|
||||
}
|
||||
|
||||
template <class RangeTuple>
|
||||
size_t RPackNum<0>::getSize(const RangeTuple& rt)
|
||||
{
|
||||
return std::get<0>(rt)->size();
|
||||
}
|
||||
|
||||
template <class IndexPack, class MetaType>
|
||||
void RPackNum<0>::getMetaPos(MetaType& target,
|
||||
const IndexPack& source)
|
||||
{
|
||||
std::get<0>(target) = std::get<0>(source)->meta();
|
||||
}
|
||||
|
||||
template <class IndexPack, typename MetaType>
|
||||
void RPackNum<0>::setMeta(IndexPack& target, const MetaType& source)
|
||||
{
|
||||
std::get<0>(target)->at( std::get<0>( source ) );
|
||||
}
|
||||
|
||||
template <class SpaceClass>
|
||||
inline std::shared_ptr<RangeBase> RPackNum<0>::getSub(const SpaceClass& space, size_t num)
|
||||
{
|
||||
|
|
@ -383,21 +311,6 @@ namespace MultiArrayHelper
|
|||
i = ownPos;
|
||||
}
|
||||
|
||||
template <class MRange, class... Indices>
|
||||
void RPackNum<0>::construct(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const MRange& range)
|
||||
{
|
||||
typedef typename std::remove_reference<decltype(range.template get<0>())>::type SubRangeType;
|
||||
typedef typename SubRangeType::IndexType SubIndexType;
|
||||
typedef typename std::remove_reference<decltype(*std::get<0>(ip).get())>::type TypeFromIndexPack;
|
||||
|
||||
static_assert(std::is_same<SubIndexType,TypeFromIndexPack>::value,
|
||||
"inconsistent types");
|
||||
|
||||
std::get<0>(ip) = std::shared_ptr<SubIndexType>( new SubIndexType( range.template getPtr<0>() ) );
|
||||
*std::get<0>(ip) = 0;
|
||||
}
|
||||
|
||||
template <class IndexType, class... Indices>
|
||||
void RPackNum<0>::copyInst(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const IndexType& ind)
|
||||
|
|
@ -413,12 +326,6 @@ namespace MultiArrayHelper
|
|||
std::get<0>(ip) = std::make_shared<SubType>( ind.template get<0>() ) ;
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
inline size_t RPackNum<0>::makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup)
|
||||
{
|
||||
return std::get<0>(iPtrTup)->pos();
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
inline size_t RPackNum<0>::makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
|
||||
const std::array<size_t,sizeof...(Indices)+1>& blockSize)
|
||||
|
|
|
|||
|
|
@ -101,30 +101,16 @@ namespace MultiArrayHelper
|
|||
template <size_t N>
|
||||
struct RPackNum
|
||||
{
|
||||
template <class... Indices>
|
||||
static void initBlockSizes(std::array<size_t,sizeof...(Indices)+1>& bs,
|
||||
std::tuple<std::shared_ptr<Indices>...>& ip);
|
||||
|
||||
template <class RangeTuple>
|
||||
static size_t getSize(const RangeTuple& rt);
|
||||
|
||||
template <class IndexPack, class MetaType>
|
||||
static void getMetaPos(MetaType& target,
|
||||
const IndexPack& source);
|
||||
|
||||
template <class IndexPack, typename MetaType>
|
||||
static void setMeta(IndexPack& target, const MetaType& source);
|
||||
|
||||
template <class SpaceClass>
|
||||
inline static std::shared_ptr<RangeBase> getSub(const SpaceClass& space, size_t num);
|
||||
|
||||
template <class IndexPack>
|
||||
static void setIndexPack(IndexPack& iPack, size_t pos);
|
||||
|
||||
template <class MRange, class... Indices>
|
||||
static void construct(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const MRange& range);
|
||||
|
||||
template <class IndexType, class... Indices>
|
||||
static void copyInst(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const IndexType& ind);
|
||||
|
|
@ -133,9 +119,6 @@ namespace MultiArrayHelper
|
|||
static void copyIndex(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const IndexType& ind);
|
||||
|
||||
template <class... Indices>
|
||||
static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup);
|
||||
|
||||
template <class... Indices>
|
||||
static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
|
||||
const std::array<size_t,sizeof...(Indices)+1>& blockSize);
|
||||
|
|
@ -222,30 +205,15 @@ namespace MultiArrayHelper
|
|||
struct RPackNum<0>
|
||||
{
|
||||
|
||||
template <class... Indices>
|
||||
static void initBlockSizes(std::array<size_t,sizeof...(Indices)+1>& bs,
|
||||
std::tuple<std::shared_ptr<Indices>...>& ip);
|
||||
|
||||
template <class RangeTuple>
|
||||
static size_t getSize(const RangeTuple& rt);
|
||||
|
||||
template <class IndexPack, class MetaType>
|
||||
static void getMetaPos(MetaType& target,
|
||||
const IndexPack& source);
|
||||
|
||||
template <class IndexPack, typename MetaType>
|
||||
static void setMeta(IndexPack& target, const MetaType& source);
|
||||
|
||||
template <class SpaceClass>
|
||||
inline static std::shared_ptr<RangeBase> getSub(const SpaceClass& space, size_t num);
|
||||
|
||||
template <class IndexPack>
|
||||
static void setIndexPack(IndexPack& iPack, size_t pos);
|
||||
|
||||
template <class MRange, class... Indices>
|
||||
static void construct(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const MRange& range);
|
||||
|
||||
template <class IndexType, class... Indices>
|
||||
static void copyInst(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const IndexType& ind);
|
||||
|
|
@ -254,9 +222,6 @@ namespace MultiArrayHelper
|
|||
static void copyIndex(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const IndexType& ind);
|
||||
|
||||
template <class... Indices>
|
||||
static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup);
|
||||
|
||||
template <class... Indices>
|
||||
static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
|
||||
const std::array<size_t,sizeof...(Indices)+1>& blockSize);
|
||||
|
|
|
|||
Loading…
Reference in a new issue