completely remove rpacknum

src/include/map_range.cc.h

@@ -606,7 +606,7 @@ namespace MultiArrayTools
     template <class ORType, class Op, SpaceType XSTYPE, class... Ranges>
     size_t GenMapRange<ORType,Op,XSTYPE,Ranges...>::cmetaSize() const
     {
-        return RPackNum<sizeof...(Ranges)-1>::getCMetaSize(mSpace);
+        return RangeHelper::getCMetaSize<0>(mSpace);
     }
 
     template <class ORType, class Op, SpaceType XSTYPE, class... Ranges>
@@ -614,7 +614,7 @@ namespace MultiArrayTools
     {
 	auto i = begin();
 	i = pos;
-        return "[ " + RPackNum<sizeof...(Ranges)-1>::getStringMeta(i) + " ]";
+        return "[ " + RangeHelper::getStringMeta<0>(i) + " ]";
     }
 
     template <class ORType, class Op, SpaceType XSTYPE, class... Ranges>
@@ -631,7 +631,6 @@ namespace MultiArrayTools
 		out.insert(out.end(), part.begin(), part.end());
 		return 0;
 	    } );
-	//RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
 	return out;
     }
 

src/include/map_range.h

@@ -12,7 +12,6 @@
 #include "ranges/range_base.h"
 #include "ranges/index_base.h"
 
-#include "ranges/rpack_num.h"
 #include "map_range_factory_product_map.h"
 #include "ranges/x_to_string.h"
 #include "ranges/type_map.h"
@@ -116,7 +115,7 @@ namespace MultiArrayTools
 	
 	static constexpr IndexType sType() { return IndexType::SINGLE; }
 	static constexpr size_t sDim() { return sizeof...(Indices); }
-	static constexpr size_t totalDim() { return mkTotalDim<Indices...>(); }
+	static constexpr size_t totalDim() { return (... * Indices::totalDim()); }
 	static void check_type() { static_assert( std::is_same<typename OIType::MetaType,typename Op::value_type>::value, "inconsitent value types" ); }
 	
         static constexpr SpaceType STYPE = XSTYPE;
@@ -329,8 +328,8 @@ namespace MultiArrayTools
 
 	static constexpr bool HASMETACONT = false;
 	static constexpr bool defaultable = false;
-	static constexpr size_t ISSTATIC = SubProp<Op,Ranges...>::ISSTATIC;
+	static constexpr size_t ISSTATIC = Op::ISSTATIC & (... & Ranges::ISSTATIC);
-	static constexpr size_t SIZE = SubProp<Op,Ranges...>::SIZE;
+	static constexpr size_t SIZE = Op::SIZE * (... * Ranges::SIZE);
     };
 
     // for legacy

src/include/multi_array_operation.cc.h

@@ -1,6 +1,7 @@
 
 #include "multi_array_operation.h"
 #include "xfor/exttype.h"
