From 5f71b5055d765c35770bc6cf55c5c24e777e7df8 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 26 Jul 2017 16:45:09 +0200
Subject: [PATCH] shift template recursion methods in a single struct
 'PackNum<N>'

---
 src/multi_range.cc | 662 ++++++++++++++-------------------------------
 src/multi_range.h  |  24 +-
 2 files changed, 207 insertions(+), 479 deletions(-)

diff --git a/src/multi_range.cc b/src/multi_range.cc
index 65c63a6..07caaab 100644
--- a/src/multi_range.cc
+++ b/src/multi_range.cc
@@ -9,213 +9,69 @@ namespace MultiArrayTools
 
     namespace
     {
+
 	template <size_t N>
-	struct IndexGetter
-	{	
+	struct PackNum
+	{
 	    template <class MultiIndex>
-	    static IndefinitIndexBase& getIndex(MultiIndex& in, size_t n)
+	    static IndexBase& getIndex(MultiIndex& in, size_t n)
 	    {
 		if(n == N){
 		    return in.getIndex<N>();
 		}
 		else {
-		    return IndexGetter<N-1>::getIndex(in, n);
+		    return PackNum<N-1>::getIndex(in, n);
 		}
 	    }
 
 	    template <class MultiIndex>
-	    static const IndefinitIndexBase& getIndex(const MultiIndex& in, size_t n)
+	    static const IndexBase& getIndex(const MultiIndex& in, size_t n)
 	    {
 		if(n == N){
 		    return in.getIndex<N>();
 		}
 		else {
-		    return IndexGetter<N-1>::getIndex(in, n);
-		}
-	    }
-	};
-
-	template <>
-	struct IndexGetter<0>
-	{
-	    template <class MultiIndex>
-	    static IndefinitIndexBase& getIndex(MultiIndex& in, size_t n)
-	    {
-		return in.getIndex<0>();
-	    }
-
-	    template <class MultiIndex>
-	    static const IndefinitIndexBase& getIndex(const MultiIndex& in, size_t n)
-	    {
-		return in.getIndex<0>();
-	    }
-	};
-
-	template <size_t N>
-	struct Evaluation
-	{
-	    template <class MultiIndex>
-	    static size_t evaluate(const MultiIndex& index)
-	    {
-		const auto& subIndex = index.template getIndex<N>();
-		return Evaluation<N-1>::evaluate(index) * subIndex.max() + subIndex.pos();
-	    }
-	};
-
-	template <>
-	struct Evaluation<0>
-	{
-	    template <class MultiIndex>
-	    static size_t evaluate(const MultiIndex& index)
-	    {
-		const auto& subIndex = index.template getIndex<0>();
-		return subIndex.pos();
-	    }
-	};
-
-	// rewrite !!
-	template <size_t DIGIT>
-	struct SubIteration
-	{
-	    // use 'plus' as few as possible !!
-	    template <class MultiIndex>
-	    static inline void plus(MultiIndex& index, int num)
-	    {
-		auto& si = index.template getIndex<DIGIT>();
-		si.setPosRel(num, &index);
-		size_t oor = si.outOfRange();
-		while(oor > 0){
-		    SubIteration<DIGIT-1>::pp(index);
-		    SubIteration<DIGIT>::plus(index, -si.max());
-		}
-		while(oor < 0){
-		    SubIteration<DIGIT-1>::mm(index);
-		    SubIteration<DIGIT>::plus(index, si.max());
+		    return PackNum<N-1>::getIndex(in, n);
 		}
 	    }
 
-	    template <class MultiIndex>
-	    static inline void pp(MultiIndex& index)
+	    template <class... Indices>
+	    static inline void pp(std::tuple<std::shared_ptr<Indices>...>& ip)
 	    {
-		auto& si = index.template getIndex<DIGIT>();
-		if(si.pos() == si.atEdge()){
-		    si.setPos(0, &index);
-		    SubIteration<DIGIT-1>::pp(index);
+		auto& si = *std::get<N>(ip);
+		if(si.pos() == si.last()){
+		    si = 0;
+		    PackNum<N-1>::pp(index);
 		}
 		else {
-		    si.setPosRel(1, &index);
+		    ++si;
 		}
 	    }
 
-	    template <class MultiIndex>
-	    static inline void mm(MultiIndex& index)
+	    template <class... Indices>
+	    static inline void mm(std::tuple<std::shared_ptr<Indices>...>& ip)
 	    {
-		auto& si = index.template getIndex<DIGIT>();
+		auto& si = *std::get<N>(ip);
 		if(si.pos() == si.atEdge()){
-		    si.setPos(si.atEdge(), &index);
-		    SubIteration<DIGIT-1>::mm(index);
+		    si = si.max();
+		    PackNum<N-1>::mm(index);
 		}
 		else {
-		    si.setPosRel(1, &index);
+		    --si;
 		}
 	    }
-	};
 
-	template <>
-	struct SubIteration<0>
-	{
-	    template <class MultiIndex>
-	    static inline void plus(MultiIndex& index, int num)
-	    {
-		auto& si = index.template getIndex<0>();
-		si.setPosRel(num, &index);
-	    }
-
-	    template <class MultiIndex>
-	    static inline void pp(MultiIndex& index)
-	    {
-		auto& si = index.template getIndex<0>();
-		si.setPosRel(1, &index);
-	    }
-
-	    template <class MultiIndex>
-	    static inline void mm(MultiIndex& index)
-	    {
-		auto& si = index.template getIndex<0>();
-		si.setPosRel(-1, &index);
-	    }
-	};
-
-	template <size_t N>
-	struct IndexSubOrder
-	{
-	    template <class IndexPack>
-	    static void subOrd(IndexPack& iPack, IndefinitIndexBase* major)
-	    {
-		std::get<N>(iPack).subOrd(major);
-		IndexSubOrder<N-1>::subOrd(iPack, major);
-	    }
-	};
-	
-	template <>
-	struct IndexSubOrder<0>
-	{
-	    template <class IndexPack>
-	    static void subOrd(IndexPack& iPack, IndefinitIndexBase* major)
-	    {
-		std::get<0>(iPack).subOrd(major);
-	    }
-	};
-
-	template <size_t N>
-	struct PositionCopy
-	{
-	    template <class MultiIndex>
-	    static void copyPos(MultiIndex& target, const MultiIndex& source)
-	    {
-		target.template getIndex<N>().copyPos( source.template getIndex<N>() );
-		PositionCopy<N-1>::copyPos(target, source);
-	    }
-	};
-
-	template <>
-	struct PositionCopy<0>
-	{
-	    template <class MultiIndex>
-	    static void copyPos(MultiIndex& target, const MultiIndex& source)
-	    {
-		target.template getIndex<0>().copyPos( source.template getIndex<0>() );
-	    }
-	};
-
-	template <size_t N>
-	struct TupleSize
-	{
 	    template <class RangeTuple>
 	    static size_t getSize(const RangeTuple& rt)
 	    {
-		return std::get<N>(rt).size() * TupleSize<N-1>::getSize(rt);
+		return std::get<N>(rt).size() * PackNum<N-1>::getSize(rt);
 	    }
-	};
-	
-	template <>
-	struct TupleSize<0>
-	{
-	    template <class RangeTuple>
-	    static size_t getSize(const RangeTuple& rt)
-	    {
-		return std::get<0>(rt).size();
-	    }
-	};
-	
-	template <size_t N>
-	struct IndexSetter
-	{
+	    
 	    template <class... Ranges>
 	    static void setBegin(MultiRange<Ranges...>::IndexType& i, const MultiRange<Ranges...>::SpaceType& r)
 	    {
 		*std::get<N>(i) = std::get<N>(r)->begin();
-		IndexSetter<N-1>::setBegin(i,r);
+		PackNum<N-1>::setBegin(i,r);
 	    }
 	    
 	    template <class... Ranges>
@@ -223,13 +79,130 @@ namespace MultiArrayTools
 	    {
 		*std::get<N>(i) = std::get<N>(r)->end();
 		*std::get<N>(i) -= 1;
-		IndexSetter<N-1>::setEnd(i,r);
+		PackNum<N-1>::setEnd(i,r);
 	    }
+
+	    template <class... Ranges>
+	    static void buildRangeVec(std::vector<MultiRangeType>& rvec, const MultiRange<Ranges...>::SpaceType& rs)
+	    {
+		rvec.push_back(std::get<sizeof...(Ranges)-N-1>(rs)->type());
+		PackNum<N-1>::buildRangeVec(rvec, rs);
+	    }
+
+	    template <class... Indices>
+	    static void getMetaPos(std::tuple<decltype(Indices().meta())...>& target,
+				   const typename MultiIndex<Indices...>::IndexPack& source)
+	    {
+		std::get<N>(target) = std::get<N>(source)->meta();
+		PackNum<N-1>::getMetaPos(target, source);
+	    }
+
+	    template <class... Indices>
+	    static void setMeta(typename MultiIndex<Indices...>::IndexPack& target,
+				const typename MultiIndex<Indices...>::MetaType& source)
+	    {
+		std::get<N>(target).atMeta( std::get<N>(source) );
+		PackNum<N-1>::setMeta(target, source);
+	    }
+
+	    template <class IndexPack>
+	    static void setIndexPack(IndexPack& iPack, size_t pos)
+	    {
+		auto i = std::get<N>(iPack);
+		const size_t ownPos = pos % i.max(); 
+		i = ownPos;
+		if(ownPos == pos){
+		    PackNum<N-1>::setIndexPack(iPack, (pos - ownPos) / i.max() );
+		}
+	    }
+
+	    template <class IndexPack, class... Indices>
+	    static auto setFromPointerList(IndexPack& ipack,
+					   std::vector<std::shared_ptr<IndefinitIndexBase> >& ptrList,
+					   std::shared_ptr<Indices>&... inds)
+		-> decltype(PackNum<N-1>::setFromPointerList(ipack,
+								     std::shared_ptr<decltype(std::get<N>(ipack))>,
+								     newPtr, inds...))
+	    {
+		typedef std::shared_ptr<decltype(std::get<N>(ipack))> NewIndexPtrType;
+		NewIndexPtrType newPtr = dynamic_pointer_cast<NewIndexPtrType>(ptrList.at(N));
+		return PackNum<N-1>::setFromPointerList(ipack, ptrList, newPtr, inds...);
+	    }
+
+	    template <class MRange, class... Indices>
+	    static void construct(std::tuple<std::shared_ptr<Indices>...>& ip,
+				  const MRange& range)
+	    {
+		typedef decltype(range.template get<N>()) SubIndexType;
+		typedef decltype(std::get<N>(ip).get()) TypeFromIndexPack;
+
+		static_assert(std::is_same<SubIndexType,TypeFromIndexPack>::value,
+			      "inconsiśtent types");
+		
+		std::get<N>(ip).swap( std::make_shared<SubIndexType>( range.template get<N>() ) );
+		PackNum<N-1>::construct(ip, range);
+	    }
+
+	    template <class... Indices>
+	    static void copy(std::tuple<std::shared_ptr<Indices>...>& ip,
+			     const MultiIndex<Indices...>& ind)
+	    {
+		typedef decltype(ind.template get<N>()) SubIndexType;
+		std::get<N>(ip).swap( std::make_shared<SubIndexType>( ind.template get<N>() ) );
+		PackNum<N-1>::copy(ip, ind);
+	    }
+
+	    template <class... Indices>
+	    static size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup)
+	    {
+		return std::get<N>(iPtrTup)->pos() +
+		    PackNum<N-1>::makePos(iPtrTup) * std::get<N-1>(iPtrTup)->max();
+	    }
+
+	    template <typename... Ts>
+	    static void print(std::ostream& os, const std::tuple<Ts...>& meta)
+	    {
+		PackNum<N-1>::print(os, meta);
+		os << std::get<N>(meta) << '\t';
+	    }	    
+	    
 	};
-	
-	template <>
-	struct IndexSetter<0>
+
+	template<>
+	struct PackNum<0>
 	{
+	    template <class MultiIndex>
+	    static IndefinitIndexBase& getIndex(MultiIndex& in, size_t n)
+	    {
+		return in.getIndex<0>();
+	    }
+
+	    template <class MultiIndex>
+	    static const IndefinitIndexBase& getIndex(const MultiIndex& in, size_t n)
+	    {
+		return in.getIndex<0>();
+	    }
+
+	    template <class MultiIndex>
+	    static inline void pp(std::tuple<std::shared_ptr<Indices>...>& ip)
+	    {
+		auto& si = *std::get<0>(ip);
+		++si;
+	    }
+
+	    template <class MultiIndex>
+	    static inline void mm(std::tuple<std::shared_ptr<Indices>...>& ip)
+	    {
+		auto& si = *std::get<0>(ip);
+		--si;
+	    }
+
+	    template <class RangeTuple>
+	    static size_t getSize(const RangeTuple& rt)
+	    {
+		return std::get<0>(rt).size();
+	    }
+
 	    template <class... Ranges>
 	    static void setBegin(MultiRange<Ranges...>::IndexType& i, const MultiRange<Ranges...>::SpaceType& r)
 	    {
@@ -242,105 +215,27 @@ namespace MultiArrayTools
 		*std::get<0>(i) = std::get<0>(r)->end();
 		*std::get<0>(i) -= 1;
 	    }
-	};
-	
-	template <size_t N>
-	struct RangeVecBuilder
-	{
-	    template <class... Ranges>
-	    static void buildRangeVec(std::vector<MultiRangeType>& rvec, const MultiRange<Ranges...>::SpaceType& rs)
-	    {
-		rvec.push_back(std::get<sizeof...(Ranges)-N-1>(rs)->type());
-		RangeVecBuilder<N-1>::buildRangeVec(rvec, rs);
-	    }
-	};
-	template <>
-	struct RangeVecBuilder<0>
-	{
+
 	    template <class... Ranges>
 	    static void buildRangeVec(std::vector<MultiRangeType>& rvec, const MultiRange<Ranges...>::SpaceType& rs)
 	    {
 		rvec.push_back(std::get<sizeof...(Ranges)-1>(rs)->type());
 	    }
-	};
-	// HERE !!!
-	template <size_t N>
-	struct MetaPosGetter
-	{
+
 	    template <class... Indices>
-	    static void getMetaPos(std::tuple<decltype(Indices().getMetaPos())...>& target,
+	    static void getMetaPos(std::tuple<decltype(Indices().meta())...>& target,
 				   const typename MultiIndex<Indices...>::IndexPack& source)
 	    {
-		std::get<N>(target) = std::get<N>(source)->getMetaPos();
-		MetaPosGetter<N-1>::getMetaPos(target, source);
+		std::get<0>(target) = std::get<0>(source)->meta();
 	    }
-	};
 
-	template <>
-	struct MetaPosGetter<0>
-	{
-	    template <class... Indices>
-	    static void getMetaPos(std::tuple<decltype(Indices().getMetaPos())...>& target,
-				   const typename MultiIndex<Indices...>::IndexPack& source)
-	    {
-		std::get<0>(target) = std::get<0>(source)->getMetaPos();
-	    }
-	};
-
-	template <size_t N>
-	struct MetaSetter
-	{
-	    template <class... Indices>
-	    static void setMeta(typename MultiIndex<Indices...>::IndexPack& target,
-				const typename MultiIndex<Indices...>::MetaType& source)
-	    {
-		std::get<N>(target).atMeta( std::get<N>(source) );
-		MetaSetter<N-1>::setMeta(target, source);
-	    }
-	};
-
-	template <>
-	struct MetaSetter<0>
-	{
 	    template <class... Indices>
 	    static void setMeta(typename MultiIndex<Indices...>::IndexPack& target,
 				const typename MultiIndex<Indices...>::MetaType& source)
 	    {
 		std::get<0>(target).atMeta( std::get<0>(source) );
 	    }
-	};
 
-	template <size_t N>
-	struct IndexPackSetter
-	{
-	    template <class IndexPack>
-	    static void setIndexPack(IndexPack& iPack, size_t pos)
-	    {
-		auto i = std::get<N>(iPack);
-		const size_t ownPos = pos % i.max(); 
-		i = ownPos;
-		if(ownPos == pos){
-		    IndexPackSetter<N-1>::setIndexPack(iPack, (pos - ownPos) / i.max() );
-		}
-	    }
-
-	    template <class IndexPack, class... Indices>
-	    static auto setFromPointerList(IndexPack& ipack,
-					   std::vector<std::shared_ptr<IndefinitIndexBase> >& ptrList,
-					   std::shared_ptr<Indices>&... inds)
-		-> decltype(IndexPackSetter<N-1>::setFromPointerList(ipack,
-								     std::shared_ptr<decltype(std::get<N>(ipack))>,
-								     newPtr, inds...))
-	    {
-		typedef std::shared_ptr<decltype(std::get<N>(ipack))> NewIndexPtrType;
-		NewIndexPtrType newPtr = dynamic_pointer_cast<NewIndexPtrType>(ptrList.at(N));
-		return IndexPackSetter<N-1>::setFromPointerList(ipack, ptrList, newPtr, inds...);
-	    }
-	};
-
-	template <>
-	struct IndexPackSetter<0>
-	{
 	    template <class IndexPack>
 	    static void setIndexPack(IndexPack& iPack, size_t pos)
 	    {
@@ -360,98 +255,55 @@ namespace MultiArrayTools
 		return std::make_tuple(newPtr, inds...);
 	    }
 
-	};
-
-	template <size_t N>
-	struct SubIndexConstruct
-	{
 	    template <class MRange, class... Indices>
-	    void construct(std::tuple<std::shared_ptr<Indices>...>& ip,
-			   const MRange& range)
-	    {
-		typedef decltype(range.template get<N>()) SubIndexType;
-		typedef decltype(std::get<N>(ip).get()) wTypeFromIndexPack;
-
-		static_assert(is_same<SubIndexType,SubIndexType>::value,
-			      "inconsiśtent types");
-		
-		std::get<N>(ip).swap( std::make_shared<SubIndexType> ( range.template get<N>() ) );
-		SubIndexConstruct<N-1>::construct(ip, range);
-	    }
-
-	    template <class... Indices>
-	    void copy(std::tuple<std::shared_ptr<Indices>...>& ip,
-		      const MultiIndex<Indices...>& ind)
-	    {
-		typedef decltype(ind.template get<N>()) SubIndexType;
-		std::get<N>(ip).swap( std::make_shared<SubIndexType>( ind.template get<N>() ) );
-		SubIndexConstruct<N-1>::copy(ip, ind);
-	    }
-	};
-
-	template <>
-	struct SubIndexConstruct<0>
-	{
-	    template <class MRange, class... Indices>
-	    void construct(std::tuple<std::shared_ptr<Indices>...>& ip,
-			   const MRange& range)
+	    static void construct(std::tuple<std::shared_ptr<Indices>...>& ip,
+				  const MRange& range)
 	    {
 		typedef decltype(range.template get<0>()) SubIndexType;
-		typedef decltype(std::get<0>(ip).get()) wTypeFromIndexPack;
+		typedef decltype(std::get<0>(ip).get()) TypeFromIndexPack;
 
-		static_assert(std::is_same<SubIndexType,SubIndexType>::value,
+		static_assert(std::is_same<SubIndexType,TypeFromIndexPack>::value,
 			      "inconsiśtent types");
 		
-		std::get<0>(ip).swap( std::make_shared<SubIndexType> ( range.template get<0>() ) );
+		std::get<0>(ip).swap( std::make_shared<SubIndexType>( range.template get<0>() ) );
 	    }
 
 	    template <class... Indices>
-	    void copy(std::tuple<std::shared_ptr<Indices>...>& ip,
-		      const MultiIndex<Indices...>& ind)
+	    static void copy(std::tuple<std::shared_ptr<Indices>...>& ip,
+			     const MultiIndex<Indices...>& ind)
 	    {
 		typedef decltype(ind.template get<0>()) SubIndexType;
 		std::get<0>(ip).swap( std::make_shared<SubIndexType>( ind.template get<0>() ) );
 	    }
 
-	};
-
-	template <size_t N>
-	struct PosGetter
-	{
 	    template <class... Indices>
-	    size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup)
-	    {
-		return std::get<N>(iPtrTup)->pos() +
-		    PosGetter<N-1>::makePos(iPtrTup) * std::get<N-1>(iPtrTup)->max();
-	    }
-	};
-
-	template <>
-	struct PosGetter<0>
-	{
-	    template <class... Indices>
-	    size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup)
+	    static size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup)
 	    {
 		return std::get<0>(iPtrTup)->pos();
 	    }
+
+	    template <typename... Ts>
+	    static void print(std::ostream& os, const std::tuple<Ts...>& meta)
+	    {
+		os << std::get<0>(meta) << '\t';
+	    }
 	};
-	
     }
 
     template <class... Indices>
     MultiIndex<Indices...>::MultiIndex(const MultiIndex<Indices...>& in) :
 	IndexInterface<std::tuple<decltype(Indices().meta())...> >(in)
     {
-	SubIndexConstruct<sizeof...(Indices)-1>::copy(mIPack, in);
-	mPos = PosGetter<sizeof...(Indices)-1>::makePos(mIPack);
+	PackNum<sizeof...(Indices)-1>::copy(mIPack, in);
+	mPos = PackNum<sizeof...(Indices)-1>::makePos(mIPack);
     }
 	
     template <class... Indices>
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(const MultiIndex<Indices...>& in)
     {
 	IndexI::operator=(in);
-	SubIndexConstruct<sizeof...(Indices)-1>::copy(mIPack, in);
-	mPos = PosGetter<sizeof...(Indices)-1>::makePos(mIPack);
+	PackNum<sizeof...(Indices)-1>::copy(mIPack, in);
+	mPos = PackNum<sizeof...(Indices)-1>::makePos(mIPack);
 	return *this;
     }
     