+#include "ranges/range_helper.h"
 
 
 /* ========================= *
@@ -380,8 +381,7 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     MExt<None> ConstOperationRoot<T,Ranges...>::rootSteps(std::intptr_t iPtrNum) const
     {
-	return MExt<None>(getStepSize( mIndex, iPtrNum ));
+	return MExt<None>(RangeHelper::getStepSize( mIndex, iPtrNum ));
-	//return MExt<None>(getStepSize( getRootIndices( mIndex->info() ), iPtrNum ));
     }
 
 
@@ -478,8 +478,7 @@ namespace MultiArrayTools
     template <class Range>
     MExt<None> MetaOperationRoot<Range>::rootSteps(std::intptr_t iPtrNum) const
     {
-	return MExt<None>(getStepSize( *mIndex, iPtrNum ));
+	return MExt<None>(RangeHelper::getStepSize( *mIndex, iPtrNum ));
-	//return MExt<None>(getStepSize( getRootIndices( mIndex->info() ), iPtrNum ));
     }
 
 
@@ -691,7 +690,7 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     MExt<None> OperationRoot<T,Ranges...>::rootSteps(std::intptr_t iPtrNum) const
     {
-	return MExt<None>(getStepSize( mIndex, iPtrNum ));
+	return MExt<None>(RangeHelper::getStepSize( mIndex, iPtrNum ));
     }
 
     template <typename T, class... Ranges>
@@ -868,8 +867,7 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     MExt<None> ParallelOperationRoot<T,Ranges...>::rootSteps(std::intptr_t iPtrNum) const
     {
-	return MExt<None>(getStepSize( mIndex, iPtrNum ));
+	return MExt<None>(RangeHelper::getStepSize( mIndex, iPtrNum ));
-	//return MExt<None>(getStepSize( mIndex.info(), iPtrNum ));
     }
 
     template <typename T, class... Ranges>

src/include/ranges/anonymous_range.h

@@ -187,24 +187,19 @@ namespace MultiArrayTools
 	    }
 	    rp = std::dynamic_pointer_cast<AnonymousRange>( arf.create() );
 	}
-    }
-}
-namespace MultiArrayHelper
-{
-    using namespace MultiArrayTools;
 
 
-    template <>
+	template <>
-    inline void setRangeToVec<AnonymousRange>(vector<std::shared_ptr<RangeBase> >& v,
+	inline void setRangeToVec<AnonymousRange>(vector<std::shared_ptr<RangeBase> >& v,
-					      std::shared_ptr<AnonymousRange> r)
+						  std::shared_ptr<AnonymousRange> r)
-    {
+	{
-	if(not r->isEmpty()){
+	    if(not r->isEmpty()){
-	    for(size_t i = r->anonymousDim(); i != 0; --i){
+		for(size_t i = r->anonymousDim(); i != 0; --i){
-		v.insert(v.begin(), r->sub(i-1));
+		    v.insert(v.begin(), r->sub(i-1));
+		}
 	    }
 	}
     }
-
 }
 
 namespace MultiArrayTools
@@ -255,7 +250,6 @@ namespace MultiArrayTools
     {
 	std::tuple<std::shared_ptr<Ranges>...> rtp;
 	RangeHelper::resolveRangeType<0>(mOrig, rtp, 0, sizes...);
-	//RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
 	MultiRangeFactory<Ranges...> mrf(rtp);
 	return std::dynamic_pointer_cast<MultiRange<Ranges...> >( mrf.create() );
     }

src/include/ranges/container_range.h

@@ -10,8 +10,6 @@
 #include "ranges/range_base.h"
 #include "ranges/index_base.h"
 
-#include "rpack_num.h"
-
 namespace MultiArrayTools
 {
     
@@ -30,7 +28,7 @@ namespace MultiArrayTools
 
 	static constexpr IndexType sType() { return IndexType::CONT; }
 	static constexpr size_t sDim() { return sizeof...(Indices); }
-	static constexpr size_t totalDim() { return mkTotalDim<Indices...>(); }
+	static constexpr size_t totalDim() { return (... * Indices::totalDim()); }
 
 	static constexpr SpaceType STYPE = SpaceType::ANY;
         static constexpr bool PARALLEL = std::tuple_element<0,std::tuple<Indices...>>::type::PARALLEL;
@@ -232,7 +230,7 @@ namespace MultiArrayTools
 	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);
+	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
     }
 
     template <typename T, class... Indices>
@@ -253,7 +251,7 @@ namespace MultiArrayTools
 	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);
+	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
 	mNonTrivialBlocks = true;
     }
 
@@ -274,7 +272,7 @@ namespace MultiArrayTools
 	    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);
+	    	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
 	}
 	return *this;
     }
@@ -332,7 +330,7 @@ namespace MultiArrayTools
 		else { ++si; return false; }
 		return false;
 	    } );
-	mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
+	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
 	++IB::mPos;
 	return *this;
     }
@@ -352,7 +350,7 @@ namespace MultiArrayTools
 		else { --si; return false; }
 		return false;
 	    } );
-	mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
+	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
 	--IB::mPos;
 	return *this;
 
@@ -363,14 +361,14 @@ namespace MultiArrayTools
     {
 	IB::mPos = pos;
 	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, pos);
-	mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
+	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
 	return *this;
     }
 
     template <typename T, class... Indices>
     int ContainerIndex<T,Indices...>::pp(std::intptr_t idxPtrNum)
     {
-	const int tmp = ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
+	const int tmp = RangeHelper::ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos += tmp;
 	return tmp;
     }
@@ -378,7 +376,7 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     int ContainerIndex<T,Indices...>::mm(std::intptr_t idxPtrNum)
     {
-	const int tmp = mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
+	const int tmp = RangeHelper::mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos -= tmp;
 	return tmp;
     }
@@ -403,7 +401,7 @@ namespace MultiArrayTools
     {
 	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);
+	IB::mPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
 	return *this;
     }
 

src/include/ranges/dynamic_range.cc.h

@@ -1,8 +1,5 @@
 
 #include "ranges/dynamic_range.h"
-//#include "ranges/dynamic_meta.h"
-
-//#include "rpack_num.h"
 
 namespace MultiArrayTools
 {
@@ -184,7 +181,6 @@ namespace MultiArrayTools
     {
 	std::tuple<std::shared_ptr<Ranges>...> rtp;
 	RangeHelper::resolveRangeType<0>(mOrig, rtp, 0, sizes...);
-	//RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
 	MultiRangeFactory<Ranges...> mrf(rtp);
 	return std::dynamic_pointer_cast<MultiRange<Ranges...> >( mrf.create() );
     }
@@ -209,43 +205,34 @@ namespace MultiArrayTools
 	    rp = std::dynamic_pointer_cast<DynamicRange>( arf.create() );
 	}
     
-    }
-}
 
-namespace MultiArrayHelper
+	template <>
-{
+	inline void setRangeToVec<DynamicRange>(vector<std::shared_ptr<RangeBase> >& v,
-    namespace
+						std::shared_ptr<DynamicRange> r)
-    {
+	{
-        using namespace MultiArrayTools;
+	    if(not r->isEmpty()){
-    }
+		for(size_t i = r->dim(); i != 0; --i){
-    
+		    v.insert(v.begin(), r->sub(i-1));
-
+		}
-    template <>
-    inline void setRangeToVec<DynamicRange>(vector<std::shared_ptr<RangeBase> >& v,
-                                            std::shared_ptr<DynamicRange> r)
-    {
-	if(not r->isEmpty()){
-	    for(size_t i = r->dim(); i != 0; --i){
-		v.insert(v.begin(), r->sub(i-1));
 	    }
 	}
-    }
 
-    template <>
+	template <>
-    inline size_t getStepSize<DynamicIndex>(const DynamicIndex& ii, std::intptr_t j)
+	inline size_t getStepSize<DynamicIndex>(const DynamicIndex& ii, std::intptr_t j)
-    {
+	{
-        size_t ss = 0;
+	    size_t ss = 0;
-        size_t sx = 1;
+	    size_t sx = 1;
-        for(size_t k = ii.dim(); k != 0; --k){
+	    for(size_t k = ii.dim(); k != 0; --k){
-	    const size_t i = k-1;
+		const size_t i = k-1;
-            const auto& ni = ii.get(i);
+		const auto& ni = ii.get(i);
-            const size_t max = ni.max();
+		const size_t max = ni.max();
-            const size_t tmp = ni.getStepSizeComp(j);
+		const size_t tmp = ni.getStepSizeComp(j);
-            ss += tmp * ii.getStepSize(i);
+		ss += tmp * ii.getStepSize(i);
-            sx *= max;
+		sx *= max;
-        }
+	    }
-        return ss;
+	    return ss;
-    }
 	
+	}
+    }
 }
 

src/include/ranges/dynamic_range.h

@@ -11,13 +11,11 @@
 
 #include "xfor/xfor.h"
 
-//#include "ranges/rpheader.h"
 #include "ranges/x_to_string.h"
 #include "ranges/type_map.h"
 #include "ranges/dynamic_meta.h"
 
 #include "index_wrapper.h"
-#include "rpack_num.h"
 
 namespace MultiArrayTools
 {
@@ -228,25 +226,23 @@ namespace MultiArrayTools
 } // namespace MultiArrayTools
 
 
-namespace MultiArrayHelper
+namespace MultiArrayTools
 {
-    namespace
+    namespace RangeHelper
     {
-        using namespace MultiArrayTools;
+
+	template <>
+	inline void resolveSetRange<DynamicRange>(std::shared_ptr<DynamicRange>& rp,
+						  const vector<std::shared_ptr<RangeBase> >& orig,
+						  size_t origpos, size_t size);
+
+	template <>
+	inline void setRangeToVec<DynamicRange>(vector<std::shared_ptr<RangeBase> >& v,
+						std::shared_ptr<DynamicRange> r);
+
+	template <>
+	inline size_t getStepSize<DynamicIndex>(const DynamicIndex& ii, std::intptr_t j);
     }
-
-    template <>
-    inline void resolveSetRange<DynamicRange>(std::shared_ptr<DynamicRange>& rp,
-                                              const vector<std::shared_ptr<RangeBase> >& orig,
-                                              size_t origpos, size_t size);
-
-    template <>
-    inline void setRangeToVec<DynamicRange>(vector<std::shared_ptr<RangeBase> >& v,
-                                            std::shared_ptr<DynamicRange> r);
-
-    template <>
-    inline size_t getStepSize<DynamicIndex>(const DynamicIndex& ii, std::intptr_t j);
-
 }
 
 //#include "dynamic_range.cc.h"

src/include/ranges/index_wrapper.cc.h

@@ -1,6 +1,6 @@
 
 #include "index_wrapper.h"
-#include "rpack_num.h"
+#include "range_helper.h"
 
 namespace MultiArrayTools
 {
@@ -117,9 +117,9 @@ namespace MultiArrayTools
     template <class Index>
     size_t IndexWrapper<Index>::getStepSizeComp(std::intptr_t j) const
     {
-        size_t out = MultiArrayHelper::getStepSize(*mI, j);
+        size_t out = RangeHelper::getStepSize(*mI, j);
 	if(out == 0){
-	    out = MultiArrayHelper::getStepSize(*mCI, j);
+	    out = RangeHelper::getStepSize(*mCI, j);
 	}
 	return out;
     }

src/include/ranges/multi_range.h

@@ -8,11 +8,9 @@
 #include <memory>
 #include <map>
 
-//#include "base_def.h"
 #include "ranges/range_base.h"
 #include "ranges/index_base.h"
 
-#include "ranges/rpack_num.h"
 #include "ranges/range_helper.h"
 #include "ranges/multi_range_factory_product_map.h"
 #include "ranges/x_to_string.h"
@@ -42,7 +40,7 @@ namespace MultiArrayTools
 
 	static constexpr IndexType sType() { return IndexType::MULTI; }
 	static constexpr size_t sDim() { return sizeof...(Indices); }
-	static constexpr size_t totalDim() { return mkTotalDim<Indices...>(); }
+	static constexpr size_t totalDim() { return (... * Indices::totalDim()); }
 
 	static constexpr SpaceType STYPE = SpaceType::ANY;
         static constexpr bool PARALLEL = std::tuple_element<0,std::tuple<Indices...>>::type::PARALLEL;
@@ -217,8 +215,8 @@ namespace MultiArrayTools
 
 	static constexpr bool HASMETACONT = false;
 	static constexpr bool defaultable = false;
-	static constexpr size_t ISSTATIC = SubProp<Ranges...>::ISSTATIC;
+	static constexpr size_t ISSTATIC = (... & Ranges::ISSTATIC);
-	static constexpr size_t SIZE = SubProp<Ranges...>::SIZE;
+	static constexpr size_t SIZE = (... * Ranges::SIZE);
     };
     
 }
@@ -388,7 +386,7 @@ namespace MultiArrayTools
     template <class... Indices>
     int MultiIndex<Indices...>::pp(std::intptr_t idxPtrNum)
     {
-	const int tmp = ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
+	const int tmp = RangeHelper::ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos += tmp;
 	return tmp;
     }
@@ -396,7 +394,7 @@ namespace MultiArrayTools
     template <class... Indices>
     int MultiIndex<Indices...>::mm(std::intptr_t idxPtrNum)
     {
-	const int tmp = mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
+	const int tmp = RangeHelper::mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos -= tmp;
 	return tmp;
     }
@@ -625,13 +623,13 @@ namespace MultiArrayTools
     {
         const size_t off = cmetaSize();
         MetaType* xtarget = reinterpret_cast<MetaType*>(target);
-        return RPackNum<sizeof...(Ranges)-1>::getCMeta(xtarget,pos,mSpace,off);
+        return RangeHelper::getCMeta<sizeof...(Ranges)-1>(xtarget,pos,mSpace,off);
     }
 
     template <class... Ranges>
     size_t MultiRange<Ranges...>::cmetaSize() const
     {
-        return RPackNum<sizeof...(Ranges)-1>::getCMetaSize(mSpace);
+        return RangeHelper::getCMetaSize<0>(mSpace);
     }
 
     template <class... Ranges>
@@ -639,7 +637,7 @@ namespace MultiArrayTools
     {
 	auto i = begin();
 	i = pos;
-	return "[" + RPackNum<sizeof...(Ranges)-1>::getStringMeta(i) + "]";
+	return "[" + RangeHelper::getStringMeta<0>(i) + "]";
     }
 
     template <class... Ranges>
@@ -656,7 +654,6 @@ namespace MultiArrayTools
 		out.insert(out.end(), part.begin(), part.end());
 		return 0;
 	    } );
-	//RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
 	return out;
     }
 

src/include/ranges/range_helper.h

@@ -6,6 +6,72 @@ namespace MultiArrayTools
 {
     namespace RangeHelper
     {
+
+	template <size_t I, class... Indices>
+	int ppx(std::tuple<std::shared_ptr<Indices>...>& ip,
+		std::array<size_t,sizeof...(Indices)+1>& bs,
+		std::intptr_t idxPtrNum)
+	{
+	    auto& siPtr = std::get<I>(ip);
+	    if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
+		if constexpr(I != 0){
+		    return ppx<I-1>(ip, bs, idxPtrNum);
+		}
+		else {
+		    return std::get<0>(bs);
+		}
+	    }
+	    else {
+		const int tmp = siPtr->pp(idxPtrNum);
+		if constexpr(I != 0){
+		    if(siPtr->pos() == siPtr->max()){
+			(*siPtr) = 0;
+			return ppx<I-1>(ip, bs, idxPtrNum) - siPtr->max() + 1;
+		    }
+		}
+		return tmp * std::get<I+1>(bs);
+	    }
+	}
+
+	template <size_t I, class... Indices>
+	int mmx(std::tuple<std::shared_ptr<Indices>...>& ip,
+		std::array<size_t,sizeof...(Indices)+1>& bs,
+		std::intptr_t idxPtrNum)
+	{
+	    auto& siPtr = std::get<I>(ip);
+	    if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
+		if constexpr(I != 0){
+		    return mmx<I-1>(ip, bs, idxPtrNum);
+		}
+		else {
+		    return std::get<0>(bs);
+		}
+	    }
+	    else {
+		const int tmp = siPtr->mm(idxPtrNum);
+		if constexpr(I != 0){
+		    if(siPtr->pos() == siPtr->max()){
+			(*siPtr) = siPtr->max() - 1;
+			return mmx<I-1>(ip, bs, idxPtrNum) - siPtr->max() + 1;
+		    }
+		}
+		return tmp * std::get<I+1>(bs);
+	    }
+	}
+
+	template <size_t N, class... Indices>
+	inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
+			      const std::array<size_t,sizeof...(Indices)+1>& blockSize)
+	{
+	    if constexpr(N != 0){
+		return makePos<N-1>(iPtrTup, blockSize) +
+		    std::get<N>(iPtrTup)->pos() * std::get<N+1>(blockSize);
+	    }
+	    else {
+		return std::get<0>(iPtrTup)->pos() * std::get<1>(blockSize);
+	    }
+	}
+
 	template <class Range>
 	inline void resolveSetRange(std::shared_ptr<Range>& rp, const vector<std::shared_ptr<RangeBase> >& orig,
 				    size_t origpos, size_t size)
@@ -14,6 +80,13 @@ namespace MultiArrayTools
 	    rp = std::dynamic_pointer_cast<Range>( orig[origpos] ); // catch bad cast here!!
 	}
 
+	template <class Range>
+	inline void setRangeToVec(vector<std::shared_ptr<RangeBase> >& v,
+				  std::shared_ptr<Range> r)
+	{
+	    v.insert(v.begin(), r);
+	}
+
 	template <size_t N, class IndexPack>
 	void setIndexPack(IndexPack& iPack, size_t pos)
 	{
@@ -108,6 +181,103 @@ namespace MultiArrayTools
 	    ::MultiArrayTools::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
 	}
 
+	template <size_t N, class MetaType, class... Ranges>
+	inline size_t getCMeta(MetaType* xtarget, size_t pos,
+			       const std::tuple<std::shared_ptr<Ranges>...>& stp, size_t off)
+	{
+	    //constexpr size_t NN = sizeof...(Ranges);
+	    auto& r = *std::get<N>(stp);
+	    const size_t ownPos = pos % r.size();
+	    const size_t s = r.cmetaSize();
+	    off -= s;
+	    r.cmeta(reinterpret_cast<char*>(&std::get<N>(*xtarget)), ownPos);
+	    if constexpr(N != 0){
+		return s + getCMeta<N-1>(xtarget, (pos - ownPos) / r.size(), stp, off);
+	    }
+	    else {
+		assert(off == 0);
+		return s;
+	    }
+	}
+
+	template <size_t N, class... Ranges>
+	inline size_t getCMetaSize(const std::tuple<std::shared_ptr<Ranges>...>& stp)
+	{
+	    auto& r = *std::get<N>(stp);
+	    if constexpr(N < sizeof...(Ranges)-1){
+		return r.cmetaSize() + getCMetaSize<N+1>(stp);
+	    }
+	    else {
+		return r.cmetaSize();
+	    }
+	}
+
+	template <size_t N, class MIndex>
+	inline std::string getStringMeta(const MIndex& mi)
+	{
+	    if constexpr(N < MIndex::sDim()-1){
+		return mi.template getPtr<N>()->stringMeta() + "," + getStringMeta<N+1>(mi);
+	    }
+	    else {
+		return mi.template getPtr<N>()->stringMeta();
+	    }
+	}
+
+	template <class Index>
+	inline size_t getStepSize(const Index& ii, std::intptr_t j);
+
+	template <size_t N, class Index>
+	inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx)
+	{
+	    const auto& ni = ii.template get<N>();
+	    const size_t max = ni.max();
+	    const size_t tmp = getStepSize(ni, j);
+	    ss += tmp * ii.template getBlockSize<N+1>();
+	    sx *= max;
+	    if constexpr(N != 0){
+		getStepSizeX<N-1>(ii, j, ss, sx);
+	    }
+	}
+
+	template <class Index>
+	inline size_t getStepSize(const Index& ii, std::intptr_t j)
+	{
+	    constexpr IndexType IT = Index::sType();
+	    if constexpr(IT == IndexType::SINGLE){
+		const std::intptr_t ip = reinterpret_cast<std::intptr_t>(&ii);
+		return ip == j ? 1 : 0;
+	    }
+	    else {
+		size_t ss = 0;
+		size_t sx = 1;
+		constexpr size_t DIM = Index::sDim();
+		getStepSizeX<DIM-1>(ii, j, ss, sx);
+		return ss;
+	    }
+	}
+
+
+	template <size_t N, size_t SIZE, class Range, class... Ranges>
+	inline bool compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec)
+	{
+	    if constexpr(N != 0){
+		return rbvec[SIZE-N-1]->spaceType() == Range::STYPE and compareSpaceTypes<N-1,SIZE,Ranges...>(rbvec);
+	    }
+	    else {
+		return rbvec[SIZE-N-1]->spaceType() == Range::STYPE;
+	    }
+	}
+
+	template <size_t N, class... Ranges>
+	inline void setSpace(const vector<std::shared_ptr<RangeBase> >& rbvec,
+			     std::tuple<std::shared_ptr<Ranges>...>& stp)
+	{
+	    typedef typename std::remove_reference<decltype(*std::get<N>( stp ))>::type RType;
+	    std::get<N>( stp ) = std::dynamic_pointer_cast<RType>( rbvec[N] );
+	    if constexpr(N != 0){
+		setSpace<N-1>(rbvec, stp);
+	    }
+	}
 
     } // namespace RangeHelper
 } // namespace MultiArrayTools

src/include/ranges/ranges_header.cc.h

@@ -1,4 +1,3 @@
 
-#include "rpack_num.cc.h"
 #include "ranges/dynamic_range.cc.h"
 #include "ranges/index_wrapper.cc.h"

src/include/ranges/rpack_num.cc.h

@@ -1,210 +0,0 @@
-
-#include "rpack_num.h"
-
-namespace MultiArrayHelper
-{
-    using namespace MultiArrayTools;
-
-    template <class Index1>
-    size_t mkTotalDim()
-    {
-	return Index1::totalDim();
-    }
-    
-    template <class Index1, class Index2, class... Indices>
-    size_t mkTotalDim()
-    {
-	return Index1::totalDim() * mkTotalDim<Index2,Indices...>();
-    }
-
-
-    /*
-    template <class Range>
-    inline void resolveSetRange(std::shared_ptr<Range>& rp, const vector<std::shared_ptr<RangeBase> >& orig,
-				size_t origpos, size_t size)
-    {
-	assert(size == 1);
-	rp = std::dynamic_pointer_cast<Range>( orig[origpos] ); // catch bad cast here!!
-    }
-    */
-
-    template <class Range>
-    inline void setRangeToVec(vector<std::shared_ptr<RangeBase> >& v,
-			      std::shared_ptr<Range> r)
-    {
-	v.insert(v.begin(), r);
-    }
-    
-    template <size_t N>
-    template <class... Indices>
-    inline size_t RPackNum<N>::makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
-                                              const std::array<size_t,sizeof...(Indices)+1>& blockSize)
-    {
-        return RPackNum<N-1>::makePos(iPtrTup, blockSize) + std::get<N>(iPtrTup)->pos() * std::get<N+1>(blockSize);
-    }
-
-    template <size_t N>
-    template <class... Indices>
-    size_t RPackNum<N>::blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
-    {
-        return std::get<sizeof...(Indices)-N>(pack)->max() * RPackNum<N-1>::blockSize(pack);
-    }
-
-    template <size_t N>
-    template <class Index>
-    inline void RPackNum<N>::getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx)
-    {
-        //constexpr size_t DIM = Index::sDim();
-        const auto& ni = ii.template get<N>();
-        const size_t max = ni.max();
-        const size_t tmp = getStepSize(ni, j);
-        //ss += tmp * sx;
-        ss += tmp * ii.template getBlockSize<N+1>();
-        sx *= max;
-        RPackNum<N-1>::getStepSizeX(ii, j, ss, sx);
-    }
-
-    template <size_t N>
-    template <class MIndex>
-    inline std::string RPackNum<N>::getStringMeta(const MIndex& mi)
-    {
-        return RPackNum<N-1>::getStringMeta(mi) + "," + mi.template getPtr<N>()->stringMeta();
-    }
-
-    template <size_t N>
-    template <size_t SIZE, class Range, class... Ranges>
-    inline bool RPackNum<N>::compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec)
-    {
-        return rbvec[SIZE-N-1]->spaceType() == Range::STYPE and RPackNum<N-1>::template compareSpaceTypes<SIZE,Ranges...>(rbvec);
-    }
-
-    template <size_t N>
-    template <class... Ranges>
-    inline void RPackNum<N>::setSpace(const vector<std::shared_ptr<RangeBase> >& rbvec,
-                                             std::tuple<std::shared_ptr<Ranges>...>& stp)
-    {
-        typedef typename std::remove_reference<decltype(*std::get<N>( stp ))>::type RType;
-        std::get<N>( stp ) = std::dynamic_pointer_cast<RType>( rbvec[N] );
-        RPackNum<N-1>::setSpace(rbvec, stp);
-    }
-
-    template <size_t N>
-    template <class MetaType, class... Ranges>
-    inline size_t RPackNum<N>::getCMeta(MetaType* xtarget, size_t pos,
-                                               const std::tuple<std::shared_ptr<Ranges>...>& stp, size_t off)
-    {
-        //constexpr size_t NN = sizeof...(Ranges);
-        auto& r = *std::get<N>(stp);
-        const size_t ownPos = pos % r.size();
-        const size_t s = r.cmetaSize();
-        off -= s;
-        r.cmeta(reinterpret_cast<char*>(&std::get<N>(*xtarget)), ownPos);
-        return s + RPackNum<N-1>::getCMeta(xtarget, (pos - ownPos) / r.size(), stp, off);
-    }
-
-    template <size_t N>
-    template <class... Ranges>
-    inline size_t RPackNum<N>::getCMetaSize(const std::tuple<std::shared_ptr<Ranges>...>& stp)
-    {
-        constexpr size_t NN = sizeof...(Ranges);
-        auto& r = *std::get<NN-N-1>(stp);
-        return r.cmetaSize() + RPackNum<N-1>::getCMetaSize(stp);
-    }
-
-
-    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)
-    {
-        return std::get<0>(iPtrTup)->pos() * std::get<1>(blockSize);
-    }
-
-    template <class... Indices>
-    size_t RPackNum<0>::blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
-    {
-        return 1;
-    }
-
-    template <class Index>
-    inline void RPackNum<0>::getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx)
-    {
-        //constexpr size_t DIM = Index::sDim();
-        const auto& ni = ii.template get<0>();
-        const size_t max = ni.max();
-        const size_t tmp = getStepSize(ni, j);
-        //ss += tmp * sx;
-        ss += tmp * ii.template getBlockSize<1>();
-        sx *= max;
-    }
-
-    template <class MIndex>
-    inline std::string RPackNum<0>::getStringMeta(const MIndex& mi)
-    {
-        return mi.template getPtr<0>()->stringMeta();
-    }
-
-    template <size_t SIZE, class Range>
-    inline bool RPackNum<0>::compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec)
-    {
-        return rbvec[SIZE-1]->spaceType() == Range::STYPE;
-    }
-
-    template <class... Ranges>
-    inline void RPackNum<0>::setSpace(const vector<std::shared_ptr<RangeBase> >& rbvec,
-                                             std::tuple<std::shared_ptr<Ranges>...>& stp)
-    {
-        typedef typename std::remove_reference<decltype(*std::get<0>( stp ))>::type RType;
-        std::get<0>( stp ) = std::dynamic_pointer_cast<RType>( rbvec[0] );
-    }
-
-    template <class MetaType, class... Ranges>
-    inline size_t RPackNum<0>::getCMeta(MetaType* xtarget, size_t pos,
-                                               const std::tuple<std::shared_ptr<Ranges>...>& stp, size_t off)
-    {
-        //constexpr size_t NN = sizeof...(Ranges);
-        auto& r = *std::get<0>(stp);
-        const size_t ownPos = pos % r.size();
-        const size_t s = r.cmetaSize();
-        off -= s;
-        assert(off == 0);
-        r.cmeta(reinterpret_cast<char*>(&std::get<0>(*xtarget)), ownPos);
-        return s;
-    }
-
-    template <class... Ranges>
-    inline size_t RPackNum<0>::getCMetaSize(const std::tuple<std::shared_ptr<Ranges>...>& stp)
-    {
-        constexpr size_t NN = sizeof...(Ranges);
-        auto& r = *std::get<NN-1>(stp);
-        return r.cmetaSize();
-    }
-
-
-    
-    template <IndexType IT>
-    template <class Index>
-    inline size_t SSG<IT>::getStepSize(const Index& ii, std::intptr_t j)
-    {
-        size_t ss = 0;
-        size_t sx = 1;
-        constexpr size_t DIM = Index::sDim();
-        RPackNum<DIM-1>::getStepSizeX(ii, j, ss, sx);
-        return ss;
-    }
-
-    template <class Index>
-    inline size_t SSG<IndexType::SINGLE>::getStepSize(const Index& ii, std::intptr_t j)
-    {
-        const std::intptr_t ip = reinterpret_cast<std::intptr_t>(&ii);
-        return ip == j ? 1 : 0;
-        //return ii.ptrNum() == j ? 1 : 0;
-    }
-    
-    template <class Index>
-    inline size_t getStepSize(const Index& ii, std::intptr_t j)
-    {
-	constexpr IndexType IT = Index::sType();
-	return SSG<IT>::getStepSize(ii, j);
-    }
-
-} //  end namespace MultiArrayHelper

src/include/ranges/rpack_num.h

@@ -1,188 +0,0 @@
-
-#ifndef __rpack_num_h__
-#define __rpack_num_h__
-
-#include <memory>
-#include <vector>
-#include <cassert>
-#include "ranges/rbase_def.h"
-#include "ranges/index_base.h"
-#include "ranges/x_to_string.h"
-
-namespace MultiArrayHelper
-{
-    using namespace MultiArrayTools;
-
-    template <size_t I, class... Indices>
-    int ppx(std::tuple<std::shared_ptr<Indices>...>& ip,
-	    std::array<size_t,sizeof...(Indices)+1>& bs,
-	    std::intptr_t idxPtrNum)
-    {
-	auto& siPtr = std::get<I>(ip);
-	if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
-	    if constexpr(I != 0){
-		return ppx<I-1>(ip, bs, idxPtrNum);
-	    }
-	    else {
-		return std::get<0>(bs);
-	    }
-	}
-	else {
-	    const int tmp = siPtr->pp(idxPtrNum);
-	    if constexpr(I != 0){
-		if(siPtr->pos() == siPtr->max()){
-		    (*siPtr) = 0;
-		    return ppx<I-1>(ip, bs, idxPtrNum) - siPtr->max() + 1;
-		}
-	    }
-	    return tmp * std::get<I+1>(bs);
-	}
-    }
-
-    template <size_t I, class... Indices>
-    int mmx(std::tuple<std::shared_ptr<Indices>...>& ip,
-	    std::array<size_t,sizeof...(Indices)+1>& bs,
-	    std::intptr_t idxPtrNum)
-    {
-	auto& siPtr = std::get<I>(ip);
-	if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
-	    if constexpr(I != 0){
-		return mmx<I-1>(ip, bs, idxPtrNum);
-	    }
-	    else {
-		return std::get<0>(bs);
-	    }
-	}
-	else {
-	    const int tmp = siPtr->mm(idxPtrNum);
-	    if constexpr(I != 0){
-		if(siPtr->pos() == siPtr->max()){
-		    (*siPtr) = siPtr->max() - 1;
-		    return mmx<I-1>(ip, bs, idxPtrNum) - siPtr->max() + 1;
-		}
-	    }
-	    return tmp * std::get<I+1>(bs);
-	}
-    }
-    
-    template <class Index1>
-    size_t mkTotalDim();
-    
-    template <class Index1, class Index2, class... Indices>
-    size_t mkTotalDim();
-
-
-    template <class RangeType, class... Ranges>
-    struct SubProp
-    {
-	static constexpr size_t ISSTATIC = RangeType::ISSTATIC & SubProp<Ranges...>::ISSTATIC;
-	static constexpr size_t SIZE = RangeType::SIZE * SubProp<Ranges...>::SIZE;
-    };
-
-    template <>
-    struct SubProp<None>
-    {
-	static constexpr size_t ISSTATIC = 1;
-	static constexpr size_t SIZE = 1;
-    };
-
-    template <class Index>
-    inline size_t getStepSize(const Index& ii, std::intptr_t j);
-
-    
-    template <class Range>
-    inline void resolveSetRange(std::shared_ptr<Range>& rp, const vector<std::shared_ptr<RangeBase> >& orig,
-				size_t origpos, size_t size);
-
-    template <class Range>
-    inline void setRangeToVec(vector<std::shared_ptr<RangeBase> >& v,
-			      std::shared_ptr<Range> r);
-    
-    template <size_t N>
-    struct RPackNum
-    {
-	
-	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);
-
-	template <class... Indices>
-	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack);
-
-
-	template <class Index>
-	static inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx);
-
-	template <class MIndex>
-	static inline std::string getStringMeta(const MIndex& mi);
-
-	template <size_t SIZE, class Range, class... Ranges>
-	static inline bool compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec);
-
-	template <class... Ranges>
-	static inline void setSpace(const vector<std::shared_ptr<RangeBase> >& rbvec,
-				    std::tuple<std::shared_ptr<Ranges>...>& stp);
-
-        template <class MetaType, class... Ranges>
-        static inline size_t getCMeta(MetaType* xtarget, size_t pos,
-                                      const std::tuple<std::shared_ptr<Ranges>...>& stp, size_t off);
-
-        template <class... Ranges>
-        static inline size_t getCMetaSize(const std::tuple<std::shared_ptr<Ranges>...>& stp);
-
-    };
-
-    
-    template<>
-    struct RPackNum<0>
-    {
-
-	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);
-
-	template <class... Indices>
-	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack);
-
-	template <class Index>
-	static inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx);
-
-        template <class MIndex>
-	static inline std::string getStringMeta(const MIndex& mi);
-
-	template <size_t SIZE, class Range>
-	static inline bool compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec);
-
-	template <class... Ranges>
-	static inline void setSpace(const vector<std::shared_ptr<RangeBase> >& rbvec,
-				    std::tuple<std::shared_ptr<Ranges>...>& stp);
-
-        template <class MetaType, class... Ranges>
-        static inline size_t getCMeta(MetaType* xtarget, size_t pos,
-                                      const std::tuple<std::shared_ptr<Ranges>...>& stp, size_t off);
-
-        template <class... Ranges>
-        static inline size_t getCMetaSize(const std::tuple<std::shared_ptr<Ranges>...>& stp);
-
-    };
-    
-    template <IndexType IT>
-    struct SSG
-    {
-	template <class Index>
-	static inline size_t getStepSize(const Index& ii, std::intptr_t j);
-    };
-
-    template <>
-    struct SSG<IndexType::SINGLE>
-    {
-	template <class Index>
-	static inline size_t getStepSize(const Index& ii, std::intptr_t j);
-    };
-    
-
-} //  end namespace MultiArrayHelper
-
-//#include "rpack_num.cc.h"
-
-#endif