@@ -460,135 +312,69 @@ namespace MultiArrayTools
     MultiIndex<Indices...>::MultiIndex(const std::shared_ptr<MRange>& range) :
 	IndexInterface<std::tuple<decltype(Indices().meta())...> >(range, 0)
     {
-	SubIndexConstruct<sizeof...(Indices)-1>::construct(mIPack, *range);
-	mPos = PosGetter<sizeof...(Indices)-1>::makePos(mIPack);
+	PackNum<sizeof...(Indices)-1>::construct(mIPack, *range);
+	mPos = PackNum<sizeof...(Indices)-1>::makePos(mIPack);
     }
     
     template <class... Indices>
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator++()
     {
-	SubIteration<sizeof...(Indices)-1>::pp(*this);
-	//plus(*this, sizeof...(Indices)-1, 1);
-	IIB::setPosRel(1);
+	PackNum<sizeof...(Indices)-1>::pp( mIPack );
+	++mPos;
 	return *this;
     }
 
     template <class... Indices>
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator--()
     {
-	SubIteration<sizeof...(Indices)-1>::mm(*this);
-	//plus(*this, sizeof...(Indices)-1, -1);
-	IIB::setPosRel(-1);
+	PackNum<sizeof...(Indices)-1>::mm( mIPack );
+	--mPos;
 	return *this;
     }
-
-    template <class... Indices>
-    MultiIndex<Indices...>& MultiIndex<Indices...>::operator+=(int n)
-    {
-	SubIteration<sizeof...(Indices)-1>::plus(*this, n);
-	//plus(*this, sizeof...(Indices)-1, n);
-	IIB::setPosRel(n);
-	return *this;
-    }
-
-    template <class... Indices>
-    MultiIndex<Indices...>& MultiIndex<Indices...>::operator-=(int n)
-    {
-	SubIteration<sizeof...(Indices)-1>::plus(*this, -n);
-	//plus(*this, sizeof...(Indices)-1, -n);
-	IIB::setPosRel(-n);
-	return *this;
-    }
-
-    template <class... Indices>
-    bool MultiIndex<Indices...>::operator==(const MultiIndex<Indices...>& in)
-    {
-	return IB::mRange == in.mRange and IIB::pos() == in.pos();
-    }
-
-    template <class... Indices>
-    bool MultiIndex<Indices...>::operator!=(const MultiIndex<Indices...>& in)
-    {
-	return IB::mRange != in.mRange or IIB::pos() != in.pos();
-    }
     
     template <class... Indices>
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(size_t pos)
     {
-	IIB::setPos( pos );
-	IndexPackSetter<sizeof...(Indices)-1>::setIndexPack(mIPack, pos);
+	mPos = pos;
+	PackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, pos);
 	return *this;
     }
 
     template <class... Indices>