src/include/ranges/single_range.h

@@ -9,16 +9,12 @@
 #include <map>
 
 #include "base_def.h"
-//#include "ranges/rpack_num.h"
 #include "ranges/index_base.h"
 #include "ranges/range_base.h"
 #include "ranges/x_to_string.h"
 #include "ranges/type_map.h"
 
 #include "xfor/for_type.h"
-//#include "xfor/xfor.h"
-
-
 
 namespace MultiArrayTools
 {

src/include/ranges/subrange.h

@@ -8,7 +8,6 @@
 #include <map>
 
 #include "base_def.h"
-//#include "ranges/rpack_num.h"
 #include "ranges/index_base.h"
 #include "ranges/range_base.h"
 #include "ranges/x_to_string.h"

src/lib/ranges/range_base.cc

@@ -7,6 +7,7 @@
 
 #include "ranges/range_base.h"
 #include "ranges/ranges_header.cc.h"
+#include "ranges/range_helper.h"
 
 #include <algorithm>
 
@@ -23,8 +24,7 @@ namespace MultiArrayTools
     template <class... Ranges>
     inline bool compareSpaceTypes(const RVEC& rvec)
     {
-	return RPackNum<sizeof...(Ranges)-1>::
+	return RangeHelper::compareSpaceTypes<sizeof...(Ranges)-1,sizeof...(Ranges),Ranges...>(rvec);
-	    template compareSpaceTypes<sizeof...(Ranges),Ranges...>(rvec);
     }
 
     template <class... Ranges>
@@ -32,7 +32,7 @@ namespace MultiArrayTools
     {
 	if(compareSpaceTypes<Ranges...>(rvec)) {
 	    STP<Ranges...> stp;
-	    RPackNum<sizeof...(Ranges)-1>::setSpace(rvec, stp);
+	    RangeHelper::setSpace<sizeof...(Ranges)-1>(rvec, stp);
 	    fptr = std::make_shared<MultiRangeFactory<Ranges...> >(stp);
 	    return true;
 	}