-    MultiRangeType MultiIndex<Indices...>::rangeType() const
+    template <size_t DIR>
+    MultiIndex<Indices...>& MultiIndex<Indices...>::up()
     {
-	return IB::mRange->type();
-    }
-    
-    template <class... Indices>
-    size_t MultiIndex<Indices...>::evaluate(const MultiIndex<Indices...>& in) const
-    {
-	size_t res = Evaluation<sizeof...(Indices)-1>::evaluate(in);
-	return res;
-    }
-
-    template <class... Indices>
-    MultiIndex<Indices...>& MultiIndex<Indices...>::operator()(Indices&&... inds)
-    {
-	mIPack = std::make_tuple(inds...);
-	IndexSubOrder<sizeof...(Indices)-1>::subOrd(mIPack, this);
-	IIB::mPos = evaluate(*this);
+	static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices");
+	mPos += /*!!!*/;
+	PackNum<DIR>::pp( mIPack );
 	return *this;
     }
 
     template <class... Indices>
-    MultiIndex<Indices...>& MultiIndex<Indices...>::operator()(const Indices&... inds)
+    template <size_t DIR>
+    MultiIndex<Indices...>& MultiIndex<Indices...>::down()
     {
-	mIPack = std::make_tuple(Indices(inds)...);
-	IndexSubOrder<sizeof...(Indices)-1>::subOrd(mIPack, this);
-	IIB::mPos = evaluate(*this);
+	static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices");
+	mPos -= /*!!!*/;
+	PackNum<DIR>::mm( mIPack );
 	return *this;
     }
     
     template <class... Indices>
     size_t MultiIndex<Indices...>::dim() const
     {
-	size_t res = 1;
-	for(size_t i = 0; i != sizeof...(Indices); ++i){
-	    res *= get(i).dim();
-	}
-	return res;
+	return sizeof...(Indices);
     }
     
     template <class... Indices>
     template <size_t N>
-    auto getIndex() -> decltype(*std::get<N>(mIPack))&
-    //typename std::tuple_element<N, std::tuple<Indices...> >::type& MultiIndex<Indices...>::getIndex()
-    {
-	return *std::get<N>(mIPack);
-    }
-
-    template <class... Indices>
-    template <size_t N>
-    auto getIndex() const -> const decltype(*std::get<N>(mIPack))&
+    auto MultiIndex<Indices...>::get() const -> const decltype(*std::get<N>(mIPack))&
     {
 	return *std::get<N>(mIPack);
     }
     
     template <class... Indices>
-    IndefinitIndexBase& MultiIndex<Indices...>::get(size_t n)
-    {
-	if(n >= sizeof...(Indices)){
-	    assert(0);
-	    // throw !!
-	}
-	MultiIndex<Indices...>* t = this;
-	return IndexGetter<sizeof...(Indices)-1>::getIndex(*t, n);
-    }
-
-    template <class... Indices>
-    const IndefinitIndexBase& MultiIndex<Indices...>::get(size_t n) const
+    const IndexBase& MultiIndex<Indices...>::get(size_t n) const
     {
 	if(n >= sizeof...(Indices)){
 	    assert(0);
@@ -599,65 +385,19 @@ namespace MultiArrayTools
     }
 
     template <class... Indices>
-    typename MultiIndex<Indices...>::MetaType MultiIndex<Indices...>::getMetaPos() const
+    typename MultiIndex<Indices...>::MetaType MultiIndex<Indices...>::meta() const
     {
         MetaType metaTuple;
-	MetaPosGetter<sizeof...(Indices)-1>::getMetaPos(metaTuple, mIPack);
+	PackNum<sizeof...(Indices)-1>::getMetaPos(metaTuple, mIPack);
 	return metaTuple;
     }
 
     template <class... Indices>
-    MultiIndex<Indices...>& MultiIndex<Indices...>::atMeta(const MultiIndex<Indices...>::MetaType& metaPos)
+    MultiIndex<Indices...>& MultiIndex<Indices...>::at(const MultiIndex<Indices...>::MetaType& metaPos)
     {
-	MetaSetter<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
+	PackNum<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
 	return *this;
     }
-
-    template <class... Indices>
-    void MultiIndex<Indices...>::copyPos(const MultiIndex<Indices...>& in)
-    {
-	PositionCopy<sizeof...(Indices)-1>::copyPos(*this, in);
-    }
-
-    template <class... Indices>
-    size_t MultiIndex<Indices...>::giveSubStepSize(IndefinitIndexBase* subIndex)
-    {
-	size_t sss = 1;
-	for(size_t i = sizeof...(Indices)-1; i != 0; --i){
-	    IndefinitIndexBase* iibPtr = &get(i);
-	    if(iibPtr == subIndex){
-		return sss;
-	    }
-	    sss *= iibPtr->max();
-	}
-	if(&get(0) == subIndex){
-	    return sss;
-	}
-	else {
-	    return 0;
-	}
-    }
-    
-    template <size_t N>
-    struct TuplePrinter
-    {
-	template <typename... Ts>
-	static void print(std::ostream& os, const std::tuple<Ts...>& meta)
-	{
-	    TuplePrinter<N-1>::print(os, meta);
-	    os << std::get<N>(meta) << '\t';
-	}
-    };
-
-    template <>
-    struct TuplePrinter<0>
-    {
-	template <typename... Ts>
-	static void print(std::ostream& os, const std::tuple<Ts...>& meta)
-	{
-	    os << std::get<0>(meta) << '\t';
-	}
-    };
     
     /******************
      *   MultiRange   *
@@ -668,14 +408,6 @@ namespace MultiArrayTools
 
     template <class... Ranges>
     MultiRange<Ranges...>::MultiRange(const SpaceType& space) : mSpace(space) {}
-    
-    template <class... Ranges>
-    template <size_t N>
-    auto getRange() -> decltype(*std::get<N>(mSpace))&
-    //typename std::tuple_element<N, std::tuple<Ranges...> >::type& MultiRange<Ranges...>::getRange()
-    {
-	return *std::get<N>(mSpace);
-    }
 
     template <class... Ranges>
     template <size_t N>
@@ -688,14 +420,14 @@ namespace MultiArrayTools
     template <class... Ranges>
     size_t MultiRange<Ranges...>::size() const
     {
-	return TupleSize<sizeof...(Ranges)-1>::getSize(mSpace);
+	return PackNum<sizeof...(Ranges)-1>::getSize(mSpace);
     }
     
     template <class... Ranges>
     MultiRangeType MultiRange<Ranges...>::type() const
     {
 	std::vector<MultiRangeType> rvec;
-	RangeVecBuilder<sizeof...(Ranges)-1>::buildRangeVec(rvec, mSpace);
+	PackNum<sizeof...(Ranges)-1>::buildRangeVec(rvec, mSpace);
 	return MultiRangeType(rvec);
     }
 
@@ -709,7 +441,7 @@ namespace MultiArrayTools
     MultiIndex<typename Ranges::IndexType...> MultiRange<Ranges...>::begin() const
     {
 	std::tuple<std::shared_ptr<typename Ranges::IndexType>...> is;
-	IndexSetter<sizeof...(Ranges)-1>::setBegin(is,mSpace);
+	PackNum<sizeof...(Ranges)-1>::setBegin(is,mSpace);
 	return MultiIndex<typename Ranges::IndexType...>(this, is);
     }
 
@@ -717,7 +449,7 @@ namespace MultiArrayTools
     MultiIndex<typename Ranges::IndexType...> MultiRange<Ranges...>::end() const
     {
 	std::tuple<std::shared_ptr<typename Ranges::IndexType>...> is;
-	IndexSetter<sizeof...(Ranges)-1>::setEnd(is,mSpace);
+	PackNum<sizeof...(Ranges)-1>::setEnd(is,mSpace);
 	return ++MultiIndex<typename Ranges::IndexType...>(this, is);
     }
 
@@ -725,7 +457,7 @@ namespace MultiArrayTools
     std::shared_ptr<IndefinitIndexBase> MultiRange<Ranges...>::indexInstance() const
     {
 	std::tuple<std::shared_ptr<typename Ranges::IndexType>...> is;
-	IndexSetter<sizeof...(Ranges)-1>::setBegin(is,mSpace);
+	PackNum<sizeof...(Ranges)-1>::setBegin(is,mSpace);
 	std::shared_ptr<IndefinitIndexBase> sptr(new MultiIndex<typename Ranges::IndexType...>(this, is));
 	return sptr;
     }
@@ -735,6 +467,6 @@ template <typename... Ts>
 std::ostream& operator<<(std::ostream& os,
 			 const std::tuple<Ts...>& meta)
 {
-    MultiArrayTools::TuplePrinter<sizeof...(Ts)-1>::print(os, meta);
+    MultiArrayTools::PackNum<sizeof...(Ts)-1>::print(os, meta);
     return os;
 }
diff --git a/src/multi_range.h b/src/multi_range.h
index f746123..747b3c6 100644
--- a/src/multi_range.h
+++ b/src/multi_range.h
@@ -21,15 +21,13 @@ namespace MultiArrayTools
 	
 	typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
 	typedef std::tuple<decltype(Indices().meta())...> MetaType;
-	typedef IndexInterface<MetaType> IndexI;
-	
+	typedef IndexInterface<MetaType> IndexI;	
 	
     public:
 	
 	MultiIndex() = default;
 	// NO DEFAULT HERE !!!
-	// ( have to subord sub-indices (mMajor) correctly, and not only copy their mMajor pointer to 'in'
-	// which is not major any more in copies!! )
+	// ( have to assign sub-indices (ptr!) correctly )
 	MultiIndex(const MultiIndex& in);
 	MultiIndex& operator=(const MultiIndex& in);
 
@@ -38,24 +36,22 @@ namespace MultiArrayTools
 	
 	virtual MultiIndex& operator++() override;
 	virtual MultiIndex& operator--() override;
-	virtual MultiIndex& operator+=(int n) override;
-	virtual MultiIndex& operator-=(int n) override;
-	
 	virtual MultiIndex& operator=(size_t pos) override;
+
+	template <size_t DIR>
+	MultiIndex& up();
+
+	template <size_t DIR>
+	MultiIndex& down();
 	
 	template <size_t N>
 	auto get() const -> decltype(*std::get<N>(mIPack))&;
-	//typename std::tuple_element<N, std::tuple<std::shared_ptr<Indices>...> >::type const& getIndex() const;
-	
+		
 	const IndexBase& get(size_t n) const;
 	
         virtual MetaType meta() const override;
-	MultiIndex& atMeta(const MetaType& metaPos);
+	virtual MultiIndex& at(const MetaType& metaPos) override;
 	
-	MultiIndex& operator()(Indices&&... inds);
-	MultiIndex& operator()(const Indices&... inds);
-	
-	// dimension of MultiRange; includes ALL degrees of freedom
 	virtual size_t dim() const override;
 	
     protected: